diff --git a/webrtc/audio/audio_send_stream.cc b/webrtc/audio/audio_send_stream.cc
index 308eeac449..376af816f6 100644
--- a/webrtc/audio/audio_send_stream.cc
+++ b/webrtc/audio/audio_send_stream.cc
@@ -487,9 +487,7 @@ bool AudioSendStream::SetupSendCodec(AudioSendStream* stream,
 bool AudioSendStream::ReconfigureSendCodec(AudioSendStream* stream,
                                            const Config& new_config) {
   const auto& old_config = stream->config_;
-  if (new_config.send_codec_spec == old_config.send_codec_spec &&
-      new_config.audio_network_adaptor_config ==
-          old_config.audio_network_adaptor_config) {
+  if (new_config.send_codec_spec == old_config.send_codec_spec) {
     return true;
   }
 
diff --git a/webrtc/audio/audio_send_stream_unittest.cc b/webrtc/audio/audio_send_stream_unittest.cc
index bec696bd4e..12fad6f83e 100644
--- a/webrtc/audio/audio_send_stream_unittest.cc
+++ b/webrtc/audio/audio_send_stream_unittest.cc
@@ -43,7 +43,6 @@ using testing::Eq;
 using testing::Ne;
 using testing::Invoke;
 using testing::Return;
-using testing::StrEq;
 
 const int kChannelId = 1;
 const uint32_t kSsrc = 1234;
@@ -142,8 +141,7 @@ struct ConfigHelper {
             &packet_router_)),
         fake_transport_(&packet_router_, send_side_cc_.get()),
         bitrate_allocator_(&limit_observer_),
-        worker_queue_("ConfigHelper_worker_queue"),
-        audio_encoder_(nullptr) {
+        worker_queue_("ConfigHelper_worker_queue") {
     using testing::Invoke;
 
     EXPECT_CALL(voice_engine_,
@@ -208,6 +206,7 @@ struct ConfigHelper {
   }
 
   void SetupDefaultChannelProxy(bool audio_bwe_enabled) {
+    using testing::StrEq;
     channel_proxy_ = new testing::StrictMock<MockVoEChannelProxy>();
     EXPECT_CALL(*channel_proxy_, GetRtpRtcp(_, _))
         .WillRepeatedly(Invoke(
@@ -251,25 +250,10 @@ struct ConfigHelper {
   void SetupMockForSetupSendCodec(bool expect_set_encoder_call) {
     if (expect_set_encoder_call) {
       EXPECT_CALL(*channel_proxy_, SetEncoderForMock(_, _))
-          .WillOnce(Invoke(
-              [this](int payload_type, std::unique_ptr<AudioEncoder>* encoder) {
-                this->audio_encoder_ = std::move(*encoder);
-                return true;
-              }));
+          .WillOnce(Return(true));
     }
   }
 
-  void SetupMockForModifyEncoder() {
-    // Let ModifyEncoder to invoke mock audio encoder.
-    EXPECT_CALL(*channel_proxy_, ModifyEncoder(_))
-        .WillRepeatedly(Invoke(
-            [this](rtc::FunctionView<void(std::unique_ptr<AudioEncoder>*)>
-                       modifier) {
-              if (this->audio_encoder_)
-                modifier(&this->audio_encoder_);
-            }));
-  }
-
   RtcpRttStats* rtcp_rtt_stats() { return &rtcp_rtt_stats_; }
 
   void SetupMockForSendTelephoneEvent() {
@@ -345,7 +329,6 @@ struct ConfigHelper {
   // |worker_queue| is defined last to ensure all pending tasks are cancelled
   // and deleted before any other members.
   rtc::TaskQueue worker_queue_;
-  std::unique_ptr<AudioEncoder> audio_encoder_;
 };
 }  // namespace
 
@@ -475,27 +458,19 @@ TEST(AudioSendStreamTest, GetStatsTypingNoiseDetected) {
   EXPECT_FALSE(send_stream.GetStats().typing_noise_detected);
 }
 
-TEST(AudioSendStreamTest, SendCodecAppliesAudioNetworkAdaptor) {
+TEST(AudioSendStreamTest, SendCodecAppliesNetworkAdaptor) {
   ConfigHelper helper(false, true);
   auto stream_config = helper.config();
   stream_config.send_codec_spec =
       rtc::Optional<AudioSendStream::Config::SendCodecSpec>({0, kOpusFormat});
-  const std::string kAnaConfigString = "abcde";
-  const std::string kAnaReconfigString = "12345";
-
   stream_config.audio_network_adaptor_config =
-      rtc::Optional<std::string>(kAnaConfigString);
+      rtc::Optional<std::string>("abced");
 
   EXPECT_CALL(helper.mock_encoder_factory(), MakeAudioEncoderMock(_, _, _))
-      .WillOnce(Invoke([&kAnaConfigString, &kAnaReconfigString](
-                           int payload_type, const SdpAudioFormat& format,
-                           std::unique_ptr<AudioEncoder>* return_value) {
+      .WillOnce(Invoke([](int payload_type, const SdpAudioFormat& format,
+                          std::unique_ptr<AudioEncoder>* return_value) {
         auto mock_encoder = SetupAudioEncoderMock(payload_type, format);
-        EXPECT_CALL(*mock_encoder,
-                    EnableAudioNetworkAdaptor(StrEq(kAnaConfigString), _))
-            .WillOnce(Return(true));
-        EXPECT_CALL(*mock_encoder,
-                    EnableAudioNetworkAdaptor(StrEq(kAnaReconfigString), _))
+        EXPECT_CALL(*mock_encoder.get(), EnableAudioNetworkAdaptor(_, _))
             .WillOnce(Return(true));
         *return_value = std::move(mock_encoder);
       }));
@@ -504,12 +479,6 @@ TEST(AudioSendStreamTest, SendCodecAppliesAudioNetworkAdaptor) {
       stream_config, helper.audio_state(), helper.worker_queue(),
       helper.transport(), helper.bitrate_allocator(), helper.event_log(),
       helper.rtcp_rtt_stats(), rtc::Optional<RtpState>());
-
-  stream_config.audio_network_adaptor_config =
-      rtc::Optional<std::string>(kAnaReconfigString);
-
-  helper.SetupMockForModifyEncoder();
-  send_stream.Reconfigure(stream_config);
 }
 
 // VAD is applied when codec is mono and the CNG frequency matches the codec