Add send-side BWE to WebRtcVoiceEngine under a finch experiment.

talk/media/webrtc/webrtcvoiceengine_unittest.cc

 /*
  * libjingle
  * Copyright 2008 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 11 matching lines @@
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/call.h"
+#include "webrtc/p2p/base/faketransportcontroller.h"
+#include "webrtc/test/field_trial.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/media/base/fakenetworkinterface.h"
 #include "talk/media/base/fakertp.h"
 #include "talk/media/webrtc/fakewebrtccall.h"
 #include "talk/media/webrtc/fakewebrtcvoiceengine.h"
 #include "talk/media/webrtc/webrtcvoiceengine.h"
-#include "webrtc/p2p/base/faketransportcontroller.h"
 #include "talk/session/media/channel.h"
 
 using cricket::kRtpAudioLevelHeaderExtension;
 using cricket::kRtpAbsoluteSenderTimeHeaderExtension;
 
 namespace {
 
 const cricket::AudioCodec kPcmuCodec(0, "PCMU", 8000, 64000, 1, 0);
 const cricket::AudioCodec kIsacCodec(103, "ISAC", 16000, 32000, 1, 0);
 const cricket::AudioCodec kOpusCodec(111, "opus", 48000, 64000, 2, 0);
@@ skipping 17 matching lines @@
                             engine,  // hw
                             engine,  // network
                             engine,  // rtp
                             engine) {  // volume
   }
 };
 }  // namespace
 
 class WebRtcVoiceEngineTestFake : public testing::Test {
  public:
-  WebRtcVoiceEngineTestFake()
+  explicit WebRtcVoiceEngineTestFake() : WebRtcVoiceEngineTestFake("") {}
+
+  explicit WebRtcVoiceEngineTestFake(const char* field_trials)
       : call_(webrtc::Call::Config()),
         engine_(new FakeVoEWrapper(&voe_)),
-        channel_(nullptr) {
+        channel_(nullptr),
+        override_field_trials_(field_trials) {
     send_parameters_.codecs.push_back(kPcmuCodec);
     recv_parameters_.codecs.push_back(kPcmuCodec);
   }
   bool SetupEngine() {
     if (!engine_.Init(rtc::Thread::Current())) {
       return false;
     }
     channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
     return (channel_ != nullptr);
   }
@@ skipping 183 matching lines @@
     EXPECT_EQ(ext, GetRecvStreamConfig(kSsrc2).rtp.extensions[0].name);
     EXPECT_EQ(id, GetRecvStreamConfig(kSsrc2).rtp.extensions[0].id);
 
     // Ensure all extensions go back off with an empty list.
     recv_parameters_.extensions.clear();
     EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
     EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size());
     EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc2).rtp.extensions.size());
   }
 
+  void TestExtensionFilter(const std::vector<std::string>& extensions,
+                           const std::string& expected_extension) {
+    EXPECT_TRUE(SetupEngineWithSendStream());
+    cricket::AudioSendParameters parameters = send_parameters_;
+    int expected_id = -1;
+    int id = 1;
+    for (const std::string& extension : extensions) {
+      if (extension == expected_extension)
+        expected_id = id;
+      parameters.extensions.push_back(
+          cricket::RtpHeaderExtension(extension, id++));
+    }
+    EXPECT_TRUE(channel_->SetSendParameters(parameters));
+    const cricket::FakeAudioSendStream send_stream = GetSendStream(kSsrc1);
+
+    // Verify that only one of them has been set, and that it is the one with
+    // highest priority (transport sequence number).
+    ASSERT_EQ(1u, send_stream.GetConfig().rtp.extensions.size());
+    EXPECT_EQ(expected_id, send_stream.GetConfig().rtp.extensions[0].id);
+    EXPECT_EQ(expected_extension,
+              send_stream.GetConfig().rtp.extensions[0].name);
+  }
+
   webrtc::AudioSendStream::Stats GetAudioSendStreamStats() const {
     webrtc::AudioSendStream::Stats stats;
     stats.local_ssrc = 12;
     stats.bytes_sent = 345;
     stats.packets_sent = 678;
     stats.packets_lost = 9012;
     stats.fraction_lost = 34.56f;
     stats.codec_name = "codec_name_send";
     stats.ext_seqnum = 789;
     stats.jitter_ms = 12;
@@ skipping 98 matching lines @@
     EXPECT_EQ(info.capture_start_ntp_time_ms, stats.capture_start_ntp_time_ms);
   }
 
  protected:
   cricket::FakeCall call_;
   cricket::FakeWebRtcVoiceEngine voe_;
   cricket::WebRtcVoiceEngine engine_;
   cricket::VoiceMediaChannel* channel_;
   cricket::AudioSendParameters send_parameters_;
   cricket::AudioRecvParameters recv_parameters_;
+
+ private:
+  webrtc::test::ScopedFieldTrials override_field_trials_;
 };
 
 // Tests that our stub library "works".
 TEST_F(WebRtcVoiceEngineTestFake, StartupShutdown) {
   EXPECT_FALSE(voe_.IsInited());
   EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   EXPECT_TRUE(voe_.IsInited());
   engine_.Terminate();
   EXPECT_FALSE(voe_.IsInited());
 }
@@ skipping 14 matching lines @@
   EXPECT_EQ(48000, codecs[0].clockrate);
   EXPECT_EQ(2, codecs[0].channels);
   EXPECT_EQ(64000, codecs[0].bitrate);
   int pref = codecs[0].preference;
   for (size_t i = 1; i < codecs.size(); ++i) {
     EXPECT_GT(pref, codecs[i].preference);
     pref = codecs[i].preference;
   }
 }
 
+TEST_F(WebRtcVoiceEngineTestFake, OpusSupportsTransportCc) {
+  const std::vector<cricket::AudioCodec>& codecs = engine_.codecs();
+  bool opus_found = false;
+  for (cricket::AudioCodec codec : codecs) {
+    if (codec.name == "opus") {
+      EXPECT_TRUE(HasTransportCc(codec));
+      opus_found = true;
+    }
+  }
+  EXPECT_TRUE(opus_found);
+}
+
 // Tests that we can find codecs by name or id, and that we interpret the
 // clockrate and bitrate fields properly.
 TEST_F(WebRtcVoiceEngineTestFake, FindCodec) {
   cricket::AudioCodec codec;
   webrtc::CodecInst codec_inst;
   // Find PCMU with explicit clockrate and bitrate.
   EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kPcmuCodec, &codec_inst));
   // Find ISAC with explicit clockrate and 0 bitrate.
   EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kIsacCodec, &codec_inst));
   // Find telephone-event with explicit clockrate and 0 bitrate.
@@ skipping 823 matching lines @@
   int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_FALSE(voe_.GetCodecFEC(channel_num));
   parameters.codecs[0].params["useinbandfec"] = "1";
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_TRUE(voe_.GetCodecFEC(channel_num));
 }
 
+TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) {
+  EXPECT_TRUE(SetupEngine());
+  cricket::AudioSendParameters send_parameters;
+  send_parameters.codecs.push_back(kOpusCodec);
+  EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty());
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters));
+
+  cricket::AudioRecvParameters recv_parameters;
+  recv_parameters.codecs.push_back(kOpusCodec);
+  EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters));
+  EXPECT_TRUE(
+      channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc1)));
+  ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr);
+  EXPECT_FALSE(
+      call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc);
+
+  send_parameters.codecs = engine_.codecs();
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters));
+  ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr);
+  EXPECT_TRUE(
+      call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc);
+}
+
 // Test maxplaybackrate <= 8000 triggers Opus narrow band mode.
 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateNb) {
   EXPECT_TRUE(SetupEngineWithSendStream());
   int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_EQ(cricket::kOpusBandwidthNb,
@@ skipping 622 matching lines @@
   parameters.codecs[0].params[""] = "97/97";
   parameters.codecs[1].id = 96;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
   webrtc::CodecInst gcodec;
   EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
   EXPECT_EQ(96, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
   EXPECT_FALSE(voe_.GetRED(channel_num));
 }
 
+class WebRtcVoiceEngineWithSendSideBweTest : public WebRtcVoiceEngineTestFake {
+ public:
+  WebRtcVoiceEngineWithSendSideBweTest()
+      : WebRtcVoiceEngineTestFake("WebRTC-Audio-SendSideBwe/Enabled/") {}
+};
+
+TEST_F(WebRtcVoiceEngineWithSendSideBweTest,
+       SupportsTransportSequenceNumberHeaderExtension) {
+  cricket::RtpCapabilities capabilities = engine_.GetCapabilities();
+  ASSERT_FALSE(capabilities.header_extensions.empty());
+  for (const cricket::RtpHeaderExtension& extension :
+       capabilities.header_extensions) {
+    if (extension.uri == cricket::kRtpTransportSequenceNumberHeaderExtension) {
+      EXPECT_EQ(cricket::kRtpTransportSequenceNumberHeaderExtensionDefaultId,
+                extension.id);
+      return;
+    }
+  }
+  FAIL() << "Transport sequence number extension not in header-extension list.";
+}
+
+TEST_F(WebRtcVoiceEngineWithSendSideBweTest,
+       FiltersExtensionsPicksTransportSeqNum) {
+  // Enable three redundant extensions.
+  std::vector<std::string> extensions;
+  extensions.push_back(cricket::kRtpAbsoluteSenderTimeHeaderExtension);
+  extensions.push_back(cricket::kRtpTransportSequenceNumberHeaderExtension);
+  TestExtensionFilter(extensions,
+                      cricket::kRtpTransportSequenceNumberHeaderExtension);
+}
+
 // Test support for audio level header extension.
 TEST_F(WebRtcVoiceEngineTestFake, SendAudioLevelHeaderExtensions) {
   TestSetSendRtpHeaderExtensions(kRtpAudioLevelHeaderExtension);
 }
 TEST_F(WebRtcVoiceEngineTestFake, RecvAudioLevelHeaderExtensions) {
   TestSetRecvRtpHeaderExtensions(kRtpAudioLevelHeaderExtension);
 }
 
 // Test support for absolute send time header extension.
 TEST_F(WebRtcVoiceEngineTestFake, SendAbsoluteSendTimeHeaderExtensions) {
@@ skipping 1307 matching lines @@
   cricket::WebRtcVoiceEngine engine;
   EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
   rtc::scoped_ptr<webrtc::Call> call(
       webrtc::Call::Create(webrtc::Call::Config()));
   cricket::WebRtcVoiceMediaChannel channel(&engine, cricket::AudioOptions(),
                                            call.get());
   cricket::AudioRecvParameters parameters;
   parameters.codecs = engine.codecs();
   EXPECT_TRUE(channel.SetRecvParameters(parameters));
 }