Split out dscp option from VideoOptions to new struct MediaChannelOptions.

talk/media/webrtc/webrtcvideoengine2_unittest.cc

 /*
  * libjingle
  * Copyright 2004 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 325 matching lines @@
   EXPECT_FALSE(capturer.GetApplyRotation());
 
   // Verify removing header extension turns on applying rotation.
   parameters.extensions.clear();
   EXPECT_TRUE(channel->SetSendParameters(parameters));
   EXPECT_TRUE(capturer.GetApplyRotation());
 }
 
 TEST_F(WebRtcVideoEngine2Test, SetSendFailsBeforeSettingCodecs) {
   engine_.Init();
-  rtc::scoped_ptr<VideoMediaChannel> channel(
-      engine_.CreateChannel(call_.get(), cricket::VideoOptions()));
+  rtc::scoped_ptr<VideoMediaChannel> channel(engine_.CreateChannel(
+      call_.get(), MediaChannelOptions(), VideoOptions()));
 
   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
 
   EXPECT_FALSE(channel->SetSend(true))
       << "Channel should not start without codecs.";
   EXPECT_TRUE(channel->SetSend(false))
       << "Channel should be stoppable even without set codecs.";
 }
 
 TEST_F(WebRtcVideoEngine2Test, GetStatsWithoutSendCodecsSetDoesNotCrash) {
   engine_.Init();
-  rtc::scoped_ptr<VideoMediaChannel> channel(
-      engine_.CreateChannel(call_.get(), cricket::VideoOptions()));
+  rtc::scoped_ptr<VideoMediaChannel> channel(engine_.CreateChannel(
+      call_.get(), MediaChannelOptions(), VideoOptions()));
   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
   VideoMediaInfo info;
   channel->GetStats(&info);
 }
 
 TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) {
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(kVp8Codec);
@@ skipping 158 matching lines @@
   EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
 }
 
 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory(
     cricket::WebRtcVideoEncoderFactory* encoder_factory,
     const std::vector<VideoCodec>& codecs) {
   engine_.SetExternalEncoderFactory(encoder_factory);
   engine_.Init();
 
   VideoMediaChannel* channel =
-      engine_.CreateChannel(call_.get(), cricket::VideoOptions());
+      engine_.CreateChannel(call_.get(), MediaChannelOptions(), VideoOptions());
   cricket::VideoSendParameters parameters;
   parameters.codecs = codecs;
   EXPECT_TRUE(channel->SetSendParameters(parameters));
 
   return channel;
 }
 
 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory(
     cricket::WebRtcVideoDecoderFactory* decoder_factory,
     const std::vector<VideoCodec>& codecs) {
   engine_.SetExternalDecoderFactory(decoder_factory);
   engine_.Init();
 
   VideoMediaChannel* channel =
-      engine_.CreateChannel(call_.get(), cricket::VideoOptions());
+      engine_.CreateChannel(call_.get(), MediaChannelOptions(), VideoOptions());
   cricket::VideoRecvParameters parameters;
   parameters.codecs = codecs;
   EXPECT_TRUE(channel->SetRecvParameters(parameters));
 
   return channel;
 }
 
 TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) {
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
@@ skipping 323 matching lines @@
 }
 
 class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test {
  public:
   WebRtcVideoChannel2Test() : WebRtcVideoChannel2Test("") {}
   explicit WebRtcVideoChannel2Test(const char* field_trials)
       : WebRtcVideoEngine2Test(field_trials), last_ssrc_(0) {}
   void SetUp() override {
     fake_call_.reset(new FakeCall(webrtc::Call::Config()));
     engine_.Init();
-    channel_.reset(
-        engine_.CreateChannel(fake_call_.get(), cricket::VideoOptions()));
+    channel_.reset(engine_.CreateChannel(
+        fake_call_.get(), MediaChannelOptions(), VideoOptions()));
     last_ssrc_ = 123;
     send_parameters_.codecs = engine_.codecs();
     recv_parameters_.codecs = engine_.codecs();
     ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
   }
 
  protected:
   FakeVideoSendStream* AddSendStream() {
     return AddSendStream(StreamParams::CreateLegacy(++last_ssrc_));
   }
@@ skipping 1461 matching lines @@
   EXPECT_TRUE(channel_->SetSend(true));
   FakeVideoSendStream* new_stream = AddSendStream();
   EXPECT_TRUE(new_stream->IsSending())
       << "Send stream created after SetSend(true) not sending initially.";
 }
 
 // This test verifies DSCP settings are properly applied on video media channel.
 TEST_F(WebRtcVideoChannel2Test, TestSetDscpOptions) {
   rtc::scoped_ptr<cricket::FakeNetworkInterface> network_interface(
       new cricket::FakeNetworkInterface);
-  channel_->SetInterface(network_interface.get());
-  cricket::VideoSendParameters parameters = send_parameters_;
-  EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(rtc::DSCP_NO_CHANGE, network_interface->dscp());
-  parameters.options.dscp = rtc::Optional<bool>(true);
-  EXPECT_TRUE(channel_->SetSendParameters(parameters));
+  MediaChannelOptions options;
+  rtc::scoped_ptr<VideoMediaChannel> channel;
+
+  channel.reset(engine_.CreateChannel(call_.get(), options, VideoOptions()));
+  channel->SetInterface(network_interface.get());
+  // Current implementation always sets the DiffServCodePoint.

[pbos-webrtc, 2016/02/01 14:44:38]

// Default value when DSCP is disabled should be DSCP_DEFAULT.

[nisse-webrtc, 2016/02/02 11:32:50]

Done.

+  EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
+
+  options.enable_dscp = true;
+  channel.reset(engine_.CreateChannel(call_.get(), options, VideoOptions()));
+  channel->SetInterface(network_interface.get());
   EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp());
-  // Verify previous value is not modified if dscp option is not set.
-  cricket::VideoSendParameters parameters1 = send_parameters_;
-  EXPECT_TRUE(channel_->SetSendParameters(parameters1));
-  EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp());
-  parameters1.options.dscp = rtc::Optional<bool>(false);
-  EXPECT_TRUE(channel_->SetSendParameters(parameters1));
+
+  // Verify that setting the option to false resets the
+  // DiffServCodePoint.
+  options.enable_dscp = false;
+  channel.reset(engine_.CreateChannel(call_.get(), options, VideoOptions()));
+  channel->SetInterface(network_interface.get());
   EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
-  channel_->SetInterface(NULL);
 }
 
 // This test verifies that the RTCP reduced size mode is properly applied to
 // send video streams.
 TEST_F(WebRtcVideoChannel2Test, TestSetSendRtcpReducedSize) {
   // Create stream, expecting that default mode is "compound".
   FakeVideoSendStream* stream1 = AddSendStream();
   EXPECT_EQ(webrtc::RtcpMode::kCompound, stream1->GetConfig().rtp.rtcp_mode);
 
   // Now enable reduced size mode.
@@ skipping 787 matching lines @@
   // TODO(pbos): Implement.
   FAIL() << "Not implemented.";
 }
 
 class WebRtcVideoChannel2SimulcastTest : public testing::Test {
  public:
   WebRtcVideoChannel2SimulcastTest() : fake_call_(webrtc::Call::Config()) {}
 
   void SetUp() override {
     engine_.Init();
-    channel_.reset(engine_.CreateChannel(&fake_call_, VideoOptions()));
+    channel_.reset(engine_.CreateChannel(&fake_call_, MediaChannelOptions(),
+                                         VideoOptions()));
     last_ssrc_ = 123;
   }
 
  protected:
   void VerifySimulcastSettings(const VideoCodec& codec,
                                size_t num_configured_streams,
                                size_t expected_num_streams) {
     cricket::VideoSendParameters parameters;
     parameters.codecs.push_back(codec);
     ASSERT_TRUE(channel_->SetSendParameters(parameters));
@@ skipping 198 matching lines @@
 // reapplied when disabling screencasting.
 TEST_F(WebRtcVideoChannel2SimulcastTest,
        DISABLED_TwoTemporalLayerScreencastSettings) {
   // TODO(pbos): Implement.
   FAIL() << "Not implemented.";
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VIDEO