Rename Maybe to Optional

talk/media/webrtc/webrtcvoiceengine.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 350 matching lines @@
     RTC_DCHECK(voe_codec->plfreq != new_plfreq);
     voe_codec->plfreq = new_plfreq;
   }
 }
 
 // Gets the default set of options applied to the engine. Historically, these
 // were supplied as a combination of flags from the channel manager (ec, agc,
 // ns, and highpass) and the rest hardcoded in InitInternal.
 AudioOptions GetDefaultEngineOptions() {
   AudioOptions options;
-  options.echo_cancellation = rtc::Maybe<bool>(true);
-  options.auto_gain_control = rtc::Maybe<bool>(true);
-  options.noise_suppression = rtc::Maybe<bool>(true);
-  options.highpass_filter = rtc::Maybe<bool>(true);
-  options.stereo_swapping = rtc::Maybe<bool>(false);
-  options.audio_jitter_buffer_max_packets = rtc::Maybe<int>(50);
-  options.audio_jitter_buffer_fast_accelerate = rtc::Maybe<bool>(false);
-  options.typing_detection = rtc::Maybe<bool>(true);
-  options.adjust_agc_delta = rtc::Maybe<int>(0);
-  options.experimental_agc = rtc::Maybe<bool>(false);
-  options.extended_filter_aec = rtc::Maybe<bool>(false);
-  options.delay_agnostic_aec = rtc::Maybe<bool>(false);
-  options.experimental_ns = rtc::Maybe<bool>(false);
-  options.aec_dump = rtc::Maybe<bool>(false);
+  options.echo_cancellation = rtc::Optional<bool>(true);
+  options.auto_gain_control = rtc::Optional<bool>(true);
+  options.noise_suppression = rtc::Optional<bool>(true);
+  options.highpass_filter = rtc::Optional<bool>(true);
+  options.stereo_swapping = rtc::Optional<bool>(false);
+  options.audio_jitter_buffer_max_packets = rtc::Optional<int>(50);
+  options.audio_jitter_buffer_fast_accelerate = rtc::Optional<bool>(false);
+  options.typing_detection = rtc::Optional<bool>(true);
+  options.adjust_agc_delta = rtc::Optional<int>(0);
+  options.experimental_agc = rtc::Optional<bool>(false);
+  options.extended_filter_aec = rtc::Optional<bool>(false);
+  options.delay_agnostic_aec = rtc::Optional<bool>(false);
+  options.experimental_ns = rtc::Optional<bool>(false);
+  options.aec_dump = rtc::Optional<bool>(false);
   return options;
 }
 
 std::string GetEnableString(bool enable) {
   return enable ? "enable" : "disable";
 }
 
 webrtc::AudioState::Config MakeAudioStateConfig(VoEWrapper* voe_wrapper) {
   webrtc::AudioState::Config config;
   config.voice_engine = voe_wrapper->engine();
@@ skipping 238 matching lines @@
   webrtc::AgcModes agc_mode = webrtc::kAgcAdaptiveAnalog;
   webrtc::NsModes ns_mode = webrtc::kNsHighSuppression;
   if (options.aecm_generate_comfort_noise) {
     LOG(LS_VERBOSE) << "Comfort noise explicitly set to "
                     << *options.aecm_generate_comfort_noise
                     << " (default is false).";
   }
 
 #if defined(IOS)
   // On iOS, VPIO provides built-in EC and AGC.
-  options.echo_cancellation = rtc::Maybe<bool>(false);
-  options.auto_gain_control = rtc::Maybe<bool>(false);
+  options.echo_cancellation = rtc::Optional<bool>(false);
+  options.auto_gain_control = rtc::Optional<bool>(false);
   LOG(LS_INFO) << "Always disable AEC and AGC on iOS. Use built-in instead.";
 #elif defined(ANDROID)
   ec_mode = webrtc::kEcAecm;
 #endif
 
 #if defined(IOS) || defined(ANDROID)
   // Set the AGC mode for iOS as well despite disabling it above, to avoid
   // unsupported configuration errors from webrtc.
   agc_mode = webrtc::kAgcFixedDigital;
-  options.typing_detection = rtc::Maybe<bool>(false);
-  options.experimental_agc = rtc::Maybe<bool>(false);
-  options.extended_filter_aec = rtc::Maybe<bool>(false);
-  options.experimental_ns = rtc::Maybe<bool>(false);
+  options.typing_detection = rtc::Optional<bool>(false);
+  options.experimental_agc = rtc::Optional<bool>(false);
+  options.extended_filter_aec = rtc::Optional<bool>(false);
+  options.experimental_ns = rtc::Optional<bool>(false);
 #endif
 
   // Delay Agnostic AEC automatically turns on EC if not set except on iOS
   // where the feature is not supported.
   bool use_delay_agnostic_aec = false;
 #if !defined(IOS)
   if (options.delay_agnostic_aec) {
     use_delay_agnostic_aec = *options.delay_agnostic_aec;
     if (use_delay_agnostic_aec) {
-      options.echo_cancellation = rtc::Maybe<bool>(true);
-      options.extended_filter_aec = rtc::Maybe<bool>(true);
+      options.echo_cancellation = rtc::Optional<bool>(true);
+      options.extended_filter_aec = rtc::Optional<bool>(true);
       ec_mode = webrtc::kEcConference;
     }
   }
 #endif
 
   webrtc::VoEAudioProcessing* voep = voe_wrapper_->processing();
 
   if (options.echo_cancellation) {
     // Check if platform supports built-in EC. Currently only supported on
     // Android and in combination with Java based audio layer.
     // TODO(henrika): investigate possibility to support built-in EC also
     // in combination with Open SL ES audio.
     const bool built_in_aec = voe_wrapper_->hw()->BuiltInAECIsAvailable();
     if (built_in_aec) {
       // Built-in EC exists on this device and use_delay_agnostic_aec is not
       // overriding it. Enable/Disable it according to the echo_cancellation
       // audio option.
       const bool enable_built_in_aec =
           *options.echo_cancellation && !use_delay_agnostic_aec;
       if (voe_wrapper_->hw()->EnableBuiltInAEC(enable_built_in_aec) == 0 &&
           enable_built_in_aec) {
         // Disable internal software EC if built-in EC is enabled,
         // i.e., replace the software EC with the built-in EC.
-        options.echo_cancellation = rtc::Maybe<bool>(false);
+        options.echo_cancellation = rtc::Optional<bool>(false);
         LOG(LS_INFO) << "Disabling EC since built-in EC will be used instead";
       }
     }
     if (voep->SetEcStatus(*options.echo_cancellation, ec_mode) == -1) {
       LOG_RTCERR2(SetEcStatus, *options.echo_cancellation, ec_mode);
       return false;
     } else {
       LOG(LS_INFO) << "Echo control set to " << *options.echo_cancellation
                    << " with mode " << ec_mode;
     }
@@ skipping 14 matching lines @@
   }
 
   if (options.auto_gain_control) {
     const bool built_in_agc = voe_wrapper_->hw()->BuiltInAGCIsAvailable();
     if (built_in_agc) {
       if (voe_wrapper_->hw()->EnableBuiltInAGC(*options.auto_gain_control) ==
               0 &&
           *options.auto_gain_control) {
         // Disable internal software AGC if built-in AGC is enabled,
         // i.e., replace the software AGC with the built-in AGC.
-        options.auto_gain_control = rtc::Maybe<bool>(false);
+        options.auto_gain_control = rtc::Optional<bool>(false);
         LOG(LS_INFO) << "Disabling AGC since built-in AGC will be used instead";
       }
     }
     if (voep->SetAgcStatus(*options.auto_gain_control, agc_mode) == -1) {
       LOG_RTCERR2(SetAgcStatus, *options.auto_gain_control, agc_mode);
       return false;
     } else {
       LOG(LS_INFO) << "Auto gain set to " << *options.auto_gain_control
                    << " with mode " << agc_mode;
     }
@@ skipping 26 matching lines @@
   }
 
   if (options.noise_suppression) {
     const bool built_in_ns = voe_wrapper_->hw()->BuiltInNSIsAvailable();
     if (built_in_ns) {
       if (voe_wrapper_->hw()->EnableBuiltInNS(*options.noise_suppression) ==
               0 &&
           *options.noise_suppression) {
         // Disable internal software NS if built-in NS is enabled,
         // i.e., replace the software NS with the built-in NS.
-        options.noise_suppression = rtc::Maybe<bool>(false);
+        options.noise_suppression = rtc::Optional<bool>(false);
         LOG(LS_INFO) << "Disabling NS since built-in NS will be used instead";
       }
     }
     if (voep->SetNsStatus(*options.noise_suppression, ns_mode) == -1) {
       LOG_RTCERR2(SetNsStatus, *options.noise_suppression, ns_mode);
       return false;
     } else {
       LOG(LS_INFO) << "Noise suppression set to " << *options.noise_suppression
                    << " with mode " << ns_mode;
     }
@@ skipping 2071 matching lines @@
       LOG(LS_WARNING) << "Unknown codec " << ToString(codec);
       return false;
     }
   }
   return true;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE