Delete all use of tick_util.h.

webrtc/modules/video_capture/video_capture_impl.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/modules/video_capture/video_capture_impl.h"
 
 #include <stdlib.h>
 
 #include "webrtc/base/refcount.h"
+#include "webrtc/base/timeutils.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/video_capture/video_capture_config.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/logging.h"
-#include "webrtc/system_wrappers/include/tick_util.h"
 
 namespace webrtc {
 namespace videocapturemodule {
 rtc::scoped_refptr<VideoCaptureModule> VideoCaptureImpl::Create(
     const int32_t id,
     VideoCaptureExternal*& externalCapture) {
   rtc::scoped_refptr<VideoCaptureImpl> implementation(
       new rtc::RefCountedObject<VideoCaptureImpl>(id));
   externalCapture = implementation.get();
   return implementation;
@@ skipping 44 matching lines @@
   }
   return -1;
 }
 
 // returns the number of milliseconds until the module want a worker thread to call Process
 int64_t VideoCaptureImpl::TimeUntilNextProcess()
 {
     CriticalSectionScoped cs(&_callBackCs);
     const int64_t kProcessIntervalMs = 300;
     return kProcessIntervalMs -
-        (TickTime::Now() - _lastProcessTime).Milliseconds();
+           (rtc::TimeNanos() - _lastProcessTimeNanos) /
+           rtc::kNumNanosecsPerMillisec;
 }
 
 // Process any pending tasks such as timeouts
 void VideoCaptureImpl::Process()
 {
     CriticalSectionScoped cs(&_callBackCs);
 
-    const TickTime now = TickTime::Now();
-    _lastProcessTime = TickTime::Now();
+    const int64_t now_ns = rtc::TimeNanos();

[stefan-webrtc, 2016/04/19 12:40:47]

Doesn't seem right that we store this in an int64_t if the method returns
uint64_t. Should we instead use milliseconds here? I think the same question is
valid for many other files you've changed.

[nisse-webrtc, 2016/04/19 13:48:51]

I agree this isn't ideal, but it's no change: It's exactly what the TickTime
class was doing. This cl just removes the TickTime wrapper, it keeps ns units
everywhere, even if it's overkill. 

+    _lastProcessTimeNanos = rtc::TimeNanos();
 
     // Handle No picture alarm
 
-    if (_lastProcessFrameCount.Ticks() == _incomingFrameTimes[0].Ticks() &&
+    if (_lastProcessFrameTimeNanos == _incomingFrameTimesNanos[0] &&
         _captureAlarm != Raised)
     {
         if (_noPictureAlarmCallBack && _captureCallBack)
         {
             _captureAlarm = Raised;
             _captureCallBack->OnNoPictureAlarm(_id, _captureAlarm);
         }
     }
-    else if (_lastProcessFrameCount.Ticks() != _incomingFrameTimes[0].Ticks() &&
+    else if (_lastProcessFrameTimeNanos != _incomingFrameTimesNanos[0] &&
              _captureAlarm != Cleared)
     {
         if (_noPictureAlarmCallBack && _captureCallBack)
         {
             _captureAlarm = Cleared;
             _captureCallBack->OnNoPictureAlarm(_id, _captureAlarm);
 
         }
     }
 
     // Handle frame rate callback
-    if ((now - _lastFrameRateCallbackTime).Milliseconds()
+    if ((now_ns - _lastFrameRateCallbackTimeNanos) /
+        rtc::kNumNanosecsPerMillisec
         > kFrameRateCallbackInterval)
     {
         if (_frameRateCallBack && _captureCallBack)
         {
-            const uint32_t frameRate = CalculateFrameRate(now);
+            const uint32_t frameRate = CalculateFrameRate(now_ns);
             _captureCallBack->OnCaptureFrameRate(_id, frameRate);
         }
-        _lastFrameRateCallbackTime = now; // Can be set by EnableFrameRateCallback
+        _lastFrameRateCallbackTimeNanos = now_ns; // Can be set by EnableFrameRateCallback
 
     }
 
-    _lastProcessFrameCount = _incomingFrameTimes[0];
+    _lastProcessFrameTimeNanos = _incomingFrameTimesNanos[0];
 }
 
 VideoCaptureImpl::VideoCaptureImpl(const int32_t id)
     : _id(id),
       _deviceUniqueId(NULL),
       _apiCs(*CriticalSectionWrapper::CreateCriticalSection()),
       _captureDelay(0),
       _requestedCapability(),
       _callBackCs(*CriticalSectionWrapper::CreateCriticalSection()),
-      _lastProcessTime(TickTime::Now()),
-      _lastFrameRateCallbackTime(TickTime::Now()),
+      _lastProcessTimeNanos(rtc::TimeNanos()),
+      _lastFrameRateCallbackTimeNanos(rtc::TimeNanos()),
       _frameRateCallBack(false),
       _noPictureAlarmCallBack(false),
       _captureAlarm(Cleared),
       _setCaptureDelay(0),
       _dataCallBack(NULL),
       _captureCallBack(NULL),
-      _lastProcessFrameCount(TickTime::Now()),
+      _lastProcessFrameTimeNanos(rtc::TimeNanos()),
       _rotateFrame(kVideoRotation_0),
       apply_rotation_(false) {
     _requestedCapability.width = kDefaultWidth;
     _requestedCapability.height = kDefaultHeight;
     _requestedCapability.maxFPS = 30;
     _requestedCapability.rawType = kVideoI420;
     _requestedCapability.codecType = kVideoCodecUnknown;
-    memset(_incomingFrameTimes, 0, sizeof(_incomingFrameTimes));
+    memset(_incomingFrameTimesNanos, 0, sizeof(_incomingFrameTimesNanos));
 }
 
 VideoCaptureImpl::~VideoCaptureImpl()
 {
     DeRegisterCaptureDataCallback();
     DeRegisterCaptureCallback();
     delete &_callBackCs;
     delete &_apiCs;
 
     if (_deviceUniqueId)
@@ skipping 117 matching lines @@
                         << frameInfo.rawType << "to I420.";
             return -1;
         }
 
         if (!apply_rotation) {
           _captureFrame.set_rotation(_rotateFrame);
         } else {
           _captureFrame.set_rotation(kVideoRotation_0);
         }
         _captureFrame.set_ntp_time_ms(captureTime);
-        _captureFrame.set_render_time_ms(TickTime::MillisecondTimestamp());
+        _captureFrame.set_render_time_ms(rtc::Time64());
 
         DeliverCapturedFrame(_captureFrame);
     }
     else // Encoded format
     {
         assert(false);
         return -1;
     }
 
     return 0;
 }
 
 int32_t VideoCaptureImpl::SetCaptureRotation(VideoRotation rotation) {
   CriticalSectionScoped cs(&_apiCs);
   CriticalSectionScoped cs2(&_callBackCs);
   _rotateFrame = rotation;
   return 0;
 }
 
 void VideoCaptureImpl::EnableFrameRateCallback(const bool enable) {
     CriticalSectionScoped cs(&_apiCs);
     CriticalSectionScoped cs2(&_callBackCs);
     _frameRateCallBack = enable;
     if (enable)
     {
-        _lastFrameRateCallbackTime = TickTime::Now();
+      _lastFrameRateCallbackTimeNanos = rtc::TimeNanos();
     }
 }
 
 bool VideoCaptureImpl::SetApplyRotation(bool enable) {
   // We can't take any lock here as it'll cause deadlock with IncomingFrame.
 
   // The effect of this is the last caller wins.
   apply_rotation_ = enable;
   return true;
 }
 
 void VideoCaptureImpl::EnableNoPictureAlarm(const bool enable) {
     CriticalSectionScoped cs(&_apiCs);
     CriticalSectionScoped cs2(&_callBackCs);
     _noPictureAlarmCallBack = enable;
 }
 
 void VideoCaptureImpl::UpdateFrameCount()
 {
-    if (_incomingFrameTimes[0].MicrosecondTimestamp() == 0)
+  if (_incomingFrameTimesNanos[0] / rtc::kNumNanosecsPerMicrosec == 0)
     {
         // first no shift
     }
     else
     {
         // shift
         for (int i = (kFrameRateCountHistorySize - 2); i >= 0; i--)
         {
-            _incomingFrameTimes[i + 1] = _incomingFrameTimes[i];
+            _incomingFrameTimesNanos[i + 1] = _incomingFrameTimesNanos[i];
         }
     }
-    _incomingFrameTimes[0] = TickTime::Now();
+    _incomingFrameTimesNanos[0] = rtc::TimeNanos();
 }
 
-uint32_t VideoCaptureImpl::CalculateFrameRate(const TickTime& now)
+uint32_t VideoCaptureImpl::CalculateFrameRate(int64_t now_ns)
 {
     int32_t num = 0;
     int32_t nrOfFrames = 0;
     for (num = 1; num < (kFrameRateCountHistorySize - 1); num++)
     {
-        if (_incomingFrameTimes[num].Ticks() <= 0
-            || (now - _incomingFrameTimes[num]).Milliseconds() > kFrameRateHistoryWindowMs) // don't use data older than 2sec
+        if (_incomingFrameTimesNanos[num] <= 0 ||
+            (now_ns - _incomingFrameTimesNanos[num]) /
+            rtc::kNumNanosecsPerMillisec >
+                kFrameRateHistoryWindowMs) // don't use data older than 2sec
         {
             break;
         }
         else
         {
             nrOfFrames++;
         }
     }
     if (num > 1)
     {
-        int64_t diff = (now - _incomingFrameTimes[num - 1]).Milliseconds();
+        int64_t diff = (now_ns - _incomingFrameTimesNanos[num - 1]) /
+                       rtc::kNumNanosecsPerMillisec;
         if (diff > 0)
         {
             return uint32_t((nrOfFrames * 1000.0f / diff) + 0.5f);
         }
     }
 
     return nrOfFrames;
 }
 }  // namespace videocapturemodule
 }  // namespace webrtc