Delete all log messages depending on system_wrappers.

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();
@@ skipping 32 matching lines @@
 RtcEventLogHelperThread::~RtcEventLogHelperThread() {
   ControlMessage message;
   message.message_type = ControlMessage::TERMINATE_THREAD;
   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();
   wake_periodically_.Set();  // Wake up the output thread.
   thread_.Stop();            // Wait for the thread to terminate.
 }
 
 void RtcEventLogHelperThread::WaitForFileFinished() {
   wake_from_hibernation_.Set();
   wake_periodically_.Set();
@@ skipping 65 matching lines @@
   // Serialize the events in the event queue.
   while (!history_.empty() && !stop) {
     stop = AppendEventToString(history_.front().get());
     if (!stop) {
       history_.pop_front();
     }
   }
 
   // Write to file.
   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());
     return;
   }
   written_bytes_ += output_string_.size();
 
   // Free the allocated memory since we probably won't need this amount of
   // space again.
   output_string_.clear();
   output_string_.shrink_to_fit();
@@ skipping 24 matching lines @@
       if (IsConfigEvent(*most_recent_event_)) {
         config_history_.push_back(std::move(most_recent_event_));
       }
       has_recent_event_ = event_queue_->Remove(&most_recent_event_);
     }
     message_received = true;
   }
 
   // Write string to file.
   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());
     return message_received;
   }
   written_bytes_ += output_string_.size();
 
   // We want to stop logging if we have reached the file size limit. We also
   // want to stop logging if the remaining events are more recent than the
   // time limit, or in other words if we have terminated the loop despite
   // having more events in the queue.
@@ skipping 14 matching lines @@
   // 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_, 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());
     }
     written_bytes_ += output_string_.size();
   }
 
   max_size_bytes_ = std::numeric_limits<int64_t>::max();
   written_bytes_ = 0;
   start_time_ = 0;
   stop_time_ = std::numeric_limits<int64_t>::max();
@@ skipping 61 matching lines @@
 }
 
 void RtcEventLogHelperThread::ThreadOutputFunction(void* obj) {
   RtcEventLogHelperThread* helper = static_cast<RtcEventLogHelperThread*>(obj);
   helper->ProcessEvents();
 }
 
 }  // namespace webrtc
 
 #endif  // ENABLE_RTC_EVENT_LOG