Resolve cyclic dependency between audio network adaptor and event log api

BUG=webrtc:7257

Review-Url: https://codereview.webrtc.org/2745473003
Cr-Commit-Position: refs/heads/master@{#17565}

webrtc/logging/BUILD.gn

@@ -87,6 +87,7 @@ if (rtc_enable_protobuf) {
       ":rtc_event_log_proto",
       "..:webrtc_common",
       "../call:call_interfaces",
+      "../modules/audio_coding:audio_network_adaptor",
       "../modules/rtp_rtcp:rtp_rtcp",
       "../system_wrappers",
     ]
@@ -114,6 +115,7 @@ if (rtc_enable_protobuf) {
         "../base:rtc_base_approved",
         "../base:rtc_base_tests_utils",
         "../call",
+        "../modules/audio_coding:audio_network_adaptor",
         "../modules/rtp_rtcp",
         "../system_wrappers:metrics_default",
         "../test:test_support",

webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h

@@ -14,6 +14,7 @@
 #include <string>
 
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
+#include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
 #include "webrtc/test/gmock.h"
 
 namespace webrtc {
@@ -70,7 +71,7 @@ class MockRtcEventLog : public RtcEventLog {
                void(int32_t bitrate_bps, BandwidthUsage detector_state));
 
   MOCK_METHOD1(LogAudioNetworkAdaptation,
-               void(const AudioNetworkAdaptor::EncoderRuntimeConfig& config));
+               void(const AudioEncoderRuntimeConfig& config));
 
   MOCK_METHOD4(LogProbeClusterCreated,
                void(int id, int bitrate_bps, int min_probes, int min_bytes));

webrtc/logging/rtc_event_log/rtc_event_log.cc

@@ -22,6 +22,7 @@
 #include "webrtc/base/timeutils.h"
 #include "webrtc/call/call.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log_helper_thread.h"
+#include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.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"
@@ -29,8 +30,8 @@
 #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/receiver_report.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/psfb.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
@@ -85,7 +86,7 @@ class RtcEventLogImpl final : public RtcEventLog {
   void LogDelayBasedBweUpdate(int32_t bitrate_bps,
                               BandwidthUsage detector_state) override;
   void LogAudioNetworkAdaptation(
-      const AudioNetworkAdaptor::EncoderRuntimeConfig& config) override;
+      const AudioEncoderRuntimeConfig& config) override;
   void LogProbeClusterCreated(int id,
                               int bitrate_bps,
                               int min_probes,
@@ -504,7 +505,7 @@ void RtcEventLogImpl::LogDelayBasedBweUpdate(int32_t bitrate_bps,
 }
 
 void RtcEventLogImpl::LogAudioNetworkAdaptation(
-    const AudioNetworkAdaptor::EncoderRuntimeConfig& config) {
+    const AudioEncoderRuntimeConfig& config) {
   std::unique_ptr<rtclog::Event> event(new rtclog::Event());
   event->set_timestamp_us(rtc::TimeMicros());
   event->set_type(rtclog::Event::AUDIO_NETWORK_ADAPTATION_EVENT);

webrtc/logging/rtc_event_log/rtc_event_log.h

@@ -17,7 +17,6 @@
 #include "webrtc/base/platform_file.h"
 #include "webrtc/call/audio_receive_stream.h"
 #include "webrtc/call/audio_send_stream.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/video_receive_stream.h"
 #include "webrtc/video_send_stream.h"
@@ -32,6 +31,7 @@ class EventStream;
 
 class Clock;
 class RtcEventLogImpl;
+struct AudioEncoderRuntimeConfig;
 
 enum class MediaType;
 
@@ -135,7 +135,7 @@ class RtcEventLog {
 
   // Logs audio encoder re-configuration driven by audio network adaptor.
   virtual void LogAudioNetworkAdaptation(
-      const AudioNetworkAdaptor::EncoderRuntimeConfig& config) = 0;
+      const AudioEncoderRuntimeConfig& config) = 0;
 
   // Logs when a probe cluster is created.
   virtual void LogProbeClusterCreated(int id,
@@ -199,7 +199,7 @@ class RtcEventLogNullImpl final : public RtcEventLog {
   void LogDelayBasedBweUpdate(int32_t bitrate_bps,
                               BandwidthUsage detector_state) override {}
   void LogAudioNetworkAdaptation(
-      const AudioNetworkAdaptor::EncoderRuntimeConfig& config) override {}
+      const AudioEncoderRuntimeConfig& config) override {}
   void LogProbeClusterCreated(int id,
                               int bitrate_bps,
                               int min_probes,

webrtc/logging/rtc_event_log/rtc_event_log_parser.cc

@@ -22,6 +22,7 @@
 #include "webrtc/base/logging.h"
 #include "webrtc/call/call.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
+#include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 
 namespace webrtc {
@@ -511,7 +512,7 @@ void ParsedRtcEventLog::GetDelayBasedBweUpdate(
 
 void ParsedRtcEventLog::GetAudioNetworkAdaptation(
     size_t index,
-    AudioNetworkAdaptor::EncoderRuntimeConfig* config) const {
+    AudioEncoderRuntimeConfig* config) const {
   RTC_CHECK_LT(index, GetNumberOfEvents());
   const rtclog::Event& event = events_[index];
   RTC_CHECK(event.has_type());

webrtc/logging/rtc_event_log/rtc_event_log_parser.h

@@ -151,11 +151,10 @@ class ParsedRtcEventLog {
                               BandwidthUsage* detector_state) const;
 
   // Reads a audio network adaptation event to a (non-NULL)
-  // AudioNetworkAdaptor::EncoderRuntimeConfig struct. Only the fields that are
+  // AudioEncoderRuntimeConfig struct. Only the fields that are
   // stored in the protobuf will be written.
-  void GetAudioNetworkAdaptation(
+  void GetAudioNetworkAdaptation(size_t index,
-      size_t index,
+                                 AudioEncoderRuntimeConfig* config) const;
-      AudioNetworkAdaptor::EncoderRuntimeConfig* config) const;
 
   ParsedRtcEventLog::BweProbeClusterCreatedEvent GetBweProbeClusterCreated(
       size_t index) const;

webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc

@@ -22,6 +22,7 @@
 #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/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.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_extension.h"
@@ -227,10 +228,9 @@ void GenerateAudioSendConfig(uint32_t extensions_bitvector,
   }
 }
 
-void GenerateAudioNetworkAdaptation(
+void GenerateAudioNetworkAdaptation(uint32_t extensions_bitvector,
-    uint32_t extensions_bitvector,
+                                    AudioEncoderRuntimeConfig* config,
-    AudioNetworkAdaptor::EncoderRuntimeConfig* config,
+                                    Random* prng) {
-    Random* prng) {
   config->bitrate_bps = rtc::Optional<int>(prng->Rand(0, 3000000));
   config->enable_fec = rtc::Optional<bool>(prng->Rand<bool>());
   config->enable_dtx = rtc::Optional<bool>(prng->Rand<bool>());
@@ -859,7 +859,7 @@ class AudioNetworkAdaptationReadWriteTest : public ConfigReadWriteTest {
     RtcEventLogTestHelper::VerifyAudioNetworkAdaptation(parsed_log, index,
                                                         config);
   }
-  AudioNetworkAdaptor::EncoderRuntimeConfig config;
+  AudioEncoderRuntimeConfig config;
 };
 
 TEST(RtcEventLogTest, LogAudioReceiveConfig) {

webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.cc

@@ -15,6 +15,7 @@
 #include <string>
 
 #include "webrtc/base/checks.h"
+#include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/testsupport/fileutils.h"
 
@@ -548,8 +549,8 @@ void RtcEventLogTestHelper::VerifyBweDelayEvent(
 void RtcEventLogTestHelper::VerifyAudioNetworkAdaptation(
     const ParsedRtcEventLog& parsed_log,
     size_t index,
-    const AudioNetworkAdaptor::EncoderRuntimeConfig& config) {
+    const AudioEncoderRuntimeConfig& config) {
-  AudioNetworkAdaptor::EncoderRuntimeConfig parsed_config;
+  AudioEncoderRuntimeConfig parsed_config;
   parsed_log.GetAudioNetworkAdaptation(index, &parsed_config);
   EXPECT_EQ(config.bitrate_bps, parsed_config.bitrate_bps);
   EXPECT_EQ(config.enable_dtx, parsed_config.enable_dtx);

webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.h

@@ -63,7 +63,7 @@ class RtcEventLogTestHelper {
   static void VerifyAudioNetworkAdaptation(
       const ParsedRtcEventLog& parsed_log,
       size_t index,
-      const AudioNetworkAdaptor::EncoderRuntimeConfig& config);
+      const AudioEncoderRuntimeConfig& config);
 
   static void VerifyLogStartEvent(const ParsedRtcEventLog& parsed_log,
                                   size_t index);

webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor.cc

@@ -12,11 +12,11 @@
 
 namespace webrtc {
 
-AudioNetworkAdaptor::EncoderRuntimeConfig::EncoderRuntimeConfig() = default;
+AudioEncoderRuntimeConfig::AudioEncoderRuntimeConfig() = default;
 
-AudioNetworkAdaptor::EncoderRuntimeConfig::~EncoderRuntimeConfig() = default;
+AudioEncoderRuntimeConfig::~AudioEncoderRuntimeConfig() = default;
 
-AudioNetworkAdaptor::EncoderRuntimeConfig::EncoderRuntimeConfig(
+AudioEncoderRuntimeConfig::AudioEncoderRuntimeConfig(
-    const EncoderRuntimeConfig& other) = default;
+    const AudioEncoderRuntimeConfig& other) = default;
 
 }  // namespace webrtc

webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc

@@ -112,9 +112,8 @@ void AudioNetworkAdaptorImpl::SetOverhead(size_t overhead_bytes_per_packet) {
   UpdateNetworkMetrics(network_metrics);
 }
 
-AudioNetworkAdaptor::EncoderRuntimeConfig
+AudioEncoderRuntimeConfig AudioNetworkAdaptorImpl::GetEncoderRuntimeConfig() {
-AudioNetworkAdaptorImpl::GetEncoderRuntimeConfig() {
+  AudioEncoderRuntimeConfig config;
-  EncoderRuntimeConfig config;
   for (auto& controller :
        controller_manager_->GetSortedControllers(last_metrics_))
     controller->MakeDecision(&config);

webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h

@@ -54,7 +54,7 @@ class AudioNetworkAdaptorImpl final : public AudioNetworkAdaptor {
 
   void SetOverhead(size_t overhead_bytes_per_packet) override;
 
-  EncoderRuntimeConfig GetEncoderRuntimeConfig() override;
+  AudioEncoderRuntimeConfig GetEncoderRuntimeConfig() override;
 
   void StartDebugDump(FILE* file_handle) override;
 

webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc

@@ -182,7 +182,7 @@ TEST(AudioNetworkAdaptorImplTest,
      DumpEncoderRuntimeConfigIsCalledOnGetEncoderRuntimeConfig) {
   auto states = CreateAudioNetworkAdaptor();
 
-  AudioNetworkAdaptor::EncoderRuntimeConfig config;
+  AudioEncoderRuntimeConfig config;
   config.bitrate_bps = rtc::Optional<int>(32000);
   config.enable_fec = rtc::Optional<bool>(true);
 
@@ -255,7 +255,7 @@ TEST(AudioNetworkAdaptorImplTest,
 TEST(AudioNetworkAdaptorImplTest, LogRuntimeConfigOnGetEncoderRuntimeConfig) {
   auto states = CreateAudioNetworkAdaptor();
 
-  AudioNetworkAdaptor::EncoderRuntimeConfig config;
+  AudioEncoderRuntimeConfig config;
   config.bitrate_bps = rtc::Optional<int>(32000);
   config.enable_fec = rtc::Optional<bool>(true);
 

webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller.cc

@@ -43,8 +43,7 @@ void BitrateController::UpdateNetworkMetrics(
     overhead_bytes_per_packet_ = network_metrics.overhead_bytes_per_packet;
 }
 
-void BitrateController::MakeDecision(
+void BitrateController::MakeDecision(AudioEncoderRuntimeConfig* config) {
-    AudioNetworkAdaptor::EncoderRuntimeConfig* config) {
   // Decision on |bitrate_bps| should not have been made.
   RTC_DCHECK(!config->bitrate_bps);
   if (target_audio_bitrate_bps_ && overhead_bytes_per_packet_) {

webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller.h

@@ -32,7 +32,7 @@ class BitrateController final : public Controller {
 
   void UpdateNetworkMetrics(const NetworkMetrics& network_metrics) override;
 
-  void MakeDecision(AudioNetworkAdaptor::EncoderRuntimeConfig* config) override;
+  void MakeDecision(AudioEncoderRuntimeConfig* config) override;
 
  private:
   const Config config_;

webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller_unittest.cc

@@ -39,7 +39,7 @@ void UpdateNetworkMetrics(
 void CheckDecision(BitrateController* controller,
                    const rtc::Optional<int>& frame_length_ms,
                    int expected_bitrate_bps) {
-  AudioNetworkAdaptor::EncoderRuntimeConfig config;
+  AudioEncoderRuntimeConfig config;
   config.frame_length_ms = frame_length_ms;
   controller->MakeDecision(&config);
   EXPECT_EQ(rtc::Optional<int>(expected_bitrate_bps), config.bitrate_bps);

webrtc/modules/audio_coding/audio_network_adaptor/channel_controller.cc

@@ -41,8 +41,7 @@ void ChannelController::UpdateNetworkMetrics(
     uplink_bandwidth_bps_ = network_metrics.uplink_bandwidth_bps;
 }
 
-void ChannelController::MakeDecision(
+void ChannelController::MakeDecision(AudioEncoderRuntimeConfig* config) {
-    AudioNetworkAdaptor::EncoderRuntimeConfig* config) {
   // Decision on |num_channels| should not have been made.
   RTC_DCHECK(!config->num_channels);
 

webrtc/modules/audio_coding/audio_network_adaptor/channel_controller.h

@@ -39,7 +39,7 @@ class ChannelController final : public Controller {
 
   void UpdateNetworkMetrics(const NetworkMetrics& network_metrics) override;
 
-  void MakeDecision(AudioNetworkAdaptor::EncoderRuntimeConfig* config) override;
+  void MakeDecision(AudioEncoderRuntimeConfig* config) override;
 
  private:
   const Config config_;

webrtc/modules/audio_coding/audio_network_adaptor/channel_controller_unittest.cc

@@ -39,7 +39,7 @@ void CheckDecision(ChannelController* controller,
     network_metrics.uplink_bandwidth_bps = uplink_bandwidth_bps;
     controller->UpdateNetworkMetrics(network_metrics);
   }
-  AudioNetworkAdaptor::EncoderRuntimeConfig config;
+  AudioEncoderRuntimeConfig config;
   controller->MakeDecision(&config);
   EXPECT_EQ(rtc::Optional<size_t>(expected_num_channels), config.num_channels);
 }

webrtc/modules/audio_coding/audio_network_adaptor/controller.h

@@ -35,8 +35,7 @@ class Controller {
   // indicates an update on the corresponding network metric.
   virtual void UpdateNetworkMetrics(const NetworkMetrics& network_metrics) = 0;
 
-  virtual void MakeDecision(
+  virtual void MakeDecision(AudioEncoderRuntimeConfig* config) = 0;
-      AudioNetworkAdaptor::EncoderRuntimeConfig* config) = 0;
 };
 
 }  // namespace webrtc

webrtc/modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc

@@ -299,10 +299,10 @@ void CheckControllersOrder(const std::vector<Controller*>& controllers,
   ASSERT_EQ(expected_types.size(), controllers.size());
 
   // We also check that the controllers follow the initial settings.
-  AudioNetworkAdaptor::EncoderRuntimeConfig encoder_config;
+  AudioEncoderRuntimeConfig encoder_config;
 
   for (size_t i = 0; i < controllers.size(); ++i) {
-    AudioNetworkAdaptor::EncoderRuntimeConfig encoder_config;
+    AudioEncoderRuntimeConfig encoder_config;
     // We check the order of |controllers| by judging their decisions.
     controllers[i]->MakeDecision(&encoder_config);
 

webrtc/modules/audio_coding/audio_network_adaptor/debug_dump_writer.cc

@@ -49,9 +49,8 @@ class DebugDumpWriterImpl final : public DebugDumpWriter {
   explicit DebugDumpWriterImpl(FILE* file_handle);
   ~DebugDumpWriterImpl() override = default;
 
-  void DumpEncoderRuntimeConfig(
+  void DumpEncoderRuntimeConfig(const AudioEncoderRuntimeConfig& config,
-      const AudioNetworkAdaptor::EncoderRuntimeConfig& config,
+                                int64_t timestamp) override;
-      int64_t timestamp) override;
 
   void DumpNetworkMetrics(const Controller::NetworkMetrics& metrics,
                           int64_t timestamp) override;
@@ -104,7 +103,7 @@ void DebugDumpWriterImpl::DumpNetworkMetrics(
 }
 
 void DebugDumpWriterImpl::DumpEncoderRuntimeConfig(
-    const AudioNetworkAdaptor::EncoderRuntimeConfig& config,
+    const AudioEncoderRuntimeConfig& config,
     int64_t timestamp) {
 #ifdef WEBRTC_AUDIO_NETWORK_ADAPTOR_DEBUG_DUMP
   Event event;

webrtc/modules/audio_coding/audio_network_adaptor/debug_dump_writer.h

@@ -27,9 +27,8 @@ class DebugDumpWriter {
 
   virtual ~DebugDumpWriter() = default;
 
-  virtual void DumpEncoderRuntimeConfig(
+  virtual void DumpEncoderRuntimeConfig(const AudioEncoderRuntimeConfig& config,
-      const AudioNetworkAdaptor::EncoderRuntimeConfig& config,
+                                        int64_t timestamp) = 0;
-      int64_t timestamp) = 0;
 
   virtual void DumpNetworkMetrics(const Controller::NetworkMetrics& metrics,
                                   int64_t timestamp) = 0;

webrtc/modules/audio_coding/audio_network_adaptor/dtx_controller.cc

@@ -31,8 +31,7 @@ void DtxController::UpdateNetworkMetrics(
     uplink_bandwidth_bps_ = network_metrics.uplink_bandwidth_bps;
 }
 
-void DtxController::MakeDecision(
+void DtxController::MakeDecision(AudioEncoderRuntimeConfig* config) {
-    AudioNetworkAdaptor::EncoderRuntimeConfig* config) {
   // Decision on |enable_dtx| should not have been made.
   RTC_DCHECK(!config->enable_dtx);
 

webrtc/modules/audio_coding/audio_network_adaptor/dtx_controller.h

@@ -35,7 +35,7 @@ class DtxController final : public Controller {
 
   void UpdateNetworkMetrics(const NetworkMetrics& network_metrics) override;
 
-  void MakeDecision(AudioNetworkAdaptor::EncoderRuntimeConfig* config) override;
+  void MakeDecision(AudioEncoderRuntimeConfig* config) override;
 
  private:
   const Config config_;

webrtc/modules/audio_coding/audio_network_adaptor/dtx_controller_unittest.cc

@@ -37,7 +37,7 @@ void CheckDecision(DtxController* controller,
     network_metrics.uplink_bandwidth_bps = uplink_bandwidth_bps;
     controller->UpdateNetworkMetrics(network_metrics);
   }
-  AudioNetworkAdaptor::EncoderRuntimeConfig config;
+  AudioEncoderRuntimeConfig config;
   controller->MakeDecision(&config);
   EXPECT_EQ(rtc::Optional<bool>(expected_dtx_enabled), config.enable_dtx);
 }

webrtc/modules/audio_coding/audio_network_adaptor/event_log_writer.cc

@@ -30,7 +30,7 @@ EventLogWriter::EventLogWriter(RtcEventLog* event_log,
 EventLogWriter::~EventLogWriter() = default;
 
 void EventLogWriter::MaybeLogEncoderConfig(
-    const AudioNetworkAdaptor::EncoderRuntimeConfig& config) {
+    const AudioEncoderRuntimeConfig& config) {
   if (last_logged_config_.num_channels != config.num_channels)
     return LogEncoderConfig(config);
   if (last_logged_config_.enable_dtx != config.enable_dtx)
@@ -59,8 +59,7 @@ void EventLogWriter::MaybeLogEncoderConfig(
   }
 }
 
-void EventLogWriter::LogEncoderConfig(
+void EventLogWriter::LogEncoderConfig(const AudioEncoderRuntimeConfig& config) {
-    const AudioNetworkAdaptor::EncoderRuntimeConfig& config) {
   event_log_->LogAudioNetworkAdaptation(config);
   last_logged_config_ = config;
 }

webrtc/modules/audio_coding/audio_network_adaptor/event_log_writer.h

@@ -24,18 +24,16 @@ class EventLogWriter final {
                  float min_bitrate_change_fraction,
                  float min_packet_loss_change_fraction);
   ~EventLogWriter();
-  void MaybeLogEncoderConfig(
+  void MaybeLogEncoderConfig(const AudioEncoderRuntimeConfig& config);
-      const AudioNetworkAdaptor::EncoderRuntimeConfig& config);
 
  private:
-  void LogEncoderConfig(
+  void LogEncoderConfig(const AudioEncoderRuntimeConfig& config);
-      const AudioNetworkAdaptor::EncoderRuntimeConfig& config);
 
   RtcEventLog* const event_log_;
   const int min_bitrate_change_bps_;
   const float min_bitrate_change_fraction_;
   const float min_packet_loss_change_fraction_;
-  AudioNetworkAdaptor::EncoderRuntimeConfig last_logged_config_;
+  AudioEncoderRuntimeConfig last_logged_config_;
   RTC_DISALLOW_COPY_AND_ASSIGN(EventLogWriter);
 };
 

webrtc/modules/audio_coding/audio_network_adaptor/event_log_writer_unittest.cc

@@ -43,7 +43,7 @@ MATCHER_P(EncoderRuntimeConfigIs, config, "") {
 struct EventLogWriterStates {
   std::unique_ptr<EventLogWriter> event_log_writer;
   std::unique_ptr<testing::StrictMock<MockRtcEventLog>> event_log;
-  AudioNetworkAdaptor::EncoderRuntimeConfig runtime_config;
+  AudioEncoderRuntimeConfig runtime_config;
 };
 
 EventLogWriterStates CreateEventLogWriter() {

webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.cc

@@ -79,8 +79,7 @@ void FecControllerPlrBased::UpdateNetworkMetrics(
   }
 }
 
-void FecControllerPlrBased::MakeDecision(
+void FecControllerPlrBased::MakeDecision(AudioEncoderRuntimeConfig* config) {
-    AudioNetworkAdaptor::EncoderRuntimeConfig* config) {
   RTC_DCHECK(!config->enable_fec);
   RTC_DCHECK(!config->uplink_packet_loss_fraction);
 

webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.h

@@ -55,7 +55,7 @@ class FecControllerPlrBased final : public Controller {
 
   void UpdateNetworkMetrics(const NetworkMetrics& network_metrics) override;
 
-  void MakeDecision(AudioNetworkAdaptor::EncoderRuntimeConfig* config) override;
+  void MakeDecision(AudioEncoderRuntimeConfig* config) override;
 
  private:
   bool FecEnablingDecision(const rtc::Optional<float>& packet_loss) const;

webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based_unittest.cc

@@ -96,7 +96,7 @@ void UpdateNetworkMetrics(FecControllerPlrBasedTestStates* states,
 void CheckDecision(FecControllerPlrBasedTestStates* states,
                    bool expected_enable_fec,
                    float expected_uplink_packet_loss_fraction) {
-  AudioNetworkAdaptor::EncoderRuntimeConfig config;
+  AudioEncoderRuntimeConfig config;
   states->controller->MakeDecision(&config);
   EXPECT_EQ(rtc::Optional<bool>(expected_enable_fec), config.enable_fec);
   EXPECT_EQ(rtc::Optional<float>(expected_uplink_packet_loss_fraction),

webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.cc

@@ -42,8 +42,7 @@ void FecControllerRplrBased::UpdateNetworkMetrics(
   }
 }
 
-void FecControllerRplrBased::MakeDecision(
+void FecControllerRplrBased::MakeDecision(AudioEncoderRuntimeConfig* config) {
-    AudioNetworkAdaptor::EncoderRuntimeConfig* config) {
   RTC_DCHECK(!config->enable_fec);
   RTC_DCHECK(!config->uplink_packet_loss_fraction);
 

webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.h

@@ -47,7 +47,7 @@ class FecControllerRplrBased final : public Controller {
 
   void UpdateNetworkMetrics(const NetworkMetrics& network_metrics) override;
 
-  void MakeDecision(AudioNetworkAdaptor::EncoderRuntimeConfig* config) override;
+  void MakeDecision(AudioEncoderRuntimeConfig* config) override;
 
  private:
   bool FecEnablingDecision() const;

webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based_unittest.cc

@@ -113,7 +113,7 @@ void UpdateNetworkMetrics(
 void CheckDecision(FecControllerRplrBased* controller,
                    bool expected_enable_fec,
                    float expected_uplink_packet_loss_fraction) {
-  AudioNetworkAdaptor::EncoderRuntimeConfig config;
+  AudioEncoderRuntimeConfig config;
   controller->MakeDecision(&config);
 
   // Less compact than comparing optionals, but yields more readable errors.

webrtc/modules/audio_coding/audio_network_adaptor/frame_length_controller.cc

@@ -65,8 +65,7 @@ void FrameLengthController::UpdateNetworkMetrics(
     overhead_bytes_per_packet_ = network_metrics.overhead_bytes_per_packet;
 }
 
-void FrameLengthController::MakeDecision(
+void FrameLengthController::MakeDecision(AudioEncoderRuntimeConfig* config) {
-    AudioNetworkAdaptor::EncoderRuntimeConfig* config) {
   // Decision on |frame_length_ms| should not have been made.
   RTC_DCHECK(!config->frame_length_ms);
 
@@ -92,7 +91,7 @@ bool FrameLengthController::Config::FrameLengthChange::operator<(
 }
 
 bool FrameLengthController::FrameLengthIncreasingDecision(
-    const AudioNetworkAdaptor::EncoderRuntimeConfig& config) const {
+    const AudioEncoderRuntimeConfig& config) const {
   // Increase frame length if
   // 1. |uplink_bandwidth_bps| is known to be smaller or equal than
   //    |min_encoder_bitrate_bps| plus |prevent_overuse_margin_bps| plus the
@@ -129,7 +128,7 @@ bool FrameLengthController::FrameLengthIncreasingDecision(
 }
 
 bool FrameLengthController::FrameLengthDecreasingDecision(
-    const AudioNetworkAdaptor::EncoderRuntimeConfig& config) const {
+    const AudioEncoderRuntimeConfig& config) const {
   // Decrease frame length if
   // 1. shorter frame length is available AND
   // 2. |uplink_bandwidth_bps| is known to be bigger than

webrtc/modules/audio_coding/audio_network_adaptor/frame_length_controller.h

@@ -54,14 +54,14 @@ class FrameLengthController final : public Controller {
 
   void UpdateNetworkMetrics(const NetworkMetrics& network_metrics) override;
 
-  void MakeDecision(AudioNetworkAdaptor::EncoderRuntimeConfig* config) override;
+  void MakeDecision(AudioEncoderRuntimeConfig* config) override;
 
  private:
   bool FrameLengthIncreasingDecision(
-      const AudioNetworkAdaptor::EncoderRuntimeConfig& config) const;
+      const AudioEncoderRuntimeConfig& config) const;
 
   bool FrameLengthDecreasingDecision(
-      const AudioNetworkAdaptor::EncoderRuntimeConfig& config) const;
+      const AudioEncoderRuntimeConfig& config) const;
 
   const Config config_;
 

webrtc/modules/audio_coding/audio_network_adaptor/frame_length_controller_unittest.cc

@@ -101,7 +101,7 @@ void UpdateNetworkMetrics(
 void CheckDecision(FrameLengthController* controller,
                    const rtc::Optional<bool>& enable_fec,
                    int expected_frame_length_ms) {
-  AudioNetworkAdaptor::EncoderRuntimeConfig config;
+  AudioEncoderRuntimeConfig config;
   config.enable_fec = enable_fec;
   controller->MakeDecision(&config);
   EXPECT_EQ(rtc::Optional<int>(expected_frame_length_ms),

webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h

@@ -15,28 +15,29 @@
 
 namespace webrtc {
 
+struct AudioEncoderRuntimeConfig {
+  AudioEncoderRuntimeConfig();
+  AudioEncoderRuntimeConfig(const AudioEncoderRuntimeConfig& other);
+  ~AudioEncoderRuntimeConfig();
+  rtc::Optional<int> bitrate_bps;
+  rtc::Optional<int> frame_length_ms;
+  // Note: This is what we tell the encoder. It doesn't have to reflect
+  // the actual NetworkMetrics; it's subject to our decision.
+  rtc::Optional<float> uplink_packet_loss_fraction;
+  rtc::Optional<bool> enable_fec;
+  rtc::Optional<bool> enable_dtx;
+
+  // Some encoders can encode fewer channels than the actual input to make
+  // better use of the bandwidth. |num_channels| sets the number of channels
+  // to encode.
+  rtc::Optional<size_t> num_channels;
+};
+
 // An AudioNetworkAdaptor optimizes the audio experience by suggesting a
 // suitable runtime configuration (bit rate, frame length, FEC, etc.) to the
 // encoder based on network metrics.
 class AudioNetworkAdaptor {
  public:
-  struct EncoderRuntimeConfig {
-    EncoderRuntimeConfig();
-    EncoderRuntimeConfig(const EncoderRuntimeConfig& other);
-    ~EncoderRuntimeConfig();
-    rtc::Optional<int> bitrate_bps;
-    rtc::Optional<int> frame_length_ms;
-    // Note: This is what we tell the encoder. It doesn't have to reflect
-    // the actual NetworkMetrics; it's subject to our decision.
-    rtc::Optional<float> uplink_packet_loss_fraction;
-    rtc::Optional<bool> enable_fec;
-    rtc::Optional<bool> enable_dtx;
-
-    // Some encoders can encode fewer channels than the actual input to make
-    // better use of the bandwidth. |num_channels| sets the number of channels
-    // to encode.
-    rtc::Optional<size_t> num_channels;
-  };
 
   virtual ~AudioNetworkAdaptor() = default;
 
@@ -54,7 +55,7 @@ class AudioNetworkAdaptor {
 
   virtual void SetOverhead(size_t overhead_bytes_per_packet) = 0;
 
-  virtual EncoderRuntimeConfig GetEncoderRuntimeConfig() = 0;
+  virtual AudioEncoderRuntimeConfig GetEncoderRuntimeConfig() = 0;
 
   virtual void StartDebugDump(FILE* file_handle) = 0;
 

webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_audio_network_adaptor.h

@@ -35,7 +35,7 @@ class MockAudioNetworkAdaptor : public AudioNetworkAdaptor {
 
   MOCK_METHOD1(SetOverhead, void(size_t overhead_bytes_per_packet));
 
-  MOCK_METHOD0(GetEncoderRuntimeConfig, EncoderRuntimeConfig());
+  MOCK_METHOD0(GetEncoderRuntimeConfig, AudioEncoderRuntimeConfig());
 
   MOCK_METHOD1(StartDebugDump, void(FILE* file_handle));
 

webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_controller.h

@@ -22,8 +22,7 @@ class MockController : public Controller {
   MOCK_METHOD0(Die, void());
   MOCK_METHOD1(UpdateNetworkMetrics,
                void(const NetworkMetrics& network_metrics));
-  MOCK_METHOD1(MakeDecision,
+  MOCK_METHOD1(MakeDecision, void(AudioEncoderRuntimeConfig* config));
-               void(AudioNetworkAdaptor::EncoderRuntimeConfig* config));
 };
 
 }  // namespace webrtc

webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_debug_dump_writer.h

@@ -22,7 +22,7 @@ class MockDebugDumpWriter : public DebugDumpWriter {
   MOCK_METHOD0(Die, void());
 
   MOCK_METHOD2(DumpEncoderRuntimeConfig,
-               void(const AudioNetworkAdaptor::EncoderRuntimeConfig& config,
+               void(const AudioEncoderRuntimeConfig& config,
                     int64_t timestamp));
   MOCK_METHOD2(DumpNetworkMetrics,
                void(const Controller::NetworkMetrics& metrics,

webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc

@@ -87,14 +87,14 @@ AudioEncoderOpusStates CreateCodec(size_t num_channels) {
   return states;
 }
 
-AudioNetworkAdaptor::EncoderRuntimeConfig CreateEncoderRuntimeConfig() {
+AudioEncoderRuntimeConfig CreateEncoderRuntimeConfig() {
   constexpr int kBitrate = 40000;
   constexpr int kFrameLength = 60;
   constexpr bool kEnableFec = true;
   constexpr bool kEnableDtx = false;
   constexpr size_t kNumChannels = 1;
   constexpr float kPacketLossFraction = 0.1f;
-  AudioNetworkAdaptor::EncoderRuntimeConfig config;
+  AudioEncoderRuntimeConfig config;
   config.bitrate_bps = rtc::Optional<int>(kBitrate);
   config.frame_length_ms = rtc::Optional<int>(kFrameLength);
   config.enable_fec = rtc::Optional<bool>(kEnableFec);
@@ -105,9 +105,8 @@ AudioNetworkAdaptor::EncoderRuntimeConfig CreateEncoderRuntimeConfig() {
   return config;
 }
 
-void CheckEncoderRuntimeConfig(
+void CheckEncoderRuntimeConfig(const AudioEncoderOpus* encoder,
-    const AudioEncoderOpus* encoder,
+                               const AudioEncoderRuntimeConfig& config) {
-    const AudioNetworkAdaptor::EncoderRuntimeConfig& config) {
   EXPECT_EQ(*config.bitrate_bps, encoder->GetTargetBitrate());
   EXPECT_EQ(*config.frame_length_ms, encoder->next_frame_length_ms());
   EXPECT_EQ(*config.enable_fec, encoder->fec_enabled());
@@ -472,7 +471,7 @@ TEST(AudioEncoderOpusTest, EmptyConfigDoesNotAffectEncoderSettings) {
   states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr);
 
   auto config = CreateEncoderRuntimeConfig();
-  AudioNetworkAdaptor::EncoderRuntimeConfig empty_config;
+  AudioEncoderRuntimeConfig empty_config;
 
   EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig())
       .WillOnce(Return(config))

webrtc/tools/DEPS

@@ -4,6 +4,7 @@ include_rules = [
   "+webrtc/common_video",
   "+webrtc/logging/rtc_event_log",
   "+webrtc/modules/audio_device",
+  "+webrtc/modules/audio_coding/audio_network_adaptor",
   "+webrtc/modules/audio_processing",
   "+webrtc/modules/bitrate_controller",
   "+webrtc/modules/congestion_controller",

webrtc/tools/event_log_visualizer/analyzer.h

@@ -20,6 +20,7 @@
 
 #include "webrtc/base/function_view.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log_parser.h"
+#include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
 #include "webrtc/tools/event_log_visualizer/plot_base.h"
@@ -55,7 +56,7 @@ struct LossBasedBweUpdate {
 
 struct AudioNetworkAdaptationEvent {
   uint64_t timestamp;
-  AudioNetworkAdaptor::EncoderRuntimeConfig config;
+  AudioEncoderRuntimeConfig config;
 };
 
 class EventLogAnalyzer {

webrtc/voice_engine/channel.cc

@@ -163,7 +163,7 @@ class RtcEventLogProxy final : public webrtc::RtcEventLog {
   }
 
   void LogAudioNetworkAdaptation(
-      const AudioNetworkAdaptor::EncoderRuntimeConfig& config) override {
+      const AudioEncoderRuntimeConfig& config) override {
     rtc::CritScope lock(&crit_);
     if (event_log_) {
       event_log_->LogAudioNetworkAdaptation(config);