Replace rtc::cricket::Settable with rtc::Maybe

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 79 matching lines @@
 class WebRtcVoiceEngineTestFake : public testing::Test {
  public:
   WebRtcVoiceEngineTestFake()
       : call_(webrtc::Call::Config()),
         voe_(kAudioCodecs, ARRAY_SIZE(kAudioCodecs)),
         trace_wrapper_(new FakeVoETraceWrapper()),
         engine_(new FakeVoEWrapper(&voe_), trace_wrapper_),
         channel_(nullptr) {
     send_parameters_.codecs.push_back(kPcmuCodec);
     recv_parameters_.codecs.push_back(kPcmuCodec);
-    options_adjust_agc_.adjust_agc_delta.Set(-10);
+    options_adjust_agc_.adjust_agc_delta = rtc::Maybe<int>(-10);
   }
   bool SetupEngine() {
     if (!engine_.Init(rtc::Thread::Current())) {
       return false;
     }
     channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
     return (channel_ != nullptr);
   }
   bool SetupEngineWithRecvStream() {
     if (!SetupEngine()) {
@@ skipping 2163 matching lines @@
   EXPECT_EQ(0, agc_config.targetLeveldBOv);  // level was restored
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, TxAgcConfigViaOptions) {
   EXPECT_TRUE(SetupEngineWithSendStream());
   webrtc::AgcConfig agc_config;
   EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
   EXPECT_EQ(0, agc_config.targetLeveldBOv);
 
   cricket::AudioOptions options;
-  options.tx_agc_target_dbov.Set(3);
-  options.tx_agc_digital_compression_gain.Set(9);
-  options.tx_agc_limiter.Set(true);
-  options.auto_gain_control.Set(true);
+  options.tx_agc_target_dbov = rtc::Maybe<uint16_t>(3);
+  options.tx_agc_digital_compression_gain = rtc::Maybe<uint16_t>(9);
+  options.tx_agc_limiter = rtc::Maybe<bool>(true);
+  options.auto_gain_control = rtc::Maybe<bool>(true);
   EXPECT_TRUE(engine_.SetOptions(options));
 
   EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
   EXPECT_EQ(3, agc_config.targetLeveldBOv);
   EXPECT_EQ(9, agc_config.digitalCompressionGaindB);
   EXPECT_TRUE(agc_config.limiterEnable);
 
   // Check interaction with adjust_agc_delta. Both should be respected, for
   // backwards compatibility.
-  options.adjust_agc_delta.Set(-10);
+  options.adjust_agc_delta = rtc::Maybe<int>(-10);
   EXPECT_TRUE(engine_.SetOptions(options));
 
   EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
   EXPECT_EQ(13, agc_config.targetLeveldBOv);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SampleRatesViaOptions) {
   EXPECT_TRUE(SetupEngineWithSendStream());
   cricket::AudioOptions options;
-  options.recording_sample_rate.Set(48000u);
-  options.playout_sample_rate.Set(44100u);
+  options.recording_sample_rate = rtc::Maybe<uint32_t>(48000);
+  options.playout_sample_rate = rtc::Maybe<uint32_t>(44100);
   EXPECT_TRUE(engine_.SetOptions(options));
 
   unsigned int recording_sample_rate, playout_sample_rate;
   EXPECT_EQ(0, voe_.RecordingSampleRate(&recording_sample_rate));
   EXPECT_EQ(0, voe_.PlayoutSampleRate(&playout_sample_rate));
   EXPECT_EQ(48000u, recording_sample_rate);
   EXPECT_EQ(44100u, playout_sample_rate);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, TraceFilterViaTraceOptions) {
@@ skipping 304 matching lines @@
   EXPECT_TRUE(highpass_filter_enabled);
   EXPECT_FALSE(stereo_swapping_enabled);
   EXPECT_TRUE(typing_detection_enabled);
   EXPECT_EQ(ec_mode, webrtc::kEcConference);
   EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression);
   EXPECT_EQ(50, voe_.GetNetEqCapacity());  // From GetDefaultEngineOptions().
   EXPECT_FALSE(
       voe_.GetNetEqFastAccelerate());  // From GetDefaultEngineOptions().
 
   // Turn echo cancellation off
-  options.echo_cancellation.Set(false);
+  options.echo_cancellation = rtc::Maybe<bool>(false);
   ASSERT_TRUE(engine_.SetOptions(options));
   voe_.GetEcStatus(ec_enabled, ec_mode);
   EXPECT_FALSE(ec_enabled);
 
   // Turn echo cancellation back on, with settings, and make sure
   // nothing else changed.
-  options.echo_cancellation.Set(true);
+  options.echo_cancellation = rtc::Maybe<bool>(true);
   ASSERT_TRUE(engine_.SetOptions(options));
   voe_.GetEcStatus(ec_enabled, ec_mode);
   voe_.GetAecmMode(aecm_mode, cng_enabled);
   voe_.GetAgcStatus(agc_enabled, agc_mode);
   voe_.GetAgcConfig(agc_config);
   voe_.GetNsStatus(ns_enabled, ns_mode);
   highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
   stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
   voe_.GetTypingDetectionStatus(typing_detection_enabled);
   EXPECT_TRUE(ec_enabled);
   EXPECT_TRUE(voe_.ec_metrics_enabled());
   EXPECT_TRUE(agc_enabled);
   EXPECT_EQ(0, agc_config.targetLeveldBOv);
   EXPECT_TRUE(ns_enabled);
   EXPECT_TRUE(highpass_filter_enabled);
   EXPECT_FALSE(stereo_swapping_enabled);
   EXPECT_TRUE(typing_detection_enabled);
   EXPECT_EQ(ec_mode, webrtc::kEcConference);
   EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression);
 
   // Turn on delay agnostic aec and make sure nothing change w.r.t. echo
   // control.
-  options.delay_agnostic_aec.Set(true);
+  options.delay_agnostic_aec = rtc::Maybe<bool>(true);
   ASSERT_TRUE(engine_.SetOptions(options));
   voe_.GetEcStatus(ec_enabled, ec_mode);
   voe_.GetAecmMode(aecm_mode, cng_enabled);
   EXPECT_TRUE(ec_enabled);
   EXPECT_TRUE(voe_.ec_metrics_enabled());
   EXPECT_EQ(ec_mode, webrtc::kEcConference);
 
   // Turn off echo cancellation and delay agnostic aec.
-  options.delay_agnostic_aec.Set(false);
-  options.extended_filter_aec.Set(false);
-  options.echo_cancellation.Set(false);
+  options.delay_agnostic_aec = rtc::Maybe<bool>(false);
+  options.extended_filter_aec = rtc::Maybe<bool>(false);
+  options.echo_cancellation = rtc::Maybe<bool>(false);
   ASSERT_TRUE(engine_.SetOptions(options));
   voe_.GetEcStatus(ec_enabled, ec_mode);
   EXPECT_FALSE(ec_enabled);
   // Turning delay agnostic aec back on should also turn on echo cancellation.
-  options.delay_agnostic_aec.Set(true);
+  options.delay_agnostic_aec = rtc::Maybe<bool>(true);
   ASSERT_TRUE(engine_.SetOptions(options));
   voe_.GetEcStatus(ec_enabled, ec_mode);
   EXPECT_TRUE(ec_enabled);
   EXPECT_TRUE(voe_.ec_metrics_enabled());
   EXPECT_EQ(ec_mode, webrtc::kEcConference);
 
   // Turn off AGC
-  options.auto_gain_control.Set(false);
+  options.auto_gain_control = rtc::Maybe<bool>(false);
   ASSERT_TRUE(engine_.SetOptions(options));
   voe_.GetAgcStatus(agc_enabled, agc_mode);
   EXPECT_FALSE(agc_enabled);
 
   // Turn AGC back on
-  options.auto_gain_control.Set(true);
-  options.adjust_agc_delta.Clear();
+  options.auto_gain_control = rtc::Maybe<bool>(true);
+  options.adjust_agc_delta = rtc::Maybe<int>();
   ASSERT_TRUE(engine_.SetOptions(options));
   voe_.GetAgcStatus(agc_enabled, agc_mode);
   EXPECT_TRUE(agc_enabled);
   voe_.GetAgcConfig(agc_config);
   EXPECT_EQ(0, agc_config.targetLeveldBOv);
 
   // Turn off other options (and stereo swapping on).
-  options.noise_suppression.Set(false);
-  options.highpass_filter.Set(false);
-  options.typing_detection.Set(false);
-  options.stereo_swapping.Set(true);
+  options.noise_suppression = rtc::Maybe<bool>(false);
+  options.highpass_filter = rtc::Maybe<bool>(false);
+  options.typing_detection = rtc::Maybe<bool>(false);
+  options.stereo_swapping = rtc::Maybe<bool>(true);
   ASSERT_TRUE(engine_.SetOptions(options));
   voe_.GetNsStatus(ns_enabled, ns_mode);
   highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
   stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
   voe_.GetTypingDetectionStatus(typing_detection_enabled);
   EXPECT_FALSE(ns_enabled);
   EXPECT_FALSE(highpass_filter_enabled);
   EXPECT_FALSE(typing_detection_enabled);
   EXPECT_TRUE(stereo_swapping_enabled);
 
@@ skipping 62 matching lines @@
   // 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
   cricket::AudioSendParameters parameters_options_all = send_parameters_;
-  parameters_options_all.options.echo_cancellation.Set(true);
-  parameters_options_all.options.auto_gain_control.Set(true);
-  parameters_options_all.options.noise_suppression.Set(true);
+  parameters_options_all.options.echo_cancellation = rtc::Maybe<bool>(true);
+  parameters_options_all.options.auto_gain_control = rtc::Maybe<bool>(true);
+  parameters_options_all.options.noise_suppression = rtc::Maybe<bool>(true);
   ASSERT_TRUE(channel1->SetSendParameters(parameters_options_all));
   EXPECT_EQ(parameters_options_all.options, channel1->options());
   ASSERT_TRUE(channel2->SetSendParameters(parameters_options_all));
   EXPECT_EQ(parameters_options_all.options, channel2->options());
 
   // unset NS
   cricket::AudioSendParameters parameters_options_no_ns = send_parameters_;
-  parameters_options_no_ns.options.noise_suppression.Set(false);
+  parameters_options_no_ns.options.noise_suppression = rtc::Maybe<bool>(false);
   ASSERT_TRUE(channel1->SetSendParameters(parameters_options_no_ns));
   cricket::AudioOptions expected_options = parameters_options_all.options;
-  expected_options.echo_cancellation.Set(true);
-  expected_options.auto_gain_control.Set(true);
-  expected_options.noise_suppression.Set(false);
+  expected_options.echo_cancellation = rtc::Maybe<bool>(true);
+  expected_options.auto_gain_control = rtc::Maybe<bool>(true);
+  expected_options.noise_suppression = rtc::Maybe<bool>(false);
   EXPECT_EQ(expected_options, channel1->options());
 
   // unset AGC
   cricket::AudioSendParameters parameters_options_no_agc = send_parameters_;
-  parameters_options_no_agc.options.auto_gain_control.Set(false);
+  parameters_options_no_agc.options.auto_gain_control = rtc::Maybe<bool>(false);
   ASSERT_TRUE(channel2->SetSendParameters(parameters_options_no_agc));
-  expected_options.echo_cancellation.Set(true);
-  expected_options.auto_gain_control.Set(false);
-  expected_options.noise_suppression.Set(true);
+  expected_options.echo_cancellation = rtc::Maybe<bool>(true);
+  expected_options.auto_gain_control = rtc::Maybe<bool>(false);
+  expected_options.noise_suppression = rtc::Maybe<bool>(true);
   EXPECT_EQ(expected_options, channel2->options());
 
   ASSERT_TRUE(engine_.SetOptions(parameters_options_all.options));
   bool ec_enabled;
   webrtc::EcModes ec_mode;
   bool agc_enabled;
   webrtc::AgcModes agc_mode;
   bool ns_enabled;
   webrtc::NsModes ns_mode;
   voe_.GetEcStatus(ec_enabled, ec_mode);
@@ skipping 32 matching lines @@
   voe_.GetAgcStatus(agc_enabled, agc_mode);
   voe_.GetNsStatus(ns_enabled, ns_mode);
   EXPECT_TRUE(ec_enabled);
   EXPECT_TRUE(agc_enabled);
   EXPECT_TRUE(ns_enabled);
 
   // Make sure settings take effect while we are sending.
   ASSERT_TRUE(engine_.SetOptions(parameters_options_all.options));
   cricket::AudioSendParameters parameters_options_no_agc_nor_ns =
       send_parameters_;
-  parameters_options_no_agc_nor_ns.options.auto_gain_control.Set(false);
-  parameters_options_no_agc_nor_ns.options.noise_suppression.Set(false);
+  parameters_options_no_agc_nor_ns.options.auto_gain_control =
+      rtc::Maybe<bool>(false);
+  parameters_options_no_agc_nor_ns.options.noise_suppression =
+      rtc::Maybe<bool>(false);
   channel2->SetSend(cricket::SEND_MICROPHONE);
   channel2->SetSendParameters(parameters_options_no_agc_nor_ns);
-  expected_options.echo_cancellation.Set(true);
-  expected_options.auto_gain_control.Set(false);
-  expected_options.noise_suppression.Set(false);
+  expected_options.echo_cancellation = rtc::Maybe<bool>(true);
+  expected_options.auto_gain_control = rtc::Maybe<bool>(false);
+  expected_options.noise_suppression = rtc::Maybe<bool>(false);
   EXPECT_EQ(expected_options, channel2->options());
   voe_.GetEcStatus(ec_enabled, ec_mode);
   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.Set(true);
+  parameters.options.dscp = rtc::Maybe<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.Set(false);
+  parameters.options.dscp = rtc::Maybe<bool>(false);
   EXPECT_TRUE(channel->SetSendParameters(parameters));
   EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
 }
 
 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(
@@ skipping 88 matching lines @@
   EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
 
   // Combined BWE should be disabled.
   for (uint32_t ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
     EXPECT_FALSE(s->GetConfig().combined_audio_video_bwe);
   }
 
   // Enable combined BWE option - now it should be set up.
-  send_parameters_.options.combined_audio_video_bwe.Set(true);
+  send_parameters_.options.combined_audio_video_bwe = rtc::Maybe<bool>(true);
   EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
   for (uint32_t ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
     EXPECT_EQ(true, s->GetConfig().combined_audio_video_bwe);
   }
 
   // Disable combined BWE option - should be disabled again.
-  send_parameters_.options.combined_audio_video_bwe.Set(false);
+  send_parameters_.options.combined_audio_video_bwe = rtc::Maybe<bool>(false);
   EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
   for (uint32_t ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
     EXPECT_FALSE(s->GetConfig().combined_audio_video_bwe);
   }
 
   EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, ConfigureCombinedBweForNewRecvStreams) {
   // Test that adding receive streams after enabling combined bandwidth
   // estimation will correctly configure each channel.
   EXPECT_TRUE(SetupEngineWithSendStream());
   cricket::WebRtcVoiceMediaChannel* media_channel =
       static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
-  send_parameters_.options.combined_audio_video_bwe.Set(true);
+  send_parameters_.options.combined_audio_video_bwe = rtc::Maybe<bool>(true);
   EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
 
   static const uint32_t kSsrcs[] = {1, 2, 3, 4};
   for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs); ++i) {
     EXPECT_TRUE(media_channel->AddRecvStream(
         cricket::StreamParams::CreateLegacy(kSsrcs[i])));
     EXPECT_NE(nullptr, call_.GetAudioReceiveStream(kSsrcs[i]));
   }
   EXPECT_EQ(ARRAY_SIZE(kSsrcs), call_.GetAudioReceiveStreams().size());
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) {
   // Test that setting the header extensions results in the expected state
   // changes on an associated Call.
   std::vector<uint32_t> ssrcs;
   ssrcs.push_back(223);
   ssrcs.push_back(224);
 
   EXPECT_TRUE(SetupEngineWithSendStream());
   cricket::WebRtcVoiceMediaChannel* media_channel =
       static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
-  send_parameters_.options.combined_audio_video_bwe.Set(true);
+  send_parameters_.options.combined_audio_video_bwe = rtc::Maybe<bool>(true);
   EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
   for (uint32_t ssrc : ssrcs) {
     EXPECT_TRUE(media_channel->AddRecvStream(
         cricket::StreamParams::CreateLegacy(ssrc)));
   }
 
   // Combined BWE should be set up, but with no configured extensions.
   EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
   for (uint32_t ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
@@ skipping 38 matching lines @@
     0x80, 0xc9, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
     0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
   };
   rtc::Buffer kRtcpPacket(kRtcp, sizeof(kRtcp));
 
   EXPECT_TRUE(SetupEngineWithSendStream());
   cricket::WebRtcVoiceMediaChannel* media_channel =
       static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
-  send_parameters_.options.combined_audio_video_bwe.Set(true);
+  send_parameters_.options.combined_audio_video_bwe = rtc::Maybe<bool>(true);
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_TRUE(media_channel->AddRecvStream(
       cricket::StreamParams::CreateLegacy(kAudioSsrc)));
 
   EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
   const cricket::FakeAudioReceiveStream* s =
       call_.GetAudioReceiveStream(kAudioSsrc);
   EXPECT_EQ(0, s->received_packets());
   channel_->OnPacketReceived(&kPcmuPacket, rtc::PacketTime());
   EXPECT_EQ(1, s->received_packets());
@@ skipping 41 matching lines @@
   EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), -1);
 }
 
 // Tests for the actual WebRtc VoE library.
 
 TEST(WebRtcVoiceEngineTest, TestDefaultOptionsBeforeInit) {
   cricket::WebRtcVoiceEngine engine;
   cricket::AudioOptions options = engine.GetOptions();
   // The default options should have at least a few things set. We purposefully
   // don't check the option values here, though.
-  EXPECT_TRUE(options.echo_cancellation.IsSet());
-  EXPECT_TRUE(options.auto_gain_control.IsSet());
-  EXPECT_TRUE(options.noise_suppression.IsSet());
+  EXPECT_TRUE(options.echo_cancellation);
+  EXPECT_TRUE(options.auto_gain_control);
+  EXPECT_TRUE(options.noise_suppression);
 }
 
 // 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());
@@ skipping 117 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));
 }