Convert rtc_event_log from webrtc::Clock to rtc::TimeMicros.

webrtc/logging/rtc_event_log/rtc_event_log_helper_thread.cc

 /*
  *  Copyright (c) 2016 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/logging/rtc_event_log/rtc_event_log_helper_thread.h"
 
 #include <algorithm>
 
 #include "webrtc/base/checks.h"
+#include "webrtc/base/timeutils.h"
 #include "webrtc/system_wrappers/include/logging.h"
 
 #ifdef ENABLE_RTC_EVENT_LOG
 
 namespace webrtc {
 
 namespace {
 const int kEventsInHistory = 10000;
 
 bool IsConfigEvent(const rtclog::Event& event) {
   rtclog::Event_EventType event_type = event.type();
   return event_type == rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT ||
          event_type == rtclog::Event::VIDEO_SENDER_CONFIG_EVENT ||
          event_type == rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT ||
          event_type == rtclog::Event::AUDIO_SENDER_CONFIG_EVENT;
 }
 }  // namespace
 
 // RtcEventLogImpl member functions.
 RtcEventLogHelperThread::RtcEventLogHelperThread(
     SwapQueue<ControlMessage>* message_queue,
-    SwapQueue<std::unique_ptr<rtclog::Event>>* event_queue,
-    const Clock* const clock)
+    SwapQueue<std::unique_ptr<rtclog::Event>>* event_queue)
     : message_queue_(message_queue),
       event_queue_(event_queue),
       history_(kEventsInHistory),
       config_history_(),
       file_(FileWrapper::Create()),
       thread_(&ThreadOutputFunction, this, "RtcEventLog thread"),
       max_size_bytes_(std::numeric_limits<int64_t>::max()),
       written_bytes_(0),
       start_time_(0),
       stop_time_(std::numeric_limits<int64_t>::max()),
       has_recent_event_(false),
       most_recent_event_(),
       output_string_(),
       wake_periodically_(false, false),
       wake_from_hibernation_(false, false),
-      file_finished_(false, false),
-      clock_(clock) {
+      file_finished_(false, false) {
   RTC_DCHECK(message_queue_);
   RTC_DCHECK(event_queue_);
-  RTC_DCHECK(clock_);
   thread_.Start();
 }
 
 RtcEventLogHelperThread::~RtcEventLogHelperThread() {
   ControlMessage message;
   message.message_type = ControlMessage::TERMINATE_THREAD;
-  message.stop_time = clock_->TimeInMicroseconds();
+  message.stop_time = rtc::TimeMicros();
   while (!message_queue_->Insert(&message)) {
     // We can't destroy the event log until we have stopped the thread,
     // so clear the message queue and try again. Note that if we clear
     // any STOP_FILE events, then the threads calling StopLogging would likely
     // wait indefinitely. However, there should not be any such calls as we
     // are executing the destructor.
     LOG(LS_WARNING) << "Clearing message queue to terminate thread.";
     message_queue_->Clear();
   }
   wake_from_hibernation_.Set();
@@ skipping 29 matching lines @@
   event_stream.mutable_stream(0)->Swap(event);
   return stop;
 }
 
 bool RtcEventLogHelperThread::LogToMemory() {
   RTC_DCHECK(!file_->is_open());
   bool message_received = false;
 
   // Process each event earlier than the current time and append it to the
   // appropriate history_.
-  int64_t current_time = clock_->TimeInMicroseconds();
+  int64_t current_time = rtc::TimeMicros();
   if (!has_recent_event_) {
     has_recent_event_ = event_queue_->Remove(&most_recent_event_);
   }
   while (has_recent_event_ &&
          most_recent_event_->timestamp_us() <= current_time) {
     if (IsConfigEvent(*most_recent_event_)) {
       config_history_.push_back(std::move(most_recent_event_));
     } else {
       history_.push_back(std::move(most_recent_event_));
     }
@@ skipping 47 matching lines @@
   }
 }
 
 bool RtcEventLogHelperThread::LogToFile() {
   RTC_DCHECK(file_->is_open());
   output_string_.clear();
   bool message_received = false;
 
   // Append each event older than both the current time and the stop time
   // to the output_string_.
-  int64_t current_time = clock_->TimeInMicroseconds();
+  int64_t current_time = rtc::TimeMicros();
   int64_t time_limit = std::min(current_time, stop_time_);
   if (!has_recent_event_) {
     has_recent_event_ = event_queue_->Remove(&most_recent_event_);
   }
   bool stop = false;
   while (!stop && has_recent_event_ &&
          most_recent_event_->timestamp_us() <= time_limit) {
     stop = AppendEventToString(most_recent_event_.get());
     if (!stop) {
       if (IsConfigEvent(*most_recent_event_)) {
@@ skipping 27 matching lines @@
 
 void RtcEventLogHelperThread::StopLogFile() {
   RTC_DCHECK(file_->is_open());
   output_string_.clear();
 
   rtclog::Event end_event;
   // This function can be called either because we have reached the stop time,
   // or because we have reached the log file size limit. Therefore, use the
   // current time if we have not reached the time limit.
   end_event.set_timestamp_us(
-      std::min(stop_time_, clock_->TimeInMicroseconds()));
+      std::min(stop_time_, rtc::TimeMicros()));
   end_event.set_type(rtclog::Event::LOG_END);
   AppendEventToString(&end_event);
 
   if (written_bytes_ + static_cast<int64_t>(output_string_.size()) <=
       max_size_bytes_) {
     if (!file_->Write(output_string_.data(), output_string_.size())) {
       LOG(LS_ERROR) << "FileWrapper failed to write WebRtcEventLog file.";
       // The current FileWrapper implementation closes the file on error.
       RTC_DCHECK(!file_->is_open());
     }
@@ skipping 69 matching lines @@
 
 bool RtcEventLogHelperThread::ThreadOutputFunction(void* obj) {
   RtcEventLogHelperThread* helper = static_cast<RtcEventLogHelperThread*>(obj);
   helper->ProcessEvents();
   return false;
 }
 
 }  // namespace webrtc
 
 #endif  // ENABLE_RTC_EVENT_LOG