Delete all use of tick_util.h.

webrtc/modules/video_capture/test/video_capture_unittest.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 <stdio.h>
 
 #include <map>
 #include <memory>
 #include <sstream>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/scoped_ref_ptr.h"
+#include "webrtc/base/timeutils.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/modules/video_capture/video_capture.h"
 #include "webrtc/modules/video_capture/video_capture_factory.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/sleep.h"
-#include "webrtc/system_wrappers/include/tick_util.h"
 #include "webrtc/video_frame.h"
 
 using webrtc::CriticalSectionWrapper;
 using webrtc::CriticalSectionScoped;
 using webrtc::SleepMs;
-using webrtc::TickTime;
 using webrtc::VideoCaptureAlarm;
 using webrtc::VideoCaptureCapability;
 using webrtc::VideoCaptureDataCallback;
 using webrtc::VideoCaptureFactory;
 using webrtc::VideoCaptureFeedBack;
 using webrtc::VideoCaptureModule;
 
 
 #define WAIT_(ex, timeout, res) \
   do { \
     res = (ex); \
-    int64_t start = TickTime::MillisecondTimestamp(); \
-    while (!res && TickTime::MillisecondTimestamp() < start + timeout) { \
+    int64_t start = rtc::Time64(); \
+    while (!res && rtc::Time64() < start + timeout) { \
       SleepMs(5); \
       res = (ex); \
     } \
   } while (0)
 
 #define EXPECT_TRUE_WAIT(ex, timeout) \
   do { \
     bool res; \
     WAIT_(ex, timeout, res); \
     if (!res) EXPECT_TRUE(ex); \
@@ skipping 56 matching lines @@
     // orientation.
     EXPECT_TRUE(height == capability_.height || height == capability_.width);
     EXPECT_TRUE(width == capability_.width || width == capability_.height);
 #else
     EXPECT_EQ(height, capability_.height);
     EXPECT_EQ(width, capability_.width);
     EXPECT_EQ(rotate_frame_, videoFrame.rotation());
 #endif
     // RenderTimstamp should be the time now.
     EXPECT_TRUE(
-        videoFrame.render_time_ms() >= TickTime::MillisecondTimestamp()-30 &&
-        videoFrame.render_time_ms() <= TickTime::MillisecondTimestamp());
+        videoFrame.render_time_ms() >= rtc::Time64()-30 &&
+        videoFrame.render_time_ms() <= rtc::Time64());
 
     if ((videoFrame.render_time_ms() >
             last_render_time_ms_ + (1000 * 1.1) / capability_.maxFPS &&
             last_render_time_ms_ > 0) ||
         (videoFrame.render_time_ms() <
             last_render_time_ms_ + (1000 * 0.9) / capability_.maxFPS &&
             last_render_time_ms_ > 0)) {
       timing_warnings_++;
     }
 
@@ skipping 137 matching lines @@
 
 #ifdef WEBRTC_MAC
 // Currently fails on Mac 64-bit, see
 // https://bugs.chromium.org/p/webrtc/issues/detail?id=5406
 #define MAYBE_CreateDelete DISABLED_CreateDelete
 #else
 #define MAYBE_CreateDelete CreateDelete
 #endif
 TEST_F(VideoCaptureTest, MAYBE_CreateDelete) {
   for (int i = 0; i < 5; ++i) {
-    int64_t start_time = TickTime::MillisecondTimestamp();
+    int64_t start_time = rtc::Time64();
     TestVideoCaptureCallback capture_observer;
     rtc::scoped_refptr<VideoCaptureModule> module(
         OpenVideoCaptureDevice(0, &capture_observer));
     ASSERT_TRUE(module.get() != NULL);
 
     VideoCaptureCapability capability;
 #ifndef WEBRTC_MAC
     device_info_->GetCapability(module->CurrentDeviceName(), 0, capability);
 #else
     capability.width = kTestWidth;
     capability.height = kTestHeight;
     capability.maxFPS = kTestFramerate;
     capability.rawType = webrtc::kVideoUnknown;
 #endif
     capture_observer.SetExpectedCapability(capability);
     ASSERT_NO_FATAL_FAILURE(StartCapture(module.get(), capability));
 
     // Less than 4s to start the camera.
-    EXPECT_LE(TickTime::MillisecondTimestamp() - start_time, 4000);
+    EXPECT_LE(rtc::Time64() - start_time, 4000);
 
     // Make sure 5 frames are captured.
     EXPECT_TRUE_WAIT(capture_observer.incoming_frames() >= 5, kTimeOut);
 
     EXPECT_GE(capture_observer.capture_delay(), 0);
 
-    int64_t stop_time = TickTime::MillisecondTimestamp();
+    int64_t stop_time = rtc::Time64();
     EXPECT_EQ(0, module->StopCapture());
     EXPECT_FALSE(module->CaptureStarted());
 
     // Less than 3s to stop the camera.
-    EXPECT_LE(TickTime::MillisecondTimestamp() - stop_time, 3000);
+    EXPECT_LE(rtc::Time64() - stop_time, 3000);
   }
 }
 
 #ifdef WEBRTC_MAC
 // Currently fails on Mac 64-bit, see
 // https://bugs.chromium.org/p/webrtc/issues/detail?id=5406
 #define MAYBE_Capabilities DISABLED_Capabilities
 #else
 #define MAYBE_Capabilities Capabilities
 #endif
@@ skipping 165 matching lines @@
 
 // Test frame rate and no picture alarm.
 // Flaky on Win32, see webrtc:3270.
 #if defined(WEBRTC_WIN) || defined(WEBRTC_MAC)
 #define MAYBE_FrameRate DISABLED_FrameRate
 #else
 #define MAYBE_FrameRate FrameRate
 #endif
 TEST_F(VideoCaptureExternalTest, MAYBE_FrameRate) {
   int64_t testTime = 3;
-  TickTime startTime = TickTime::Now();
+  int64_t startTime = rtc::TimeNanos();

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

Seems like startTime should be the same type as returned by rtc::TimeNanos(),
and that way you'd avoid the casts below.

[nisse-webrtc, 2016/04/19 12:19:25]

Done. Typing seem a bit confused, TimeNanos and TimeMicros return unsigned
64-bit values, but signed int64_t is used for timestamps almost everywhere else.

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

Do you think there's a reason to return uint64_t from those methods, or should
we change to int64_t? Most code uses int64_t as it's using milliseconds mostly.

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

I don't have a strong opinion here. Changing return type to int64_t (signed) is
fine with me. There seems to be a few places that assume that negative values
can't occur, though, using -1 to mean unset.

As far as I've seen, code using ns or us units also seem to use signed int64_t. 

 
-  while ((TickTime::Now() - startTime).Milliseconds() < testTime * 1000) {
+  while ((static_cast<int64_t>(rtc::TimeNanos()) - startTime) /
+         rtc::kNumNanosecsPerMillisec <
+         testTime * 1000) {
      size_t length = webrtc::CalcBufferSize(webrtc::kI420,
                                             test_frame_.width(),
                                             test_frame_.height());
      std::unique_ptr<uint8_t[]> test_buffer(new uint8_t[length]);
      webrtc::ExtractBuffer(test_frame_, length, test_buffer.get());
      EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
        length, capture_callback_.capability(), 0));
     SleepMs(100);
   }
   EXPECT_TRUE(capture_feedback_.frame_rate() >= 8 &&
               capture_feedback_.frame_rate() <= 10);
   SleepMs(500);
   EXPECT_EQ(webrtc::Raised, capture_feedback_.alarm());
 
-  startTime = TickTime::Now();
-  while ((TickTime::Now() - startTime).Milliseconds() < testTime * 1000) {
+  startTime = rtc::TimeNanos();
+  while ((static_cast<int64_t>(rtc::TimeNanos()) - startTime) /
+         rtc::kNumNanosecsPerMillisec <
+         testTime * 1000) {
     size_t length = webrtc::CalcBufferSize(webrtc::kI420,
                                            test_frame_.width(),
                                            test_frame_.height());
     std::unique_ptr<uint8_t[]> test_buffer(new uint8_t[length]);
     webrtc::ExtractBuffer(test_frame_, length, test_buffer.get());
     EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
       length, capture_callback_.capability(), 0));
     SleepMs(1000 / 30);
   }
   EXPECT_EQ(webrtc::Cleared, capture_feedback_.alarm());
@@ skipping 18 matching lines @@
     length, capture_callback_.capability(), 0));
   EXPECT_EQ(0, capture_module_->SetCaptureRotation(webrtc::kVideoRotation_180));
   capture_callback_.SetExpectedCaptureRotation(webrtc::kVideoRotation_180);
   EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
     length, capture_callback_.capability(), 0));
   EXPECT_EQ(0, capture_module_->SetCaptureRotation(webrtc::kVideoRotation_270));
   capture_callback_.SetExpectedCaptureRotation(webrtc::kVideoRotation_270);
   EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
     length, capture_callback_.capability(), 0));
 }