Modularize RtcEventLog

webrtc/logging/rtc_event_log/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/logging/rtc_event_log/rtc_event_log.h"
 
 #include <atomic>
 #include <deque>
 #include <functional>
 #include <limits>
 #include <memory>
 #include <utility>
 #include <vector>
 
+#include "webrtc/logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.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_packet/app.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/common_header.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/psfb.h"
@@ skipping 58 matching lines @@
     return true;
   }
 
  private:
   std::unique_ptr<T> resource_;
   std::function<void(std::unique_ptr<T>)> handler_;
 };
 }  // namespace
 
 class RtcEventLogImpl final : public RtcEventLog {
-  friend std::unique_ptr<RtcEventLog> RtcEventLog::Create();
+  friend std::unique_ptr<RtcEventLog> RtcEventLog::Create(EncodingType);
 
  public:
   ~RtcEventLogImpl() override;
 
   bool StartLogging(const std::string& file_name,
                     int64_t max_size_bytes) override;
   bool StartLogging(rtc::PlatformFile platform_file,
                     int64_t max_size_bytes) override;
   void StopLogging() override;
   void LogVideoReceiveStreamConfig(const rtclog::StreamConfig& config) override;
@@ skipping 31 matching lines @@
       const AudioEncoderRuntimeConfig& config) override;
   void LogProbeClusterCreated(int id,
                               int bitrate_bps,
                               int min_probes,
                               int min_bytes) override;
   void LogProbeResultSuccess(int id, int bitrate_bps) override;
   void LogProbeResultFailure(int id,
                              ProbeFailureReason failure_reason) override;
 
  private:
+  // Creation is done by RtcEventLog::Create.
+  explicit RtcEventLogImpl(std::unique_ptr<RtcEventLogEncoder> event_encoder);
+
   void StartLoggingInternal(std::unique_ptr<FileWrapper> file,
                             int64_t max_size_bytes);
 
-  RtcEventLogImpl();  // Creation is done by RtcEventLog::Create.
-
   void StoreEvent(std::unique_ptr<rtclog::Event> event);
   void LogProbeResult(int id,
                       rtclog::BweProbeResult::ResultType result,
                       int bitrate_bps);
 
   // Appends an event to the output protobuf string, returning true on success.
   // Fails and returns false in case the limit on output size prevents the
   // event from being added; in this case, the output string is left unchanged.
   bool AppendEventToString(rtclog::Event* event,
                            ProtoString* output_string) RTC_WARN_UNUSED_RESULT;
@@ skipping 18 matching lines @@
       ACCESS_ON(task_queue_);
 
   // History containing the most recent (non-configuration) events (~10s).
   std::deque<std::unique_ptr<rtclog::Event>> history_ ACCESS_ON(task_queue_);
 
   std::unique_ptr<FileWrapper> file_ ACCESS_ON(task_queue_);
 
   size_t max_size_bytes_ ACCESS_ON(task_queue_);
   size_t written_bytes_ ACCESS_ON(task_queue_);
 
+  std::unique_ptr<RtcEventLogEncoder> event_encoder_ ACCESS_ON(task_queue_);
+
   // Keep this last to ensure it destructs first, or else tasks living on the
   // queue might access other members after they've been torn down.
   rtc::TaskQueue task_queue_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(RtcEventLogImpl);
 };
 
 namespace {
 // The functions in this namespace convert enums from the runtime format
 // that the rest of the WebRtc project can use, to the corresponding
@@ skipping 38 matching lines @@
       return rtclog::BweProbeResult::TIMEOUT;
   }
   RTC_NOTREACHED();
   return rtclog::BweProbeResult::SUCCESS;
 }
 
 }  // namespace
 
 std::atomic<int> RtcEventLogImpl::log_count_(0);
 
-RtcEventLogImpl::RtcEventLogImpl()
+RtcEventLogImpl::RtcEventLogImpl(
+    std::unique_ptr<RtcEventLogEncoder> event_encoder)
     : file_(FileWrapper::Create()),
       max_size_bytes_(std::numeric_limits<decltype(max_size_bytes_)>::max()),
       written_bytes_(0),
+      event_encoder_(std::move(event_encoder)),
       task_queue_("rtc_event_log") {}
 
 RtcEventLogImpl::~RtcEventLogImpl() {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&owner_sequence_checker_);
 
   // If we're logging to the file, this will stop that. Blocking function.
   StopLogging();
 
   int count = std::atomic_fetch_sub(&RtcEventLogImpl::log_count_, 1) - 1;
   RTC_DCHECK_GE(count, 0);
@@ skipping 584 matching lines @@
   while ((bytes_read = dump_file->Read(tmp_buffer, sizeof(tmp_buffer))) > 0) {
     dump_buffer.append(tmp_buffer, bytes_read);
   }
   dump_file->CloseFile();
   return result->ParseFromString(dump_buffer);
 }
 
 #endif  // ENABLE_RTC_EVENT_LOG
 
 // RtcEventLog member functions.
-std::unique_ptr<RtcEventLog> RtcEventLog::Create() {
+std::unique_ptr<RtcEventLog> RtcEventLog::Create(EncodingType encoding_type) {
 #ifdef ENABLE_RTC_EVENT_LOG
   // TODO(eladalon): Known issue - there's a race over |log_count_| here.
   constexpr int kMaxLogCount = 5;
   int count = 1 + std::atomic_fetch_add(&RtcEventLogImpl::log_count_, 1);
   if (count > kMaxLogCount) {
     LOG(LS_WARNING) << "Denied creation of additional WebRTC event logs. "
                     << count - 1 << " logs open already.";
     std::atomic_fetch_sub(&RtcEventLogImpl::log_count_, 1);
-    return std::unique_ptr<RtcEventLog>(new RtcEventLogNullImpl());
+    return CreateNull();
   }
-  return std::unique_ptr<RtcEventLog>(new RtcEventLogImpl());
+  auto encoder = CreateEncoder(encoding_type);
+  return rtc::WrapUnique<RtcEventLog>(new RtcEventLogImpl(std::move(encoder)));
 #else
   return CreateNull();
 #endif  // ENABLE_RTC_EVENT_LOG
 }
 
 std::unique_ptr<RtcEventLog> RtcEventLog::CreateNull() {
   return std::unique_ptr<RtcEventLog>(new RtcEventLogNullImpl());
 }
 
+std::unique_ptr<RtcEventLogEncoder> RtcEventLog::CreateEncoder(
+    EncodingType type) {
+  switch (type) {
+    case EncodingType::Legacy:
+      return rtc::MakeUnique<RtcEventLogEncoderLegacy>();
+    default:
+      LOG(LS_ERROR) << "Unknown RtcEventLog encoder type (" << int(type) << ")";
+      RTC_NOTREACHED();
+  }
+}
+
 }  // namespace webrtc