Delete all use of tick_util.h.

webrtc/video/vie_encoder.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/video/vie_encoder.h"
 
 #include <assert.h>
 
 #include <algorithm>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/common_video/include/frame_callback.h"
+#include "webrtc/base/timeutils.h"
 #include "webrtc/common_video/include/video_image.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/pacing/paced_sender.h"
 #include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/modules/video_coding/include/video_coding.h"
 #include "webrtc/modules/video_coding/include/video_coding_defines.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/metrics.h"
-#include "webrtc/system_wrappers/include/tick_util.h"
 #include "webrtc/video/overuse_frame_detector.h"
 #include "webrtc/video/payload_router.h"
 #include "webrtc/video/send_statistics_proxy.h"
 #include "webrtc/video_frame.h"
 
 namespace webrtc {
 
 static const float kStopPaddingThresholdMs = 2000;
 static const int kMinKeyFrameRequestIntervalMs = 300;
 
@@ skipping 219 matching lines @@
     }
   }
 
   // Disable padding if only sending one stream and video isn't suspended and
   // min-transmit bitrate isn't used (applied later).
   if (!video_is_suspended && send_codec.numberOfSimulcastStreams <= 1)
     pad_up_to_bitrate_bps = 0;
 
   // The amount of padding should decay to zero if no frames are being
   // captured/encoded unless a min-transmit bitrate is used.
-  int64_t now_ms = TickTime::MillisecondTimestamp();
+  int64_t now_ms = rtc::Time64();
   if (now_ms - time_of_last_frame_activity_ms > kStopPaddingThresholdMs)
     pad_up_to_bitrate_bps = 0;
 
   // Pad up to min bitrate.
   if (pad_up_to_bitrate_bps < min_transmit_bitrate_bps)
     pad_up_to_bitrate_bps = min_transmit_bitrate_bps;
 
   // Padding may never exceed bitrate estimate.
   if (pad_up_to_bitrate_bps > bitrate_bps)
     pad_up_to_bitrate_bps = bitrate_bps;
@@ skipping 33 matching lines @@
 
 void ViEEncoder::EncodeVideoFrame(const VideoFrame& video_frame) {
   if (!send_payload_router_->active()) {
     // We've paused or we have no channels attached, don't waste resources on
     // encoding.
     return;
   }
   VideoCodecType codec_type;
   {
     rtc::CritScope lock(&data_cs_);
-    time_of_last_frame_activity_ms_ = TickTime::MillisecondTimestamp();
+    time_of_last_frame_activity_ms_ = rtc::Time64();
     if (EncoderPaused()) {
       TraceFrameDropStart();
       return;
     }
     TraceFrameDropEnd();
     codec_type = encoder_config_.codecType;
   }
 
   TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", video_frame.render_time_ms(),
                           "Encode");
@@ skipping 69 matching lines @@
 }
 
 int32_t ViEEncoder::SendData(const uint8_t payload_type,
                              const EncodedImage& encoded_image,
                              const RTPFragmentationHeader* fragmentation_header,
                              const RTPVideoHeader* rtp_video_hdr) {
   RTC_DCHECK(send_payload_router_);
 
   {
     rtc::CritScope lock(&data_cs_);
-    time_of_last_frame_activity_ms_ = TickTime::MillisecondTimestamp();
+    time_of_last_frame_activity_ms_ = rtc::Time64();
   }
 
   if (stats_proxy_)
     stats_proxy_->OnSendEncodedImage(encoded_image, rtp_video_hdr);
 
   bool success = send_payload_router_->RoutePayload(
       encoded_image._frameType, payload_type, encoded_image._timeStamp,
       encoded_image.capture_time_ms_, encoded_image._buffer,
       encoded_image._length, fragmentation_header, rtp_video_hdr);
   overuse_detector_->FrameSent(encoded_image._timeStamp);
@@ skipping 50 matching lines @@
   has_received_rpsi_ = true;
 }
 
 void ViEEncoder::OnReceivedIntraFrameRequest(uint32_t ssrc) {
   // Key frame request from remote side, signal to VCM.
   TRACE_EVENT0("webrtc", "OnKeyFrameRequest");
 
   for (size_t i = 0; i < ssrcs_.size(); ++i) {
     if (ssrcs_[i] != ssrc)
       continue;
-    int64_t now_ms = TickTime::MillisecondTimestamp();
+    int64_t now_ms = rtc::Time64();
     {
       rtc::CritScope lock(&data_cs_);
       if (time_last_intra_request_ms_[i] + kMinKeyFrameRequestIntervalMs >
           now_ms) {
         return;
       }
       time_last_intra_request_ms_[i] = now_ms;
     }
     vcm_->IntraFrameRequest(static_cast<int>(i));
     return;
@@ skipping 52 matching lines @@
     const uint32_t width,
     const uint32_t height) {
   return vp_->SetTargetResolution(width, height, frame_rate);
 }
 
 void QMVideoSettingsCallback::SetTargetFramerate(int frame_rate) {
   vp_->SetTargetFramerate(frame_rate);
 }
 
 }  // namespace webrtc