Introduce struct MediaConfig, with construction-time settings.

webrtc/media/engine/webrtcvoiceengine_unittest.cc

 /*
  *  Copyright (c) 2008 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 59 matching lines @@
         engine_(new FakeVoEWrapper(&voe_)),
         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());
+    channel_ = engine_.CreateChannel(&call_, cricket::MediaConfig(),
+                                     cricket::AudioOptions());
     return (channel_ != nullptr);
   }
   bool SetupEngineWithRecvStream() {
     if (!SetupEngine()) {
       return false;
     }
     return channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(kSsrc1));
   }
   bool SetupEngineWithSendStream() {
@@ skipping 39 matching lines @@
   }
 
   const webrtc::AudioReceiveStream::Config& GetRecvStreamConfig(uint32_t ssrc) {
     const auto* recv_stream = call_.GetAudioReceiveStream(ssrc);
     EXPECT_TRUE(recv_stream);
     return recv_stream->GetConfig();
   }
 
   void TestInsertDtmf(uint32_t ssrc, bool caller) {
     EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
-    channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
+    channel_ = engine_.CreateChannel(&call_, cricket::MediaConfig(),
+                                     cricket::AudioOptions());
     EXPECT_TRUE(channel_ != nullptr);
     if (caller) {
       // If this is a caller, local description will be applied and add the
       // send stream.
       EXPECT_TRUE(channel_->AddSendStream(
           cricket::StreamParams::CreateLegacy(kSsrc1)));
     }
 
     // Test we can only InsertDtmf when the other side supports telephone-event.
     EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
@@ skipping 256 matching lines @@
   EXPECT_FALSE(voe_.IsInited());
   EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   EXPECT_TRUE(voe_.IsInited());
   engine_.Terminate();
   EXPECT_FALSE(voe_.IsInited());
 }
 
 // Tests that we can create and destroy a channel.
 TEST_F(WebRtcVoiceEngineTestFake, CreateChannel) {
   EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
-  channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
+  channel_ = engine_.CreateChannel(&call_, cricket::MediaConfig(),
+                                   cricket::AudioOptions());
   EXPECT_TRUE(channel_ != nullptr);
 }
 
 // Tests that the list of supported codecs is created properly and ordered
 // correctly
 TEST_F(WebRtcVoiceEngineTestFake, CodecPreference) {
   const std::vector<cricket::AudioCodec>& codecs = engine_.codecs();
   ASSERT_FALSE(codecs.empty());
   EXPECT_STRCASEEQ("opus", codecs[0].name.c_str());
   EXPECT_EQ(48000, codecs[0].clockrate);
@@ skipping 1266 matching lines @@
   EXPECT_TRUE(voe_.GetVAD(channel_num));
   EXPECT_FALSE(voe_.GetRED(channel_num));
   EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
   EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
   EXPECT_TRUE(channel_->CanInsertDtmf());
 }
 
 // Test that we set VAD and DTMF types correctly as callee.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) {
   EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
-  channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
+  channel_ = engine_.CreateChannel(&call_, cricket::MediaConfig(),
+                                   cricket::AudioOptions());
   EXPECT_TRUE(channel_ != nullptr);
 
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   // TODO(juberti): cn 32000
   parameters.codecs.push_back(kCn16000Codec);
   parameters.codecs.push_back(kCn8000Codec);
   parameters.codecs.push_back(kTelephoneEventCodec);
   parameters.codecs.push_back(kRedCodec);
@@ skipping 96 matching lines @@
   EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
   EXPECT_EQ(96, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
   EXPECT_TRUE(voe_.GetRED(channel_num));
   EXPECT_EQ(127, voe_.GetSendREDPayloadType(channel_num));
 }
 
 // Test that we set up RED correctly as callee.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsREDAsCallee) {
   EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
-  channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
+  channel_ = engine_.CreateChannel(&call_, cricket::MediaConfig(),
+                                   cricket::AudioOptions());
   EXPECT_TRUE(channel_ != nullptr);
 
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kRedCodec);
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   parameters.codecs[0].id = 127;
   parameters.codecs[0].params[""] = "96/96";
   parameters.codecs[1].id = 96;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
@@ skipping 510 matching lines @@
   EXPECT_TRUE(call_.GetAudioSendStream(kSsrc1));
   EXPECT_TRUE(channel_->AddRecvStream(
       cricket::StreamParams::CreateLegacy(kSsrc2)));
   EXPECT_EQ(kSsrc1, GetRecvStreamConfig(kSsrc2).rtp.local_ssrc);
 }
 
 // Test that the local SSRC is the same on sending and receiving channels if the
 // receive channel is created before the send channel.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcAfterCreatingReceiveChannel) {
   EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
-  channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
+  channel_ = engine_.CreateChannel(&call_, cricket::MediaConfig(),
+                                   cricket::AudioOptions());
 
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
   int receive_channel_num = voe_.GetLastChannel();
   EXPECT_TRUE(channel_->AddSendStream(
       cricket::StreamParams::CreateLegacy(1234)));
 
   EXPECT_TRUE(call_.GetAudioSendStream(1234));
   EXPECT_EQ(1234U, voe_.GetLocalSSRC(receive_channel_num));
 }
 
@@ skipping 407 matching lines @@
   EXPECT_EQ(0, voe_.GetAgcConfig(config));
   EXPECT_EQ(set_config.targetLeveldBOv, config.targetLeveldBOv);
   EXPECT_EQ(set_config.digitalCompressionGaindB,
             config.digitalCompressionGaindB);
   EXPECT_EQ(set_config.limiterEnable, config.limiterEnable);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) {
   EXPECT_TRUE(SetupEngineWithSendStream());
   rtc::scoped_ptr<cricket::WebRtcVoiceMediaChannel> channel1(
-      static_cast<cricket::WebRtcVoiceMediaChannel*>(
-          engine_.CreateChannel(&call_, cricket::AudioOptions())));
+      static_cast<cricket::WebRtcVoiceMediaChannel*>(engine_.CreateChannel(
+          &call_, cricket::MediaConfig(), cricket::AudioOptions())));
   rtc::scoped_ptr<cricket::WebRtcVoiceMediaChannel> channel2(
-      static_cast<cricket::WebRtcVoiceMediaChannel*>(
-          engine_.CreateChannel(&call_, cricket::AudioOptions())));
+      static_cast<cricket::WebRtcVoiceMediaChannel*>(engine_.CreateChannel(
+          &call_, cricket::MediaConfig(), cricket::AudioOptions())));
 
   // Have to add a stream to make SetSend work.
   cricket::StreamParams stream1;
   stream1.ssrcs.push_back(1);
   channel1->AddSendStream(stream1);
   cricket::StreamParams stream2;
   stream2.ssrcs.push_back(2);
   channel2->AddSendStream(stream2);
 
   // AEC and AGC and NS
@@ skipping 75 matching lines @@
   voe_.GetAgcStatus(agc_enabled, agc_mode);
   voe_.GetNsStatus(ns_enabled, ns_mode);
   EXPECT_TRUE(ec_enabled);
   EXPECT_FALSE(agc_enabled);
   EXPECT_FALSE(ns_enabled);
 }
 
 // This test verifies DSCP settings are properly applied on voice media channel.
 TEST_F(WebRtcVoiceEngineTestFake, TestSetDscpOptions) {
   EXPECT_TRUE(SetupEngineWithSendStream());
-  rtc::scoped_ptr<cricket::VoiceMediaChannel> channel(
-      engine_.CreateChannel(&call_, cricket::AudioOptions()));
-  rtc::scoped_ptr<cricket::FakeNetworkInterface> network_interface(
-      new cricket::FakeNetworkInterface);
-  channel->SetInterface(network_interface.get());
-  cricket::AudioSendParameters parameters = send_parameters_;
-  parameters.options.dscp = rtc::Optional<bool>(true);
-  EXPECT_TRUE(channel->SetSendParameters(parameters));
-  EXPECT_EQ(rtc::DSCP_EF, network_interface->dscp());
-  // Verify previous value is not modified if dscp option is not set.
-  EXPECT_TRUE(channel->SetSendParameters(send_parameters_));
-  EXPECT_EQ(rtc::DSCP_EF, network_interface->dscp());
-  parameters.options.dscp = rtc::Optional<bool>(false);
-  EXPECT_TRUE(channel->SetSendParameters(parameters));
-  EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
+  cricket::FakeNetworkInterface network_interface;
+  cricket::MediaConfig config;
+  rtc::scoped_ptr<cricket::VoiceMediaChannel> channel;
+
+  channel.reset(engine_.CreateChannel(&call_, config, cricket::AudioOptions()));
+  channel->SetInterface(&network_interface);
+  // Default value when DSCP is disabled should be DSCP_DEFAULT.
+  EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface.dscp());
+
+  config.enable_dscp = true;
+  channel.reset(engine_.CreateChannel(&call_, config, cricket::AudioOptions()));
+  channel->SetInterface(&network_interface);
+  EXPECT_EQ(rtc::DSCP_EF, network_interface.dscp());
+
+  // Verify that setting the option to false resets the
+  // DiffServCodePoint.
+  config.enable_dscp = false;
+  channel.reset(engine_.CreateChannel(&call_, config, cricket::AudioOptions()));
+  channel->SetInterface(&network_interface);
+  // Default value when DSCP is disabled should be DSCP_DEFAULT.
+  EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface.dscp());
+
+  channel->SetInterface(nullptr);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, TestGetReceiveChannelId) {
   EXPECT_TRUE(SetupEngine());
   cricket::WebRtcVoiceMediaChannel* media_channel =
         static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
   EXPECT_EQ(-1, media_channel->GetReceiveChannelId(0));
   EXPECT_TRUE(channel_->AddRecvStream(
       cricket::StreamParams::CreateLegacy(kSsrc1)));
   int channel_id = voe_.GetLastChannel();
@@ skipping 237 matching lines @@
   DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
   EXPECT_NE(nullptr, GetRecvStream(0x01).sink());
 }
 
 // Tests that the library initializes and shuts down properly.
 TEST(WebRtcVoiceEngineTest, StartupShutdown) {
   cricket::WebRtcVoiceEngine engine;
   EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
   rtc::scoped_ptr<webrtc::Call> call(
       webrtc::Call::Create(webrtc::Call::Config()));
-  cricket::VoiceMediaChannel* channel =
-      engine.CreateChannel(call.get(), cricket::AudioOptions());
+  cricket::VoiceMediaChannel* channel = engine.CreateChannel(
+      call.get(), cricket::MediaConfig(), cricket::AudioOptions());
   EXPECT_TRUE(channel != nullptr);
   delete channel;
   engine.Terminate();
 
   // Reinit to catch regression where VoiceEngineObserver reference is lost
   EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
   engine.Terminate();
 }
 
 // Tests that the library is configured with the codecs we want.
@@ skipping 84 matching lines @@
 // Tests that VoE supports at least 32 channels
 TEST(WebRtcVoiceEngineTest, Has32Channels) {
   cricket::WebRtcVoiceEngine engine;
   EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
   rtc::scoped_ptr<webrtc::Call> call(
       webrtc::Call::Create(webrtc::Call::Config()));
 
   cricket::VoiceMediaChannel* channels[32];
   int num_channels = 0;
   while (num_channels < arraysize(channels)) {
-    cricket::VoiceMediaChannel* channel =
-        engine.CreateChannel(call.get(), cricket::AudioOptions());
+    cricket::VoiceMediaChannel* channel = engine.CreateChannel(
+        call.get(), cricket::MediaConfig(), cricket::AudioOptions());
     if (!channel)
       break;
     channels[num_channels++] = channel;
   }
 
   int expected = arraysize(channels);
   EXPECT_EQ(expected, num_channels);
 
   while (num_channels > 0) {
     delete channels[--num_channels];
   }
   engine.Terminate();
 }
 
 // Test that we set our preferred codecs properly.
 TEST(WebRtcVoiceEngineTest, SetRecvCodecs) {
   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::WebRtcVoiceMediaChannel channel(&engine, cricket::MediaConfig(),
+                                           cricket::AudioOptions(), call.get());
   cricket::AudioRecvParameters parameters;
   parameters.codecs = engine.codecs();
   EXPECT_TRUE(channel.SetRecvParameters(parameters));
 }