Reset the BWE when the network changes

webrtc/pc/channel_unittest.cc

 /*
  *  Copyright 2009 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 472 matching lines @@
 
   void OnMediaMonitor(typename T::Channel* channel,
                       const typename T::MediaInfo& info) {
     if (channel == channel1_.get()) {
       media_info_callbacks1_++;
     } else if (channel == channel2_.get()) {
       media_info_callbacks2_++;
     }
   }
 
+  cricket::CandidatePairInterface* last_selected_candidate_pair() {
+    return last_selected_candidate_pair_;
+  }
+
   void AddLegacyStreamInContent(uint32_t ssrc,
                                 int flags,
                                 typename T::Content* content) {
     // Base implementation.
   }
 
   // Tests that can be used by derived classes.
 
   // Basic sanity check.
   void TestInit() {
@@ skipping 441 matching lines @@
     if (verify_playout_) {
       EXPECT_TRUE(media_channel1_->playout());
     }
     EXPECT_TRUE(media_channel1_->sending());
     if (verify_playout_) {
       EXPECT_TRUE(media_channel2_->playout());
     }
     EXPECT_TRUE(media_channel2_->sending());
   }
 
+  // Tests that when the transport channel signals a candidate pair change
+  // event, the media channel will receive a call on the network route change.
+  void TestNetworkRouteChanges() {
+    CreateChannels(0, 0);
+
+    cricket::TransportChannel* transport_channel1 =
+        channel1_->transport_channel();
+    ASSERT_TRUE(transport_channel1 != nullptr);
+    typename T::MediaChannel* media_channel1 =
+        static_cast<typename T::MediaChannel*>(channel1_->media_channel());
+    ASSERT_TRUE(media_channel1 != nullptr);
+
+    media_channel1_->set_num_network_route_changes(0);
+    // The transport channel becomes disconnected.
+    transport_channel1->SignalSelectedCandidatePairChanged(transport_channel1,
+                                                           nullptr);
+    EXPECT_EQ(1, media_channel1_->num_network_route_changes());
+    EXPECT_FALSE(media_channel1->last_network_route().connected);
+
+    media_channel1_->set_num_network_route_changes(0);
+    // The transport channel becomes connected.
+    rtc::SocketAddress local_address("192.168.1.1", 1000 /* port number */);
+    rtc::SocketAddress remote_address("192.168.1.2", 2000 /* port number */);
+    uint16_t local_net_id = 1;
+    uint16_t remote_net_id = 2;
+    rtc::scoped_ptr<cricket::CandidatePairInterface> candidate_pair(
+        transport_controller1_.CreateFakeCandidatePair(
+            local_address, local_net_id, remote_address, remote_net_id));
+    transport_channel1->SignalSelectedCandidatePairChanged(
+        transport_channel1, candidate_pair.get());
+    EXPECT_EQ(1, media_channel1_->num_network_route_changes());
+    cricket::NetworkRoute expected_network_route(local_net_id, remote_net_id);
+    EXPECT_EQ(expected_network_route, media_channel1->last_network_route());
+  }
+
   // Test setting up a call.
   void TestCallSetup() {
     CreateChannels(0, 0);
     EXPECT_FALSE(channel1_->secure());
     EXPECT_TRUE(SendInitiate());
     if (verify_playout_) {
       EXPECT_TRUE(media_channel1_->playout());
     }
     EXPECT_FALSE(media_channel1_->sending());
     EXPECT_TRUE(SendAccept());
@@ skipping 900 matching lines @@
   std::unique_ptr<typename T::Channel> channel2_;
   typename T::Content local_media_content1_;
   typename T::Content local_media_content2_;
   typename T::Content remote_media_content1_;
   typename T::Content remote_media_content2_;
   // The RTP and RTCP packets to send in the tests.
   std::string rtp_packet_;
   std::string rtcp_packet_;
   int media_info_callbacks1_;
   int media_info_callbacks2_;
+  cricket::CandidatePairInterface* last_selected_candidate_pair_;
 };
 
 template<>
 void ChannelTest<VoiceTraits>::CreateContent(
     int flags,
     const cricket::AudioCodec& audio_codec,
     const cricket::VideoCodec& video_codec,
     cricket::AudioContentDescription* audio) {
   audio->AddCodec(audio_codec);
   audio->set_rtcp_mux((flags & RTCP_MUX) != 0);
@@ skipping 105 matching lines @@
   VideoChannelTest()
       : Base(false,
              kH264Packet,
              sizeof(kH264Packet),
              kRtcpReport,
              sizeof(kRtcpReport)) {}
 };
 
 
 // VoiceChannelTest
-
 TEST_F(VoiceChannelTest, TestInit) {
   Base::TestInit();
   EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
   EXPECT_TRUE(media_channel1_->dtmf_info_queue().empty());
 }
 
 TEST_F(VoiceChannelTest, TestSetContents) {
   Base::TestSetContents();
 }
 
@@ skipping 52 matching lines @@
   EXPECT_TRUE(channel1_->SetAudioSend(kSsrc1, false, nullptr, nullptr));
   EXPECT_TRUE(media_channel1_->IsStreamMuted(kSsrc1));
   EXPECT_TRUE(channel1_->SetAudioSend(kSsrc1, true, nullptr, nullptr));
   EXPECT_FALSE(media_channel1_->IsStreamMuted(kSsrc1));
 }
 
 TEST_F(VoiceChannelTest, TestMediaContentDirection) {
   Base::TestMediaContentDirection();
 }
 
+TEST_F(VoiceChannelTest, TestNetworkRouteChanges) {
+  Base::TestNetworkRouteChanges();
+}
+
 TEST_F(VoiceChannelTest, TestCallSetup) {
   Base::TestCallSetup();
 }
 
 TEST_F(VoiceChannelTest, TestCallTeardownRtcpMux) {
   Base::TestCallTeardownRtcpMux();
 }
 
 TEST_F(VoiceChannelTest, SendRtpToRtp) {
   Base::SendRtpToRtp();
@@ skipping 310 matching lines @@
   EXPECT_TRUE(channel1_->SetVideoSend(kSsrc1, false, nullptr));
   EXPECT_TRUE(media_channel1_->IsStreamMuted(kSsrc1));
   EXPECT_TRUE(channel1_->SetVideoSend(kSsrc1, true, nullptr));
   EXPECT_FALSE(media_channel1_->IsStreamMuted(kSsrc1));
 }
 
 TEST_F(VideoChannelTest, TestMediaContentDirection) {
   Base::TestMediaContentDirection();
 }
 
+TEST_F(VideoChannelTest, TestNetworkRouteChanges) {
+  Base::TestNetworkRouteChanges();
+}
+
 TEST_F(VideoChannelTest, TestCallSetup) {
   Base::TestCallSetup();
 }
 
 TEST_F(VideoChannelTest, TestCallTeardownRtcpMux) {
   Base::TestCallTeardownRtcpMux();
 }
 
 TEST_F(VideoChannelTest, SendRtpToRtp) {
   Base::SendRtpToRtp();
@@ skipping 359 matching lines @@
   };
   rtc::CopyOnWriteBuffer payload(data, 3);
   cricket::SendDataResult result;
   ASSERT_TRUE(media_channel1_->SendData(params, payload, &result));
   EXPECT_EQ(params.ssrc,
             media_channel1_->last_sent_data_params().ssrc);
   EXPECT_EQ("foo", media_channel1_->last_sent_data());
 }
 
 // TODO(pthatcher): TestSetReceiver?