Non-constraint interfaces for all constrainable interfaces

webrtc/api/peerconnection.cc

Index: webrtc/api/peerconnection.cc
diff --git a/webrtc/api/peerconnection.cc b/webrtc/api/peerconnection.cc
index ee359271c2fc2573b2f209d9af2c365ed6a5970c..f9aad3d7662c9c2b5b95a311ba66ef32aed4a09b 100644
--- a/webrtc/api/peerconnection.cc
+++ b/webrtc/api/peerconnection.cc
@@ -452,6 +452,13 @@ bool ConvertRtcOptionsForOffer(
   return true;
 }
 
+bool ConvertRtcOptionsForAnswer(
+    const PeerConnectionInterface::RTCOfferAnswerOptions& rtc_options,
+    cricket::MediaSessionOptions* session_options) {
+  // TODO(hta): Figure out if there's a difference
+  return ConvertRtcOptionsForOffer(rtc_options, session_options);
+}
+
 bool ParseConstraintsForAnswer(const MediaConstraintsInterface* constraints,
                                cricket::MediaSessionOptions* session_options) {
   bool value = false;
@@ -566,7 +573,6 @@ PeerConnection::~PeerConnection() {
 
 bool PeerConnection::Initialize(
     const PeerConnectionInterface::RTCConfiguration& configuration,
-    const MediaConstraintsInterface* constraints,
     rtc::scoped_ptr<cricket::PortAllocator> allocator,
     rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
     PeerConnectionObserver* observer) {
@@ -591,13 +597,9 @@ bool PeerConnection::Initialize(
   int portallocator_flags = port_allocator_->flags();
   portallocator_flags |= cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET |
                          cricket::PORTALLOCATOR_ENABLE_IPV6;
-  bool value;
   // If IPv6 flag was specified, we'll not override it by experiment.
-  if (FindConstraint(constraints, MediaConstraintsInterface::kEnableIPv6,
-                     &value, nullptr)) {
-    if (!value) {
-      portallocator_flags &= ~(cricket::PORTALLOCATOR_ENABLE_IPV6);
-    }
+  if (configuration.disable_ipv6) {
+    portallocator_flags &= ~(cricket::PORTALLOCATOR_ENABLE_IPV6);
   } else if (webrtc::field_trial::FindFullName("WebRTC-IPv6Default") ==
              "Disabled") {
     portallocator_flags &= ~(cricket::PORTALLOCATOR_ENABLE_IPV6);
@@ -619,11 +621,14 @@ bool PeerConnection::Initialize(
       configuration.disable_prerenderer_smoothing;
 
   // Find DSCP constraint.
-  FindConstraint(constraints, MediaConstraintsInterface::kEnableDscp,
-                 &media_config.enable_dscp, NULL);
+  if (configuration.enable_dscp) {
+    media_config.enable_dscp = *(configuration.enable_dscp);

[nisse-webrtc, 2016/02/25 08:26:51]

I agree this use of rtc::Optional makes some sense. Since it represents a "raw"
user config.

However, I think the call-site in PeerConnectionFactory is a more natural place
to merge config values from different sources. See my other comment on that
file. 

I'm also missing the logic for dscp experiments; in the current cl, if the
constraint is unset, media_config.enable_dscp always get the compiled-in default
of false (from the declaration in mediachannel.h).
So it's not clear to me how you intend to make the default configurable by
chrome (or other applications).

[hta-webrtc, 2016/02/25 14:32:42]

I was misremembering (it is the IPv6 that is controlled by experiment -
webrtc::field_trial::FindFullName - see above.)
I'll see what i can do about lifting the logic.

+  }
   // Find constraints for cpu overuse detection.
-  FindConstraint(constraints, MediaConstraintsInterface::kCpuOveruseDetection,
-                 &media_config.enable_cpu_overuse_detection, NULL);
+  if (configuration.cpu_overuse_detection) {
+    media_config.enable_cpu_overuse_detection =
+        *(configuration.cpu_overuse_detection);
+  }
 
   media_controller_.reset(factory_->CreateMediaController(media_config));
 
@@ -636,8 +641,8 @@ bool PeerConnection::Initialize(
   stats_.reset(new StatsCollector(this));
 
   // Initialize the WebRtcSession. It creates transport channels etc.
-  if (!session_->Initialize(factory_->options(), constraints,
-                            std::move(dtls_identity_store), configuration)) {
+  if (!session_->Initialize(factory_->options(), std::move(dtls_identity_store),
+                            configuration)) {
     return false;
   }
 
@@ -1001,7 +1006,26 @@ void PeerConnection::CreateAnswer(
     return;
   }
 
-  session_->CreateAnswer(observer, constraints, session_options);
+  session_->CreateAnswer(observer, session_options);
+}
+
+void PeerConnection::CreateAnswer(CreateSessionDescriptionObserver* observer,
+                                  const RTCOfferAnswerOptions& options) {
+  TRACE_EVENT0("webrtc", "PeerConnection::CreateAnswer");
+  if (!VERIFY(observer != nullptr)) {
+    LOG(LS_ERROR) << "CreateAnswer - observer is NULL.";
+    return;
+  }
+
+  cricket::MediaSessionOptions session_options;
+  if (!GetOptionsForAnswer(options, &session_options)) {
+    std::string error = "CreateAnswer called with invalid options.";
+    LOG(LS_ERROR) << error;
+    PostCreateSessionDescriptionFailure(observer, error);
+    return;
+  }
+
+  session_->CreateAnswer(observer, session_options);
 }
 
 void PeerConnection::SetLocalDescription(
@@ -1533,11 +1557,8 @@ bool PeerConnection::GetOptionsForOffer(
   return true;
 }
 
-bool PeerConnection::GetOptionsForAnswer(
-    const MediaConstraintsInterface* constraints,
+void PeerConnection::FinishOptionsForAnswer(
     cricket::MediaSessionOptions* session_options) {
-  session_options->recv_audio = false;
-  session_options->recv_video = false;
   // TODO(deadbeef): Once we have transceivers, enumerate them here instead of
   // ContentInfos.
   if (session_->remote_description()) {
@@ -1548,10 +1569,6 @@ bool PeerConnection::GetOptionsForAnswer(
           cricket::TransportOptions();
     }
   }
-  if (!ParseConstraintsForAnswer(constraints, session_options)) {
-    return false;
-  }
-
   AddSendStreams(session_options, senders_, rtp_data_channels_);
   session_options->bundle_enabled =
       session_options->bundle_enabled &&
@@ -1564,6 +1581,29 @@ bool PeerConnection::GetOptionsForAnswer(
   if (session_->data_channel_type() == cricket::DCT_SCTP) {
     session_options->data_channel_type = cricket::DCT_SCTP;
   }
+}
+
+bool PeerConnection::GetOptionsForAnswer(
+    const MediaConstraintsInterface* constraints,
+    cricket::MediaSessionOptions* session_options) {
+  session_options->recv_audio = false;
+  session_options->recv_video = false;
+  if (!ParseConstraintsForAnswer(constraints, session_options)) {
+    return false;
+  }
+  FinishOptionsForAnswer(session_options);
+  return true;
+}
+
+bool PeerConnection::GetOptionsForAnswer(
+    const RTCOfferAnswerOptions& options,
+    cricket::MediaSessionOptions* session_options) {
+  session_options->recv_audio = false;
+  session_options->recv_video = false;
+  if (!ConvertRtcOptionsForAnswer(options, session_options)) {
+    return false;
+  }
+  FinishOptionsForAnswer(session_options);
   return true;
 }
 
@@ -2099,4 +2139,41 @@ DataChannel* PeerConnection::FindDataChannelBySid(int sid) const {
   return nullptr;
 }
 
+void CopyConstraintsIntoRtcConfiguration(
+    const MediaConstraintsInterface* constraints,
+    PeerConnectionInterface::RTCConfiguration* configuration) {
+  // Copy info from constraints into configuration, if present.
+  if (!constraints) {
+    return;
+  }
+
+  bool value;
+  if (FindConstraint(constraints, MediaConstraintsInterface::kEnableIPv6,
+                     &value, nullptr)) {
+    if (!value) {
+      configuration->disable_ipv6 = true;
+    }
+  }
+  configuration->enable_dscp = ConstraintToOptionalBool(
+      constraints, MediaConstraintsInterface::kEnableDscp);
+  configuration->cpu_overuse_detection = ConstraintToOptionalBool(
+      constraints, MediaConstraintsInterface::kCpuOveruseDetection);
+  if (FindConstraint(constraints,
+                     MediaConstraintsInterface::kEnableRtpDataChannels, &value,
+                     NULL) &&
+      value) {
+    configuration->enable_rtp_data_channel = true;
+  }
+  // Find Suspend Below Min Bitrate constraint.
+  configuration->suspend_below_min_bitrate = ConstraintToOptionalBool(
+      constraints,
+      MediaConstraintsInterface::kEnableVideoSuspendBelowMinBitrate);
+  configuration->screencast_min_bitrate = ConstraintToOptionalInt(
+      constraints, MediaConstraintsInterface::kScreencastMinBitrate);
+  configuration->combined_audio_video_bwe = ConstraintToOptionalBool(
+      constraints, MediaConstraintsInterface::kCombinedAudioVideoBwe);
+  configuration->enable_dtls_srtp = ConstraintToOptionalBool(
+      constraints, MediaConstraintsInterface::kEnableDtlsSrtp);
+}
+
 }  // namespace webrtc