Non-constraint interfaces for all constrainable interfaces

webrtc/api/webrtcsession.cc

 /*
  *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/api/webrtcsession.h"
 
 #include <limits.h>
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "webrtc/api/jsepicecandidate.h"
 #include "webrtc/api/jsepsessiondescription.h"
-#include "webrtc/api/mediaconstraintsinterface.h"
 #include "webrtc/api/peerconnectioninterface.h"
 #include "webrtc/api/sctputils.h"
 #include "webrtc/api/webrtcsessiondescriptionfactory.h"
 #include "webrtc/audio/audio_sink.h"
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
@@ skipping 382 matching lines @@
                                    const std::string& desc) {
   std::ostringstream ret;
   ret << error << " " << desc;
   return ret.str();
 }
 
 static std::string MakeTdErrorString(const std::string& desc) {
   return MakeErrorString(kPushDownTDFailed, 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>
-static void SetOptionFromOptionalConstraint(
-    const MediaConstraintsInterface* constraints,
-    const std::string& key,
-    rtc::Optional<T>* option) {
-  if (!constraints) {
-    return;
-  }
-  std::string string_value;
-  T value;
-  if (constraints->GetOptional().FindFirst(key, &string_value)) {
-    if (rtc::FromString(string_value, &value)) {
-      *option = rtc::Optional<T>(value);
-    }
-  }
-}
-
 uint32_t ConvertIceTransportTypeToCandidateFilter(
     PeerConnectionInterface::IceTransportsType type) {
   switch (type) {
     case PeerConnectionInterface::kNone:
         return cricket::CF_NONE;
     case PeerConnectionInterface::kRelay:
         return cricket::CF_RELAY;
     case PeerConnectionInterface::kNoHost:
         return (cricket::CF_ALL & ~cricket::CF_HOST);
     case PeerConnectionInterface::kAll:
@@ skipping 118 matching lines @@
     SignalDataChannelDestroyed();
     channel_manager_->DestroyDataChannel(data_channel_.release());
   }
   SignalDestroyed();
 
   LOG(LS_INFO) << "Session: " << id() << " is destroyed.";
 }
 
 bool WebRtcSession::Initialize(
     const PeerConnectionFactoryInterface::Options& options,
-    const MediaConstraintsInterface* constraints,
     rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
     const PeerConnectionInterface::RTCConfiguration& rtc_configuration) {
   bundle_policy_ = rtc_configuration.bundle_policy;
   rtcp_mux_policy_ = rtc_configuration.rtcp_mux_policy;
   transport_controller_->SetSslMaxProtocolVersion(options.ssl_max_version);
 
   // Obtain a certificate from RTCConfiguration if any were provided (optional).
   rtc::scoped_refptr<rtc::RTCCertificate> certificate;
   if (!rtc_configuration.certificates.empty()) {
     // TODO(hbos,torbjorng): Decide on certificate-selection strategy instead of
     // just picking the first one. The decision should be made based on the DTLS
     // handshake. The DTLS negotiations need to know about all certificates.
     certificate = rtc_configuration.certificates[0];
   }
 
   SetIceConfig(ParseIceConfig(rtc_configuration));
 
-  // TODO(perkj): Take |constraints| into consideration. Return false if not all
-  // mandatory constraints can be fulfilled. Note that |constraints|
-  // can be null.
-  bool value;
-
   if (options.disable_encryption) {
     dtls_enabled_ = false;
   } else {
     // Enable DTLS by default if we have an identity store or a certificate.
     dtls_enabled_ = (dtls_identity_store || certificate);
-    // |constraints| can override the default |dtls_enabled_| value.
-    if (FindConstraint(constraints, MediaConstraintsInterface::kEnableDtlsSrtp,
-                       &value, nullptr)) {
-      dtls_enabled_ = value;
+    // |rtc_configuration| can override the default |dtls_enabled_| value.
+    if (rtc_configuration.override_enable_dtls_srtp) {
+      dtls_enabled_ = rtc_configuration.enable_dtls_srtp;
     }
   }
 
   // Enable creation of RTP data channels if the kEnableRtpDataChannels is set.
   // It takes precendence over the disable_sctp_data_channels
   // PeerConnectionFactoryInterface::Options.
-  if (FindConstraint(
-      constraints, MediaConstraintsInterface::kEnableRtpDataChannels,
-      &value, NULL) && value) {
-    LOG(LS_INFO) << "Allowing RTP data engine.";
+  if (rtc_configuration.enable_rtp_data_channel) {
     data_channel_type_ = cricket::DCT_RTP;
   } else {
     // DTLS has to be enabled to use SCTP.
     if (!options.disable_sctp_data_channels && dtls_enabled_) {
-      LOG(LS_INFO) << "Allowing SCTP data engine.";
       data_channel_type_ = cricket::DCT_SCTP;
     }
   }
 
   // Find Suspend Below Min Bitrate constraint.
-  if (FindConstraint(
-          constraints,
-          MediaConstraintsInterface::kEnableVideoSuspendBelowMinBitrate,
-          &value,
-          NULL)) {
-    video_options_.suspend_below_min_bitrate = rtc::Optional<bool>(value);
+  if (rtc_configuration.override_suspend_below_min_bitrate) {
+    video_options_.suspend_below_min_bitrate =
+        rtc::Optional<bool>(rtc_configuration.suspend_below_min_bitrate);
   }
 
-  SetOptionFromOptionalConstraint(constraints,
-      MediaConstraintsInterface::kScreencastMinBitrate,
-      &video_options_.screencast_min_bitrate_kbps);
-
-  SetOptionFromOptionalConstraint(constraints,
-      MediaConstraintsInterface::kCombinedAudioVideoBwe,
-      &audio_options_.combined_audio_video_bwe);
+  if (rtc_configuration.override_screencast_min_bitrate) {
+    video_options_.screencast_min_bitrate_kbps =
+        rtc::Optional<int>(rtc_configuration.screencast_min_bitrate);
+  }
+  if (rtc_configuration.override_combined_audio_video_bwe) {
+    audio_options_.combined_audio_video_bwe =
+        rtc::Optional<bool>(rtc_configuration.combined_audio_video_bwe);
+  }
 
   audio_options_.audio_jitter_buffer_max_packets =
       rtc::Optional<int>(rtc_configuration.audio_jitter_buffer_max_packets);
 
   audio_options_.audio_jitter_buffer_fast_accelerate = rtc::Optional<bool>(
       rtc_configuration.audio_jitter_buffer_fast_accelerate);
 
   if (!dtls_enabled_) {
     // Construct with DTLS disabled.
     webrtc_session_desc_factory_.reset(new WebRtcSessionDescriptionFactory(
@@ skipping 59 matching lines @@
 
 void WebRtcSession::CreateOffer(
     CreateSessionDescriptionObserver* observer,
     const PeerConnectionInterface::RTCOfferAnswerOptions& options,
     const cricket::MediaSessionOptions& session_options) {
   webrtc_session_desc_factory_->CreateOffer(observer, options, session_options);
 }
 
 void WebRtcSession::CreateAnswer(
     CreateSessionDescriptionObserver* observer,
-    const MediaConstraintsInterface* constraints,
     const cricket::MediaSessionOptions& session_options) {
-  webrtc_session_desc_factory_->CreateAnswer(observer, constraints,
-                                             session_options);
+  webrtc_session_desc_factory_->CreateAnswer(observer, session_options);
 }
 
 bool WebRtcSession::SetLocalDescription(SessionDescriptionInterface* desc,
                                         std::string* err_desc) {
   ASSERT(signaling_thread()->IsCurrent());
 
   // Takes the ownership of |desc| regardless of the result.
   rtc::scoped_ptr<SessionDescriptionInterface> desc_temp(desc);
 
   // Validate SDP.
@@ skipping 1401 matching lines @@
   }
 }
 
 void WebRtcSession::OnSentPacket_w(cricket::TransportChannel* channel,
                                    const rtc::SentPacket& sent_packet) {
   RTC_DCHECK(worker_thread()->IsCurrent());
   media_controller_->call_w()->OnSentPacket(sent_packet);
 }
 
 }  // namespace webrtc