Delete all use of tick_util.h.

webrtc/modules/video_render/test/testAPI/testAPI.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.
  */
 
@@ skipping 13 matching lines @@
 
 #elif defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <iostream>
 #include <sys/time.h>
 
 #endif
 
+#include "webrtc/base/timeutils.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/modules/video_render/video_render.h"
 #include "webrtc/modules/video_render/video_render_defines.h"
 #include "webrtc/system_wrappers/include/sleep.h"
-#include "webrtc/system_wrappers/include/tick_util.h"
 #include "webrtc/system_wrappers/include/trace.h"
 
 using namespace webrtc;
 
 void GetTestVideoFrame(VideoFrame* frame, uint8_t startColor);
 int TestSingleStream(VideoRender* renderModule);
 int TestFullscreenStream(VideoRender* &renderModule,
                          void* window,
                          const VideoRenderType videoRenderType);
 int TestBitmapText(VideoRender* renderModule);
@@ skipping 255 matching lines @@
     const int height = 288;
 
     VideoFrame videoFrame0;
     videoFrame0.CreateEmptyFrame(width, height, width, half_width, half_width);
 
     const uint32_t renderDelayMs = 500;
 
     for (int i=0; i<TEST_FRAME_NUM; i++) {
         GetTestVideoFrame(&videoFrame0, TEST_STREAM0_START_COLOR);
         // Render this frame with the specified delay
-        videoFrame0.set_render_time_ms(TickTime::MillisecondTimestamp()
+        videoFrame0.set_render_time_ms(rtc::Time64()
                                        + renderDelayMs);
         renderCallback0->RenderFrame(streamId0, videoFrame0);
         SleepMs(1000/TEST_FRAME_RATE);
     }
 
 
     // Shut down
     printf("Closing...\n");
     error = renderModule->StopRender(streamId0);
     assert(error == 0);
@@ skipping 53 matching lines @@
     const int height = 288;
 
     VideoFrame videoFrame0;
     videoFrame0.CreateEmptyFrame(width, height, width, half_width, half_width);
 
     const uint32_t renderDelayMs = 500;
 
     for (int i=0; i<TEST_FRAME_NUM; i++) {
         GetTestVideoFrame(&videoFrame0, TEST_STREAM0_START_COLOR);
         // Render this frame with the specified delay
-        videoFrame0.set_render_time_ms(TickTime::MillisecondTimestamp() +
+        videoFrame0.set_render_time_ms(rtc::Time64() +
                                        renderDelayMs);
         renderCallback0->RenderFrame(streamId0, videoFrame0);
         SleepMs(1000/TEST_FRAME_RATE);
     }
     // Sleep and let all frames be rendered before closing
     SleepMs(renderDelayMs*2);
 
 
     // Shut down
     printf("Closing...\n");
@@ skipping 64 matching lines @@
     videoFrame2.CreateEmptyFrame(width, height, width, half_width, half_width);
     VideoFrame videoFrame3;
     videoFrame3.CreateEmptyFrame(width, height, width, half_width, half_width);
 
     const uint32_t renderDelayMs = 500;
 
     // Render frames with the specified delay.
     for (int i=0; i<TEST_FRAME_NUM; i++) {
       GetTestVideoFrame(&videoFrame0, TEST_STREAM0_START_COLOR);
 
-      videoFrame0.set_render_time_ms(TickTime::MillisecondTimestamp() +
+      videoFrame0.set_render_time_ms(rtc::Time64() +
                                      renderDelayMs);
       renderCallback0->RenderFrame(streamId0, videoFrame0);
 
       GetTestVideoFrame(&videoFrame1, TEST_STREAM1_START_COLOR);
-      videoFrame1.set_render_time_ms(TickTime::MillisecondTimestamp() +
+      videoFrame1.set_render_time_ms(rtc::Time64() +
                                      renderDelayMs);
       renderCallback1->RenderFrame(streamId1, videoFrame1);
 
       GetTestVideoFrame(&videoFrame2,  TEST_STREAM2_START_COLOR);
-      videoFrame2.set_render_time_ms(TickTime::MillisecondTimestamp() +
+      videoFrame2.set_render_time_ms(rtc::Time64() +
                                      renderDelayMs);
       renderCallback2->RenderFrame(streamId2, videoFrame2);
 
       GetTestVideoFrame(&videoFrame3, TEST_STREAM3_START_COLOR);
-      videoFrame3.set_render_time_ms(TickTime::MillisecondTimestamp() +
+      videoFrame3.set_render_time_ms(rtc::Time64() +
                                      renderDelayMs);
       renderCallback3->RenderFrame(streamId3, videoFrame3);
 
       SleepMs(1000/TEST_FRAME_RATE);
     }
 
     // Shut down
     printf("Closing...\n");
     error = renderModule->StopRender(streamId0);
     assert(error == 0);
@@ skipping 37 matching lines @@
 
     const int width = 352;
     const int half_width = (width + 1) / 2;
     const int height = 288;
     VideoFrame videoFrame0;
     videoFrame0.CreateEmptyFrame(width, height, width, half_width, half_width);
 
     const uint32_t renderDelayMs = 500;
     int frameCount = TEST_FRAME_NUM;
     for (int i=0; i<frameCount; i++) {
-        videoFrame0.set_render_time_ms(TickTime::MillisecondTimestamp() +
+        videoFrame0.set_render_time_ms(rtc::Time64() +
                                        renderDelayMs);
         renderCallback0->RenderFrame(streamId0, videoFrame0);
         SleepMs(33);
     }
 
     // Sleep and let all frames be rendered before closing
     SleepMs(2*renderDelayMs);
 
     // Shut down
     printf("Closing...\n");
@@ skipping 77 matching lines @@
     Display* display;
     WebRtcCreateWindow(&testWindow, &display, 0, 352, 288);
     VideoRenderType windowType = kRenderX11;
     window = (void*)testWindow;
 #endif // WEBRTC_LINUX
 
     RunVideoRenderTests(window, windowType);
     return 0;
 }
 #endif  // !WEBRTC_MAC