Fix bug where a connection switch causes BWE to be set to zero.

webrtc/video/video_send_stream_tests.cc

 /*
  *  Copyright (c) 2013 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 <algorithm>  // max
@@ skipping 1103 matching lines @@
 
     std::unique_ptr<RtpRtcp> rtp_rtcp_;
     std::unique_ptr<internal::TransportAdapter> feedback_transport_;
     VideoSendStream* stream_;
     bool bitrate_capped_;
   } test;
 
   RunBaseTest(&test);
 }
 
+TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
+  class ChangingNetworkRouteTest : public test::EndToEndTest {
+   public:
+    const int kStartBitrateBps = 300000;
+    const int kNewMaxBitrateBps = 1234567;
+
+    ChangingNetworkRouteTest()
+        : EndToEndTest(test::CallTest::kDefaultTimeoutMs),
+          call_(nullptr),
+          route_changed_(false) {}
+
+    void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
+      call_ = sender_call;
+    }
+
+    Action OnSendRtp(const uint8_t* packet, size_t length) override {
+      if (!route_changed_ &&
+          call_->GetStats().send_bandwidth_bps > kStartBitrateBps) {
+        observation_complete_.Set();
+      }
+      if (route_changed_ &&
+          call_->GetStats().send_bandwidth_bps > kStartBitrateBps) {

[terelius, 2016/07/07 15:48:38]

I don't understand this. The code seems (almost) equivalent to a single
if-statement
 if (call_->GetStats().send_bandwidth_bps > kStartBitrateBps) {
    observation_complete_.Set();
 }

[stefan-webrtc, 2016/07/08 10:21:59]

You are right. This is a complicated way of saying what you suggest. It's an
artifact of how I initially wrote the test. I will simply remove the last wait
as it isn't providing much value.

+        observation_complete_.Set();
+      }
+
+      return SEND_PACKET;
+    }
+
+    void PerformTest() override {
+      rtc::NetworkRoute new_route(true, 10, 20, -1);
+      call_->OnNetworkRouteChanged("transport", new_route);
+      Call::Config::BitrateConfig bitrate_config;
+      bitrate_config.start_bitrate_bps = kStartBitrateBps;
+      call_->SetBitrateConfig(bitrate_config);
+      EXPECT_TRUE(Wait())
+          << "Timed out while waiting for start bitrate to be exceeded.";
+
+      bitrate_config.start_bitrate_bps = -1;
+      bitrate_config.max_bitrate_bps = kNewMaxBitrateBps;
+      call_->SetBitrateConfig(bitrate_config);
+      // TODO(holmer): We should set the last sent packet id here and verify
+      // that we correctly ignore any packet loss reported prior to that id.
+      ++new_route.local_network_id;
+      call_->OnNetworkRouteChanged("transport", new_route);
+      route_changed_ = true;
+      EXPECT_EQ(kStartBitrateBps, call_->GetStats().send_bandwidth_bps);
+
+      ASSERT_TRUE(Wait()) << "Timed out waiting for start bitrate to be "
+                             "exceeded after connection switch.";
+    }
+
+   private:
+    Call* call_;
+    bool route_changed_;
+  } test;
+
+  RunBaseTest(&test);
+}
+
 class MaxPaddingSetTest : public test::SendTest {
  public:
   static const uint32_t kMinTransmitBitrateBps = 400000;
   static const uint32_t kActualEncodeBitrateBps = 40000;
   static const uint32_t kMinPacketsToSend = 50;
 
   explicit MaxPaddingSetTest(bool test_switch_content_type)
       : SendTest(test::CallTest::kDefaultTimeoutMs),
         call_(nullptr),
         send_stream_(nullptr),
@@ skipping 1333 matching lines @@
         observation_complete_.Set();
       }
     }
   } test;
 
   RunBaseTest(&test);
 }
 #endif  // !defined(RTC_DISABLE_VP9)
 
 }  // namespace webrtc