Resolve cyclic dependency between audio network adaptor and event log api

webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus_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.
  */
 
@@ skipping 69 matching lines @@
       new MockSmoothingFilter());
   states.mock_bitrate_smoother = bitrate_smoother.get();
   states.simulated_clock.reset(new SimulatedClock(kInitialTimeUs));
   states.config.clock = states.simulated_clock.get();
 
   states.encoder.reset(new AudioEncoderOpus(states.config, std::move(creator),
                                             std::move(bitrate_smoother)));
   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);
   config.enable_dtx = rtc::Optional<bool>(kEnableDtx);
   config.num_channels = rtc::Optional<size_t>(kNumChannels);
   config.uplink_packet_loss_fraction =
       rtc::Optional<float>(kPacketLossFraction);
   return config;
 }
 
-void CheckEncoderRuntimeConfig(
-    const AudioEncoderOpus* encoder,
-    const AudioNetworkAdaptor::EncoderRuntimeConfig& config) {
+void CheckEncoderRuntimeConfig(const AudioEncoderOpus* encoder,
+                               const AudioEncoderRuntimeConfig& 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());
   EXPECT_EQ(*config.enable_dtx, encoder->GetDtx());
   EXPECT_EQ(*config.num_channels, encoder->num_channels_to_encode());
 }
 
 // Create 10ms audio data blocks for a total packet size of "packet_size_ms".
 std::unique_ptr<test::AudioLoop> Create10msAudioBlocks(
     const std::unique_ptr<AudioEncoderOpus>& encoder,
@@ skipping 344 matching lines @@
   // Bitrate above hysteresis window. Expect lower complexity.
   config.bitrate_bps = rtc::Optional<int>(14001);
   EXPECT_EQ(rtc::Optional<int>(6), config.GetNewComplexity());
 }
 
 TEST(AudioEncoderOpusTest, EmptyConfigDoesNotAffectEncoderSettings) {
   auto states = CreateCodec(2);
   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))
       .WillOnce(Return(empty_config));
 
   constexpr size_t kOverhead = 64;
   EXPECT_CALL(**states.mock_audio_network_adaptor, SetOverhead(kOverhead))
       .Times(2);
   states.encoder->OnReceivedOverhead(kOverhead);
   states.encoder->OnReceivedOverhead(kOverhead);
@@ skipping 54 matching lines @@
 
     // Should encode now.
     states.encoder->Encode(rtp_timestamp, audio_frames->GetNextBlock(),
                            &encoded);
     EXPECT_GT(encoded.size(), 0u);
     encoded.Clear();
   }
 }
 
 }  // namespace webrtc