Move RtcEventLog object from inside VoiceEngine to Call.

webrtc/call/rtc_event_log.cc

 /*
  *  Copyright (c) 2015 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/call/rtc_event_log.h"
 
 #include <deque>
 #include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/thread_annotations.h"
+#include "webrtc/base/thread_checker.h"
 #include "webrtc/call.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/file_wrapper.h"
 
 #ifdef ENABLE_RTC_EVENT_LOG
 // Files generated at build-time by the protobuf compiler.
 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
 #include "external/webrtc/webrtc/call/rtc_event_log.pb.h"
 #else
 #include "webrtc/call/rtc_event_log.pb.h"
 #endif
 #endif
 
 namespace webrtc {
 
 #ifndef ENABLE_RTC_EVENT_LOG
 
 // No-op implementation if flag is not set.
 class RtcEventLogImpl final : public RtcEventLog {
  public:
   void SetBufferDuration(int64_t buffer_duration_us) override {}
   void StartLogging(const std::string& file_name, int duration_ms) override {}
-  bool StartLogging(rtc::PlatformFile log_file) override { return false; }
+  bool StartLogging(rtc::PlatformFile log_file,
+                    int64_t max_size_bytes) override {
+    return false;
+  }
   void StopLogging(void) override {}
   void LogVideoReceiveStreamConfig(
       const VideoReceiveStream::Config& config) override {}
   void LogVideoSendStreamConfig(
       const VideoSendStream::Config& config) override {}
   void LogRtpHeader(PacketDirection direction,
                     MediaType media_type,
                     const uint8_t* header,
                     size_t packet_length) override {}
   void LogRtcpPacket(PacketDirection direction,
                      MediaType media_type,
                      const uint8_t* packet,
                      size_t length) override {}
   void LogAudioPlayout(uint32_t ssrc) override {}
   void LogBwePacketLossEvent(int32_t bitrate,
                              uint8_t fraction_loss,
                              int32_t total_packets) override {}
 };
 
 #else  // ENABLE_RTC_EVENT_LOG is defined
 
 class RtcEventLogImpl final : public RtcEventLog {
  public:
   RtcEventLogImpl();
+  ~RtcEventLogImpl();
 
   void SetBufferDuration(int64_t buffer_duration_us) override;
   void StartLogging(const std::string& file_name, int duration_ms) override;
-  bool StartLogging(rtc::PlatformFile log_file) override;
+  bool StartLogging(rtc::PlatformFile log_file,
+                    int64_t max_size_bytes) override;
   void StopLogging() override;
   void LogVideoReceiveStreamConfig(
       const VideoReceiveStream::Config& config) override;
   void LogVideoSendStreamConfig(const VideoSendStream::Config& config) override;
   void LogRtpHeader(PacketDirection direction,
                     MediaType media_type,
                     const uint8_t* header,
                     size_t packet_length) override;
   void LogRtcpPacket(PacketDirection direction,
                      MediaType media_type,
@@ skipping 14 matching lines @@
   // list of recent log events otherwise.
   void HandleEvent(rtclog::Event* event) EXCLUSIVE_LOCKS_REQUIRED(crit_);
   // Writes the event to the file. Note that this will destroy the state of the
   // input argument.
   void StoreToFile(rtclog::Event* event) EXCLUSIVE_LOCKS_REQUIRED(crit_);
   // Adds the event to the list of recent events, and removes any events that
   // are too old and no longer fall in the time window.
   void AddRecentEvent(const rtclog::Event& event)
       EXCLUSIVE_LOCKS_REQUIRED(crit_);
 
+  rtc::ThreadChecker thread_checker_;
   rtc::CriticalSection crit_;
   rtc::scoped_ptr<FileWrapper> file_ GUARDED_BY(crit_) =
       rtc::scoped_ptr<FileWrapper>(FileWrapper::Create());
   rtc::PlatformFile platform_file_ GUARDED_BY(crit_) =
       rtc::kInvalidPlatformFileValue;
   rtclog::EventStream stream_ GUARDED_BY(crit_);
   std::deque<rtclog::Event> recent_log_events_ GUARDED_BY(crit_);
   std::vector<rtclog::Event> config_events_ GUARDED_BY(crit_);
 
   // Microseconds to record log events, before starting the actual log.
@@ skipping 56 matching lines @@
 
 // RtcEventLogImpl member functions.
 RtcEventLogImpl::RtcEventLogImpl()
     : file_(FileWrapper::Create()),
       stream_(),
       buffer_duration_us_(10000000),
       currently_logging_(false),
       start_time_us_(0),
       duration_us_(0),
       clock_(Clock::GetRealTimeClock()) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+}
+
+RtcEventLogImpl::~RtcEventLogImpl() {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void RtcEventLogImpl::SetBufferDuration(int64_t buffer_duration_us) {
   rtc::CritScope lock(&crit_);
   buffer_duration_us_ = buffer_duration_us;
 }
 
 void RtcEventLogImpl::StartLogging(const std::string& file_name,
                                    int duration_ms) {
   rtc::CritScope lock(&crit_);
   if (currently_logging_) {
     StopLoggingLocked();
   }
   if (file_->OpenFile(file_name.c_str(), false) != 0) {
     return;
   }
   start_time_us_ = clock_->TimeInMicroseconds();
   duration_us_ = static_cast<int64_t>(duration_ms) * 1000;
   StartLoggingLocked();
 }
 
-bool RtcEventLogImpl::StartLogging(rtc::PlatformFile log_file) {
+bool RtcEventLogImpl::StartLogging(rtc::PlatformFile log_file,
+                                   int64_t max_size_bytes) {

[stefan-webrtc, 2016/03/11 10:11:53]

Can we break this change out to a separate CL, or is the max size depending on
moving to Call?

[terelius, 2016/03/11 12:30:44]

I think the total amount of work will decrease by doing it in one CL, and this
CL would not become significantly smaller by doing it separately. The file size
limit change just adds an argument to all the layers between the event log and
PeerConnection, and this CL is rewriting that anyway.

I guess we could do
bool StartLogging(rtc::PlatformFile log_file, int64_t max_size_bytes){
  StartLogging(logfile)
}
to avoid having to change all call sites right now though.

[ivoc, 2016/03/16 17:00:32]

The max size and moving to call are pretty independent, however, since we're
changing the peerconnection API in this CL, I think it makes sense to include it
here as well, to avoid having to change it again soon afterwards. 
I like Bjorn's suggestion, I will implement it like that.

[stefan-webrtc, 2016/03/21 13:25:47]

Thanks.

   rtc::CritScope lock(&crit_);
 
   if (currently_logging_) {
     StopLoggingLocked();
   }
   RTC_DCHECK(platform_file_ == rtc::kInvalidPlatformFileValue);
 
   FILE* file_stream = rtc::FdopenPlatformFileForWriting(log_file);
   if (!file_stream) {
     rtc::ClosePlatformFile(log_file);
@@ skipping 299 matching lines @@
 }
 
 #endif  // ENABLE_RTC_EVENT_LOG
 
 // RtcEventLog member functions.
 rtc::scoped_ptr<RtcEventLog> RtcEventLog::Create() {
   return rtc::scoped_ptr<RtcEventLog>(new RtcEventLogImpl());
 }
 
 }  // namespace webrtc