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

talk/app/webrtc/webrtcsession.cc

Index: talk/app/webrtc/webrtcsession.cc
diff --git a/talk/app/webrtc/webrtcsession.cc b/talk/app/webrtc/webrtcsession.cc
index 95abeab77a9c9e6dc6e1a1033b083d9f41535e7a..3e62fc640d4ca3c359ef29b63d220293322ef240 100644
--- a/talk/app/webrtc/webrtcsession.cc
+++ b/talk/app/webrtc/webrtcsession.cc
@@ -441,10 +441,11 @@ static std::string MakeTdErrorString(const std::string& desc) {
 
 // Set |option| to the highest-priority value of |key| in the optional
 // constraints if the key is found and has a valid value.
-template<typename T>
+template <typename T>
 static void SetOptionFromOptionalConstraint(
     const MediaConstraintsInterface* constraints,
-    const std::string& key, cricket::Settable<T>* option) {
+    const std::string& key,
+    rtc::Maybe<T>* option) {
   if (!constraints) {
     return;
   }
@@ -452,7 +453,7 @@ static void SetOptionFromOptionalConstraint(
   T value;
   if (constraints->GetOptional().FindFirst(key, &string_value)) {
     if (rtc::FromString(string_value, &value)) {
-      option->Set(value);
+      *option = value;
     }
   }
 }
@@ -644,8 +645,8 @@ bool WebRtcSession::Initialize(
         constraints,
         MediaConstraintsInterface::kEnableDscp,
         &value, NULL)) {
-    audio_options_.dscp.Set(value);
-    video_options_.dscp.Set(value);
+    audio_options_.dscp = value;
+    video_options_.dscp = value;
   }
 
   // Find Suspend Below Min Bitrate constraint.
@@ -654,7 +655,7 @@ bool WebRtcSession::Initialize(
           MediaConstraintsInterface::kEnableVideoSuspendBelowMinBitrate,
           &value,
           NULL)) {
-    video_options_.suspend_below_min_bitrate.Set(value);
+    video_options_.suspend_below_min_bitrate = value;
   }
 
   SetOptionFromOptionalConstraint(constraints,
@@ -684,12 +685,10 @@ bool WebRtcSession::Initialize(
   SetOptionFromOptionalConstraint(constraints,
       MediaConstraintsInterface::kNumUnsignalledRecvStreams,
       &video_options_.unsignalled_recv_stream_limit);
-  if (video_options_.unsignalled_recv_stream_limit.IsSet()) {
-    int stream_limit;
-    video_options_.unsignalled_recv_stream_limit.Get(&stream_limit);
-    stream_limit = std::min(kMaxUnsignalledRecvStreams, stream_limit);
-    stream_limit = std::max(0, stream_limit);
-    video_options_.unsignalled_recv_stream_limit.Set(stream_limit);
+  if (video_options_.unsignalled_recv_stream_limit) {
+    video_options_.unsignalled_recv_stream_limit =

[the sun, 2015/10/28 13:18:01]

The above two lines are pretty confusing.

This syntax is likely the reason std::optional isn't standardized yet. My
problem is that it is easy to forget that we're accessing the Maybe<> and not a
value, yet the second line looks like we have direct access to the value. 

Also it is inconsistent with standard C syntax in that you can use direct
assignment to set the value, but need to dereference to get the value.

[kwiberg-webrtc, 2015/10/28 14:34:38]

I agree that it isn't 100% obvious. But this is how std::experimental::optional
does it, so I'm not sure how incompatible we ought to be.

Our options are basically (1) the current operator= overload:

  x = 4;

(2) a Set method (which is what Settable used):

  x.Set(4);

and (3) relying on operator= with a Maybe on the right-hand side:

  x = rtc::Maybe<int>(4);

If we don't pick option (1), my vote is on option (3), since that's compatible
with std::experimental::optional. What do you think?

[the sun, 2015/10/28 14:45:48]

Option 4:
Drop assignment overload and always require dereference to access the value:

*x = 4

Which is a syntax which will work regardless?

+        std::max(0, std::min(kMaxUnsignalledRecvStreams,
+                             *video_options_.unsignalled_recv_stream_limit));
   }
 
   SetOptionFromOptionalConstraint(constraints,
@@ -700,11 +699,11 @@ bool WebRtcSession::Initialize(
       MediaConstraintsInterface::kCombinedAudioVideoBwe,
       &audio_options_.combined_audio_video_bwe);
 
-  audio_options_.audio_jitter_buffer_max_packets.Set(
-      rtc_configuration.audio_jitter_buffer_max_packets);
+  audio_options_.audio_jitter_buffer_max_packets =
+      rtc_configuration.audio_jitter_buffer_max_packets;
 
-  audio_options_.audio_jitter_buffer_fast_accelerate.Set(
-      rtc_configuration.audio_jitter_buffer_fast_accelerate);
+  audio_options_.audio_jitter_buffer_fast_accelerate =
+      rtc_configuration.audio_jitter_buffer_fast_accelerate;
 
   const cricket::VideoCodec default_codec(
       JsepSessionDescription::kDefaultVideoCodecId,