Added functions on libjingle API to start and stop the recording of an RtcEventLog.

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.
  */
 
@@ skipping 19 matching lines @@
 #endif
 
 namespace webrtc {
 
 #ifndef ENABLE_RTC_EVENT_LOG
 
 // No-op implementation if flag is not set.
 class RtcEventLogImpl final : public RtcEventLog {
  public:
   void StartLogging(const std::string& file_name, int duration_ms) override {}
+  int StartLogging(FILE* log_file) override { return -1; }
+  int StartLogging(rtc::PlatformFile& log_file) override { return -1; }
   void StopLogging(void) override {}
   void LogVideoReceiveStreamConfig(
       const VideoReceiveStream::Config& config) override {}
   void LogVideoSendStreamConfig(
       const VideoSendStream::Config& config) override {}
   void LogRtpHeader(bool incoming,
                     MediaType media_type,
                     const uint8_t* header,
                     size_t packet_length) override {}
   void LogRtcpPacket(bool incoming,
                      MediaType media_type,
                      const uint8_t* packet,
                      size_t length) override {}
   void LogAudioPlayout(uint32_t ssrc) override {}
 };
 
 #else  // ENABLE_RTC_EVENT_LOG is defined
 
 class RtcEventLogImpl final : public RtcEventLog {
  public:
   RtcEventLogImpl();
 
   void StartLogging(const std::string& file_name, int duration_ms) override;
+  int StartLogging(FILE* log_file) override;
+  int StartLogging(rtc::PlatformFile& log_file) override;
   void StopLogging() override;
   void LogVideoReceiveStreamConfig(
       const VideoReceiveStream::Config& config) override;
   void LogVideoSendStreamConfig(const VideoSendStream::Config& config) override;
   void LogRtpHeader(bool incoming,
                     MediaType media_type,
                     const uint8_t* header,
                     size_t packet_length) override;
   void LogRtcpPacket(bool incoming,
                      MediaType media_type,
                      const uint8_t* packet,
                      size_t length) override;
   void LogAudioPlayout(uint32_t ssrc) override;
 
  private:
+  // Starts logging. This function assumes the file_ has been opened succesfully
+  // and that the start_time_us_ and _duration_us_ have been set.
+  void StartLoggingLocked() EXCLUSIVE_LOCKS_REQUIRED(crit_);
   // Stops logging and clears the stored data and buffers.
   void StopLoggingLocked() EXCLUSIVE_LOCKS_REQUIRED(crit_);
   // Adds a new event to the logfile if logging is active, or adds it to the
   // 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_);
 
   // Amount of time in microseconds to record log events, before starting the
   // actual log.
   const int recent_log_duration_us = 10000000;
 
   rtc::CriticalSection crit_;
   rtc::scoped_ptr<FileWrapper> file_ GUARDED_BY(crit_);
+  rtc::PlatformFile platform_file_ GUARDED_BY(crit_);
+  bool using_platform_file_ GUARDED_BY(crit_);
   rtclog::EventStream stream_ GUARDED_BY(crit_);
   std::deque<rtclog::Event> recent_log_events_ GUARDED_BY(crit_);
   bool currently_logging_ GUARDED_BY(crit_);
   int64_t start_time_us_ GUARDED_BY(crit_);
   int64_t duration_us_ GUARDED_BY(crit_);
   const Clock* const clock_;
 };
 
 namespace {
 // The functions in this namespace convert enums from the runtime format
@@ skipping 31 matching lines @@
   }
   RTC_NOTREACHED();
   return rtclog::ANY;
 }
 
 }  // namespace
 
 // RtcEventLogImpl member functions.
 RtcEventLogImpl::RtcEventLogImpl()
     : file_(FileWrapper::Create()),
+      platform_file_(static_cast<rtc::PlatformFile>(0)),

[the sun, 2015/10/14 09:29:09]

Use C++11 initialization (at member declaration). Also, initialize to
rtc::kInvalidPlatformFileValue.

[ivoc, 2015/10/14 12:23:47]

Nice, was not familiar with this. I changed it for the other variables as well
and got rid of the constructor.

+      using_platform_file_(false),
       stream_(),
       currently_logging_(false),
       start_time_us_(0),
       duration_us_(0),
       clock_(Clock::GetRealTimeClock()) {
 }
 
 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;
   }
-  currently_logging_ = true;
   start_time_us_ = clock_->TimeInMicroseconds();
   duration_us_ = static_cast<int64_t>(duration_ms) * 1000;
+  StartLoggingLocked();
+}
+
+int RtcEventLogImpl::StartLogging(FILE* log_file) {

[the sun, 2015/10/14 09:29:09]

Used?

[ivoc, 2015/10/14 12:23:47]

Not currently, I left it in because I thought it might come in handy, but I
guess it's better to wait until it's actually needed, so I removed it.

+  rtc::CritScope lock(&crit_);
+
+  if (currently_logging_)
+    StopLoggingLocked();
+  RTC_DCHECK(log_file);
+  if (file_->OpenFromFileHandle(log_file, true, false) != 0) {
+    return -1;
+  }
+  // Set the start time and duration to keep logging for 10 minutes.
+  start_time_us_ = clock_->TimeInMicroseconds();
+  duration_us_ = 10 * 60 * 1000000;
+  StartLoggingLocked();
+  return 0;
+}
+
+int RtcEventLogImpl::StartLogging(rtc::PlatformFile& log_file) {
+  rtc::CritScope lock(&crit_);
+
+  if (currently_logging_)

[the sun, 2015/10/14 09:29:09]

please, always use braces

[ivoc, 2015/10/14 12:23:47]

Done.

+    StopLoggingLocked();
+

[the sun, 2015/10/14 09:29:09]

RTC_DCHECK(!using_platform_file)

[ivoc, 2015/10/14 12:23:47]

Done.

+  FILE* file_stream = rtc::FdopenPlatformFileForWriting(log_file);
+  if (!file_stream) {
+    rtc::ClosePlatformFile(log_file);
+    return -1;
+  }
+
+  if (file_->OpenFromFileHandle(file_stream, true, false) != 0) {
+    rtc::ClosePlatformFile(log_file);
+    return -1;
+  }
+  using_platform_file_ = true;
+  // Set the start time and duration to keep logging for 10 minutes.
+  start_time_us_ = clock_->TimeInMicroseconds();
+  duration_us_ = 10 * 60 * 1000000;
+  StartLoggingLocked();
+  return 0;
+}
+
+void RtcEventLogImpl::StartLoggingLocked() {
+  currently_logging_ = true;
   // Write all the recent events to the log file, ignoring any old events.
   for (auto& event : recent_log_events_) {
     if (event.timestamp_us() >= start_time_us_ - recent_log_duration_us) {
       StoreToFile(&event);
     }
   }
   recent_log_events_.clear();
   // Write a LOG_START event to the file.
   rtclog::Event start_event;
   start_event.set_timestamp_us(start_time_us_);
@@ skipping 155 matching lines @@
     currently_logging_ = false;
     // Create a LogEnd event
     rtclog::Event event;
     int64_t timestamp = clock_->TimeInMicroseconds();
     event.set_timestamp_us(timestamp);
     event.set_type(rtclog::Event::LOG_END);
     // Store the event and close the file
     RTC_DCHECK(file_->Open());
     StoreToFile(&event);
     file_->CloseFile();
+    if (using_platform_file_) {
+      rtc::ClosePlatformFile(platform_file_);

[the sun, 2015/10/14 09:29:09]

platform_file_ is never set. Also, you don't need using_platform_file_; you can
compare with rtc::kInvalidPlatformFileValue.

[ivoc, 2015/10/14 12:23:47]

Good points, have updated.

+      using_platform_file_ = false;
+    }
   }
   RTC_DCHECK(!file_->Open());
   stream_.Clear();
 }
 
 void RtcEventLogImpl::HandleEvent(rtclog::Event* event) {
   if (currently_logging_) {
     if (clock_->TimeInMicroseconds() < start_time_us_ + duration_us_) {
       StoreToFile(event);
       return;
@@ skipping 41 matching lines @@
   return result->ParseFromString(dump_buffer);
 }
 
 #endif  // ENABLE_RTC_EVENT_LOG
 
 // RtcEventLog member functions.
 rtc::scoped_ptr<RtcEventLog> RtcEventLog::Create() {
   return rtc::scoped_ptr<RtcEventLog>(new RtcEventLogImpl());
 }
 }  // namespace webrtc