Remove encoding code from RtcEventLogImpl and use RtcEventLogEncoder instead

webrtc/logging/rtc_event_log/rtc_event_log_unittest.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 <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "webrtc/call/call.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_audio_network_adaptation.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_audio_playout.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_audio_receive_stream_config.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_audio_send_stream_config.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_bwe_update_delay_based.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_bwe_update_loss_based.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_logging_started.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_logging_stopped.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_probe_cluster_created.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_probe_result_failure.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_probe_result_success.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_rtcp_packet_incoming.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_rtcp_packet_outgoing.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_rtp_packet_incoming.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_video_receive_stream_config.h"
+#include "webrtc/logging/rtc_event_log/events/rtc_event_video_send_stream_config.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log_parser.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.h"
 #include "webrtc/logging/rtc_event_log/rtc_stream_config.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_header_extension_map.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h"
@@ skipping 339 matching lines @@
   size_t bwe_delay_written = 0;
   size_t recv_configs_written = 0;
   size_t send_configs_written = 0;
 
   for (size_t i = 0; i < event_types.size(); i++) {
     fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
     if (i == event_types.size() / 2)
       log_dumper->StartLogging(temp_filename, 10000000);
     switch (event_types[i]) {
       case EventType::INCOMING_RTP:
-        log_dumper->LogIncomingRtpHeader(
-            incoming_rtp_packets[incoming_rtp_written++]);
+        log_dumper->Log(rtc::MakeUnique<RtcEventRtpPacketIncoming>(
+            incoming_rtp_packets[incoming_rtp_written++]));
         break;
-      case EventType::OUTGOING_RTP:
-        log_dumper->LogOutgoingRtpHeader(
-            outgoing_rtp_packets[outgoing_rtp_written++],
-            PacedPacketInfo::kNotAProbe);
+      case EventType::OUTGOING_RTP: {
+        constexpr int kNotAProble = PacedPacketInfo::kNotAProbe;  // Compiler...
+        log_dumper->Log(rtc::MakeUnique<RtcEventRtpPacketOutgoing>(
+            outgoing_rtp_packets[outgoing_rtp_written++], kNotAProble));
         break;
+      }
       case EventType::INCOMING_RTCP:
-        log_dumper->LogIncomingRtcpPacket(
-            incoming_rtcp_packets[incoming_rtcp_written++]);
+        log_dumper->Log(rtc::MakeUnique<RtcEventRtcpPacketIncoming>(
+            incoming_rtcp_packets[incoming_rtcp_written++]));
         break;
       case EventType::OUTGOING_RTCP:
-        log_dumper->LogOutgoingRtcpPacket(
-            outgoing_rtcp_packets[outgoing_rtcp_written++]);
+        log_dumper->Log(rtc::MakeUnique<RtcEventRtcpPacketOutgoing>(
+            outgoing_rtcp_packets[outgoing_rtcp_written++]));
         break;
       case EventType::AUDIO_PLAYOUT:
-        log_dumper->LogAudioPlayout(playout_ssrcs[playouts_written++]);
+        log_dumper->Log(rtc::MakeUnique<RtcEventAudioPlayout>(
+            playout_ssrcs[playouts_written++]));
         break;
       case EventType::BWE_LOSS_UPDATE:
-        log_dumper->LogLossBasedBweUpdate(
+        log_dumper->Log(rtc::MakeUnique<RtcEventBweUpdateLossBased>(
             bwe_loss_updates[bwe_loss_written].bitrate_bps,
             bwe_loss_updates[bwe_loss_written].fraction_loss,
-            bwe_loss_updates[bwe_loss_written].total_packets);
+            bwe_loss_updates[bwe_loss_written].total_packets));
         bwe_loss_written++;
         break;
       case EventType::BWE_DELAY_UPDATE:
-        log_dumper->LogDelayBasedBweUpdate(
+        log_dumper->Log(rtc::MakeUnique<RtcEventBweUpdateDelayBased>(
             bwe_delay_updates[bwe_delay_written].first,
-            bwe_delay_updates[bwe_delay_written].second);
+            bwe_delay_updates[bwe_delay_written].second));
         bwe_delay_written++;
         break;
       case EventType::VIDEO_RECV_CONFIG:
-        log_dumper->LogVideoReceiveStreamConfig(
-            receiver_configs[recv_configs_written++]);
+        log_dumper->Log(rtc::MakeUnique<RtcEventVideoReceiveStreamConfig>(
+            rtc::MakeUnique<rtclog::StreamConfig>(
+                receiver_configs[recv_configs_written++])));
         break;
       case EventType::VIDEO_SEND_CONFIG:
-        log_dumper->LogVideoSendStreamConfig(
-            sender_configs[send_configs_written++]);
+        log_dumper->Log(rtc::MakeUnique<RtcEventVideoSendStreamConfig>(
+            rtc::MakeUnique<rtclog::StreamConfig>(
+                sender_configs[send_configs_written++])));
         break;
       case EventType::AUDIO_RECV_CONFIG:
         // Not implemented
         RTC_NOTREACHED();
         break;
       case EventType::AUDIO_SEND_CONFIG:
         // Not implemented
         RTC_NOTREACHED();
         break;
       case EventType::AUDIO_NETWORK_ADAPTATION:
@@ skipping 307 matching lines @@
   // filename.
   auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
   const std::string temp_filename =
       test::OutputPath() + test_info->test_case_name() + test_info->name();
 
   // Add RTP, start logging, add RTCP and then stop logging
   rtc::ScopedFakeClock fake_clock;
   fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
   std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
 
-  log_dumper->LogIncomingRtpHeader(rtp_packet);
+  log_dumper->Log(rtc::MakeUnique<RtcEventRtpPacketIncoming>(rtp_packet));
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
 
   log_dumper->StartLogging(temp_filename, 10000000);
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
 
-  log_dumper->LogOutgoingRtcpPacket(rtcp_packet);
+  log_dumper->Log(rtc::MakeUnique<RtcEventRtcpPacketOutgoing>(rtcp_packet));
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
 
   log_dumper->StopLogging();
 
   // Read the generated file from disk.
   ParsedRtcEventLog parsed_log;
   ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
 
   // Verify that what we read back from the event log is the same as
   // what we wrote down.
@@ skipping 26 matching lines @@
   auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
   const std::string temp_filename =
       test::OutputPath() + test_info->test_case_name() + test_info->name();
 
   // Start logging, add the packet loss event and then stop logging.
   rtc::ScopedFakeClock fake_clock;
   fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
   std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
   log_dumper->StartLogging(temp_filename, 10000000);
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-  log_dumper->LogLossBasedBweUpdate(bitrate, fraction_lost, total_packets);
+  log_dumper->Log(rtc::MakeUnique<RtcEventBweUpdateLossBased>(
+      bitrate, fraction_lost, total_packets));
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
   log_dumper->StopLogging();
 
   // Read the generated file from disk.
   ParsedRtcEventLog parsed_log;
   ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
 
   // Verify that what we read back from the event log is the same as
   // what we wrote down.
   EXPECT_EQ(3u, parsed_log.GetNumberOfEvents());
@@ skipping 19 matching lines @@
   auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
   const std::string temp_filename =
       test::OutputPath() + test_info->test_case_name() + test_info->name();
 
   // Start logging, add the packet delay events and then stop logging.
   rtc::ScopedFakeClock fake_clock;
   fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
   std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
   log_dumper->StartLogging(temp_filename, 10000000);
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-  log_dumper->LogDelayBasedBweUpdate(bitrate1, BandwidthUsage::kBwNormal);
+  log_dumper->Log(rtc::MakeUnique<RtcEventBweUpdateDelayBased>(
+      bitrate1, BandwidthUsage::kBwNormal));
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-  log_dumper->LogDelayBasedBweUpdate(bitrate2, BandwidthUsage::kBwOverusing);
+  log_dumper->Log(rtc::MakeUnique<RtcEventBweUpdateDelayBased>(
+      bitrate2, BandwidthUsage::kBwOverusing));
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-  log_dumper->LogDelayBasedBweUpdate(bitrate3, BandwidthUsage::kBwUnderusing);
+  log_dumper->Log(rtc::MakeUnique<RtcEventBweUpdateDelayBased>(
+      bitrate3, BandwidthUsage::kBwUnderusing));
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
   log_dumper->StopLogging();
 
   // Read the generated file from disk.
   ParsedRtcEventLog parsed_log;
   ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
 
   // Verify that what we read back from the event log is the same as
   // what we wrote down.
   EXPECT_EQ(5u, parsed_log.GetNumberOfEvents());
@@ skipping 27 matching lines @@
   // filename.
   auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
   const std::string temp_filename =
       test::OutputPath() + test_info->test_case_name() + test_info->name();
 
   rtc::ScopedFakeClock fake_clock;
   fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
   std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
 
   log_dumper->StartLogging(temp_filename, 10000000);
-  log_dumper->LogProbeClusterCreated(0, bitrate_bps0, min_probes0, min_bytes0);
+  log_dumper->Log(rtc::MakeUnique<RtcEventProbeClusterCreated>(
+      0, bitrate_bps0, min_probes0, min_bytes0));
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-  log_dumper->LogProbeClusterCreated(1, bitrate_bps1, min_probes1, min_bytes1);
+  log_dumper->Log(rtc::MakeUnique<RtcEventProbeClusterCreated>(
+      1, bitrate_bps1, min_probes1, min_bytes1));
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-  log_dumper->LogProbeClusterCreated(2, bitrate_bps2, min_probes2, min_bytes2);
+  log_dumper->Log(rtc::MakeUnique<RtcEventProbeClusterCreated>(
+      2, bitrate_bps2, min_probes2, min_bytes2));
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
   log_dumper->StopLogging();
 
   // Read the generated file from disk.
   ParsedRtcEventLog parsed_log;
   ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
 
   // Verify that what we read back from the event log is the same as
   // what we wrote down.
   EXPECT_EQ(5u, parsed_log.GetNumberOfEvents());
@@ skipping 21 matching lines @@
   // filename.
   auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
   const std::string temp_filename =
       test::OutputPath() + test_info->test_case_name() + test_info->name();
 
   rtc::ScopedFakeClock fake_clock;
   fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
   std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
 
   log_dumper->StartLogging(temp_filename, 10000000);
-  log_dumper->LogProbeResultSuccess(0, bitrate_bps0);
+  log_dumper->Log(rtc::MakeUnique<RtcEventProbeResultSuccess>(0, bitrate_bps0));
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-  log_dumper->LogProbeResultSuccess(1, bitrate_bps1);
+  log_dumper->Log(rtc::MakeUnique<RtcEventProbeResultSuccess>(1, bitrate_bps1));
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-  log_dumper->LogProbeResultSuccess(2, bitrate_bps2);
+  log_dumper->Log(rtc::MakeUnique<RtcEventProbeResultSuccess>(2, bitrate_bps2));
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
   log_dumper->StopLogging();
 
   // Read the generated file from disk.
   ParsedRtcEventLog parsed_log;
   ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
 
   // Verify that what we read back from the event log is the same as
   // what we wrote down.
   EXPECT_EQ(5u, parsed_log.GetNumberOfEvents());
@@ skipping 17 matching lines @@
   // filename.
   auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
   const std::string temp_filename =
       test::OutputPath() + test_info->test_case_name() + test_info->name();
 
   rtc::ScopedFakeClock fake_clock;
   fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
   std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
 
   log_dumper->StartLogging(temp_filename, 10000000);
-  log_dumper->LogProbeResultFailure(
-      0, ProbeFailureReason::kInvalidSendReceiveInterval);
+  log_dumper->Log(rtc::MakeUnique<RtcEventProbeResultFailure>(
+      0, ProbeFailureReason::kInvalidSendReceiveInterval));
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-  log_dumper->LogProbeResultFailure(
-      1, ProbeFailureReason::kInvalidSendReceiveRatio);
+  log_dumper->Log(rtc::MakeUnique<RtcEventProbeResultFailure>(
+      1, ProbeFailureReason::kInvalidSendReceiveRatio));
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-  log_dumper->LogProbeResultFailure(2, ProbeFailureReason::kTimeout);
+  log_dumper->Log(rtc::MakeUnique<RtcEventProbeResultFailure>(
+      2, ProbeFailureReason::kTimeout));
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
   log_dumper->StopLogging();
 
   // Read the generated file from disk.
   ParsedRtcEventLog parsed_log;
   ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
 
   // Verify that what we read back from the event log is the same as
   // what we wrote down.
   EXPECT_EQ(5u, parsed_log.GetNumberOfEvents());
@@ skipping 61 matching lines @@
   }
   Random prng;
 };
 
 class AudioReceiveConfigReadWriteTest : public ConfigReadWriteTest {
  public:
   void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
     GenerateAudioReceiveConfig(extensions, &config, &prng);
   }
   void LogConfig(RtcEventLog* event_log) override {
-    event_log->LogAudioReceiveStreamConfig(config);
+    event_log->Log(rtc::MakeUnique<RtcEventAudioReceiveStreamConfig>(
+        rtc::MakeUnique<rtclog::StreamConfig>(config)));
   }
   void VerifyConfig(const ParsedRtcEventLog& parsed_log,
                     size_t index) override {
     RtcEventLogTestHelper::VerifyAudioReceiveStreamConfig(parsed_log, index,
                                                           config);
   }
   rtclog::StreamConfig config;
 };
 
 class AudioSendConfigReadWriteTest : public ConfigReadWriteTest {
  public:
   AudioSendConfigReadWriteTest() {}
   void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
     GenerateAudioSendConfig(extensions, &config, &prng);
   }
   void LogConfig(RtcEventLog* event_log) override {
-    event_log->LogAudioSendStreamConfig(config);
+    event_log->Log(rtc::MakeUnique<RtcEventAudioSendStreamConfig>(
+        rtc::MakeUnique<rtclog::StreamConfig>(config)));
   }
   void VerifyConfig(const ParsedRtcEventLog& parsed_log,
                     size_t index) override {
     RtcEventLogTestHelper::VerifyAudioSendStreamConfig(parsed_log, index,
                                                        config);
   }
   rtclog::StreamConfig config;
 };
 
 class VideoReceiveConfigReadWriteTest : public ConfigReadWriteTest {
  public:
   VideoReceiveConfigReadWriteTest() {}
   void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
     GenerateVideoReceiveConfig(extensions, &config, &prng);
   }
   void LogConfig(RtcEventLog* event_log) override {
-    event_log->LogVideoReceiveStreamConfig(config);
+    event_log->Log(rtc::MakeUnique<RtcEventVideoReceiveStreamConfig>(
+        rtc::MakeUnique<rtclog::StreamConfig>(config)));
   }
   void VerifyConfig(const ParsedRtcEventLog& parsed_log,
                     size_t index) override {
     RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(parsed_log, index,
                                                           config);
   }
   rtclog::StreamConfig config;
 };
 
 class VideoSendConfigReadWriteTest : public ConfigReadWriteTest {
  public:
   VideoSendConfigReadWriteTest() {}
   void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
     GenerateVideoSendConfig(extensions, &config, &prng);
   }
   void LogConfig(RtcEventLog* event_log) override {
-    event_log->LogVideoSendStreamConfig(config);
+    event_log->Log(rtc::MakeUnique<RtcEventVideoSendStreamConfig>(
+        rtc::MakeUnique<rtclog::StreamConfig>(config)));
   }
   void VerifyConfig(const ParsedRtcEventLog& parsed_log,
                     size_t index) override {
     RtcEventLogTestHelper::VerifyVideoSendStreamConfig(parsed_log, index,
                                                        config);
   }
   rtclog::StreamConfig config;
 };
 
 class AudioNetworkAdaptationReadWriteTest : public ConfigReadWriteTest {
  public:
   void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
     GenerateAudioNetworkAdaptation(extensions, &config, &prng);
   }
   void LogConfig(RtcEventLog* event_log) override {
-    event_log->LogAudioNetworkAdaptation(config);
+    event_log->Log(rtc::MakeUnique<RtcEventAudioNetworkAdaptation>(
+        rtc::MakeUnique<AudioEncoderRuntimeConfig>(config)));
   }
   void VerifyConfig(const ParsedRtcEventLog& parsed_log,
                     size_t index) override {
     RtcEventLogTestHelper::VerifyAudioNetworkAdaptation(parsed_log, index,
                                                         config);
   }
   AudioEncoderRuntimeConfig config;
 };
 
 TEST(RtcEventLogTest, LogAudioReceiveConfig) {
@@ skipping 15 matching lines @@
   VideoSendConfigReadWriteTest test;
   test.DoTest();
 }
 
 TEST(RtcEventLogTest, LogAudioNetworkAdaptation) {
   AudioNetworkAdaptationReadWriteTest test;
   test.DoTest();
 }
 
 }  // namespace webrtc