Revert of Moving MediaStreamSignaling logic into PeerConnection.

talk/app/webrtc/webrtcsessiondescriptionfactory.cc

 /*
  * libjingle
  * Copyright 2013 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 13 matching lines @@
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "talk/app/webrtc/webrtcsessiondescriptionfactory.h"
 
 #include "talk/app/webrtc/dtlsidentitystore.h"
 #include "talk/app/webrtc/jsep.h"
 #include "talk/app/webrtc/jsepsessiondescription.h"
 #include "talk/app/webrtc/mediaconstraintsinterface.h"
+#include "talk/app/webrtc/mediastreamsignaling.h"
 #include "talk/app/webrtc/webrtcsession.h"
 #include "webrtc/base/sslidentity.h"
 
 using cricket::MediaSessionOptions;
 
 namespace webrtc {
 namespace {
 static const char kFailedDueToIdentityFailed[] =
     " failed because DTLS identity request failed";
 static const char kFailedDueToSessionShutdown[] =
@@ skipping 79 matching lines @@
       if (!dest_candidates->HasCandidate(new_candidate))
         dest_desc->AddCandidate(source_candidates->at(n));
     }
   }
 }
 
 // Private constructor called by other constructors.
 WebRtcSessionDescriptionFactory::WebRtcSessionDescriptionFactory(
     rtc::Thread* signaling_thread,
     cricket::ChannelManager* channel_manager,
+    MediaStreamSignaling* mediastream_signaling,
     rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
     const rtc::scoped_refptr<WebRtcIdentityRequestObserver>&
         identity_request_observer,
     WebRtcSession* session,
     const std::string& session_id,
+    cricket::DataChannelType dct,
     bool dtls_enabled)
     : signaling_thread_(signaling_thread),
+      mediastream_signaling_(mediastream_signaling),
       session_desc_factory_(channel_manager, &transport_desc_factory_),
       // RFC 4566 suggested a Network Time Protocol (NTP) format timestamp
       // as the session id and session version. To simplify, it should be fine
       // to just use a random number as session id and start version from
       // |kInitSessionVersion|.
       session_version_(kInitSessionVersion),
       dtls_identity_store_(dtls_identity_store.Pass()),
       identity_request_observer_(identity_request_observer),
       session_(session),
       session_id_(session_id),
+      data_channel_type_(dct),
       certificate_request_state_(CERTIFICATE_NOT_NEEDED) {
   session_desc_factory_.set_add_legacy_streams(false);
   // SRTP-SDES is disabled if DTLS is on.
   SetSdesPolicy(dtls_enabled ? cricket::SEC_DISABLED : cricket::SEC_REQUIRED);
 }
 
 WebRtcSessionDescriptionFactory::WebRtcSessionDescriptionFactory(
     rtc::Thread* signaling_thread,
     cricket::ChannelManager* channel_manager,
+    MediaStreamSignaling* mediastream_signaling,
     WebRtcSession* session,
-    const std::string& session_id)
+    const std::string& session_id,
+    cricket::DataChannelType dct)
     : WebRtcSessionDescriptionFactory(signaling_thread,
                                       channel_manager,
+                                      mediastream_signaling,
                                       nullptr,
                                       nullptr,
                                       session,
                                       session_id,
+                                      dct,
                                       false) {
   LOG(LS_VERBOSE) << "DTLS-SRTP disabled.";
 }
 
 WebRtcSessionDescriptionFactory::WebRtcSessionDescriptionFactory(
     rtc::Thread* signaling_thread,
     cricket::ChannelManager* channel_manager,
+    MediaStreamSignaling* mediastream_signaling,
     rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
     WebRtcSession* session,
-    const std::string& session_id)
+    const std::string& session_id,
+    cricket::DataChannelType dct)
     : WebRtcSessionDescriptionFactory(
-          signaling_thread,
-          channel_manager,
-          dtls_identity_store.Pass(),
-          new rtc::RefCountedObject<WebRtcIdentityRequestObserver>(),
-          session,
-          session_id,
-          true) {
+        signaling_thread,
+        channel_manager,
+        mediastream_signaling,
+        dtls_identity_store.Pass(),
+        new rtc::RefCountedObject<WebRtcIdentityRequestObserver>(),
+        session,
+        session_id,
+        dct,
+        true) {
   RTC_DCHECK(dtls_identity_store_);
 
   certificate_request_state_ = CERTIFICATE_WAITING;
 
   identity_request_observer_->SignalRequestFailed.connect(
       this, &WebRtcSessionDescriptionFactory::OnIdentityRequestFailed);
   identity_request_observer_->SignalCertificateReady.connect(
       this, &WebRtcSessionDescriptionFactory::SetCertificate);
 
   rtc::KeyType key_type = rtc::KT_DEFAULT;
   LOG(LS_VERBOSE) << "DTLS-SRTP enabled; sending DTLS identity request (key "
                   << "type: " << key_type << ").";
 
   // Request identity. This happens asynchronously, so the caller will have a
   // chance to connect to SignalIdentityReady.
   dtls_identity_store_->RequestIdentity(key_type, identity_request_observer_);
 }
 
 WebRtcSessionDescriptionFactory::WebRtcSessionDescriptionFactory(
     rtc::Thread* signaling_thread,
     cricket::ChannelManager* channel_manager,
+    MediaStreamSignaling* mediastream_signaling,
     const rtc::scoped_refptr<rtc::RTCCertificate>& certificate,
     WebRtcSession* session,
-    const std::string& session_id)
-    : WebRtcSessionDescriptionFactory(signaling_thread,
-                                      channel_manager,
-                                      nullptr,
-                                      nullptr,
-                                      session,
-                                      session_id,
-                                      true) {
+    const std::string& session_id,
+    cricket::DataChannelType dct)
+    : WebRtcSessionDescriptionFactory(
+        signaling_thread, channel_manager, mediastream_signaling, nullptr,
+        nullptr, session, session_id, dct, true) {
   RTC_DCHECK(certificate);
 
   certificate_request_state_ = CERTIFICATE_WAITING;
 
   LOG(LS_VERBOSE) << "DTLS-SRTP enabled; has certificate parameter.";
   // We already have a certificate but we wait to do SetIdentity; if we do
   // it in the constructor then the caller has not had a chance to connect to
   // SignalIdentityReady.
   signaling_thread_->Post(
       this, MSG_USE_CONSTRUCTOR_CERTIFICATE,
@@ skipping 20 matching lines @@
       // destructor that caused WebRtcSessionDescriptionFactory's destruction.
       // The callback is then ignored, leaking memory allocated by OnMessage for
       // MSG_USE_CONSTRUCTOR_CERTIFICATE.
       delete msg.pdata;
     }
   }
 }
 
 void WebRtcSessionDescriptionFactory::CreateOffer(
     CreateSessionDescriptionObserver* observer,
-    const PeerConnectionInterface::RTCOfferAnswerOptions& options,
-    const cricket::MediaSessionOptions& session_options) {
+    const PeerConnectionInterface::RTCOfferAnswerOptions& options) {
+  cricket::MediaSessionOptions session_options;
+
   std::string error = "CreateOffer";
   if (certificate_request_state_ == CERTIFICATE_FAILED) {
     error += kFailedDueToIdentityFailed;
     LOG(LS_ERROR) << error;
     PostCreateSessionDescriptionFailed(observer, error);
     return;
   }
 
+  if (!mediastream_signaling_->GetOptionsForOffer(options,
+                                                  &session_options)) {
+    error += " called with invalid options.";
+    LOG(LS_ERROR) << error;
+    PostCreateSessionDescriptionFailed(observer, error);
+    return;
+  }
+
   if (!ValidStreams(session_options.streams)) {
     error += " called with invalid media streams.";
     LOG(LS_ERROR) << error;
     PostCreateSessionDescriptionFailed(observer, error);
     return;
   }
 
+  if (data_channel_type_ == cricket::DCT_SCTP &&
+      mediastream_signaling_->HasDataChannels()) {
+    session_options.data_channel_type = cricket::DCT_SCTP;
+  }
+
   CreateSessionDescriptionRequest request(
       CreateSessionDescriptionRequest::kOffer, observer, session_options);
   if (certificate_request_state_ == CERTIFICATE_WAITING) {
     create_session_description_requests_.push(request);
   } else {
     ASSERT(certificate_request_state_ == CERTIFICATE_SUCCEEDED ||
            certificate_request_state_ == CERTIFICATE_NOT_NEEDED);
     InternalCreateOffer(request);
   }
 }
 
 void WebRtcSessionDescriptionFactory::CreateAnswer(
     CreateSessionDescriptionObserver* observer,
-    const MediaConstraintsInterface* constraints,
-    const cricket::MediaSessionOptions& session_options) {
+    const MediaConstraintsInterface* constraints) {
   std::string error = "CreateAnswer";
   if (certificate_request_state_ == CERTIFICATE_FAILED) {
     error += kFailedDueToIdentityFailed;
     LOG(LS_ERROR) << error;
     PostCreateSessionDescriptionFailed(observer, error);
     return;
   }
   if (!session_->remote_description()) {
     error += " can't be called before SetRemoteDescription.";
     LOG(LS_ERROR) << error;
     PostCreateSessionDescriptionFailed(observer, error);
     return;
   }
   if (session_->remote_description()->type() !=
       JsepSessionDescription::kOffer) {
     error += " failed because remote_description is not an offer.";
     LOG(LS_ERROR) << error;
     PostCreateSessionDescriptionFailed(observer, error);
     return;
   }
 
-  if (!ValidStreams(session_options.streams)) {
+  cricket::MediaSessionOptions options;
+  if (!mediastream_signaling_->GetOptionsForAnswer(constraints, &options)) {
+    error += " called with invalid constraints.";
+    LOG(LS_ERROR) << error;
+    PostCreateSessionDescriptionFailed(observer, error);
+    return;
+  }
+  if (!ValidStreams(options.streams)) {
     error += " called with invalid media streams.";
     LOG(LS_ERROR) << error;
     PostCreateSessionDescriptionFailed(observer, error);
     return;
   }
+  // RTP data channel is handled in MediaSessionOptions::AddStream. SCTP streams
+  // are not signaled in the SDP so does not go through that path and must be
+  // handled here.
+  if (data_channel_type_ == cricket::DCT_SCTP) {
+    options.data_channel_type = cricket::DCT_SCTP;
+  }
 
   CreateSessionDescriptionRequest request(
-      CreateSessionDescriptionRequest::kAnswer, observer, session_options);
+      CreateSessionDescriptionRequest::kAnswer, observer, options);
   if (certificate_request_state_ == CERTIFICATE_WAITING) {
     create_session_description_requests_.push(request);
   } else {
     ASSERT(certificate_request_state_ == CERTIFICATE_SUCCEEDED ||
            certificate_request_state_ == CERTIFICATE_NOT_NEEDED);
     InternalCreateAnswer(request);
   }
 }
 
 void WebRtcSessionDescriptionFactory::SetSdesPolicy(
@@ skipping 168 matching lines @@
     if (create_session_description_requests_.front().type ==
         CreateSessionDescriptionRequest::kOffer) {
       InternalCreateOffer(create_session_description_requests_.front());
     } else {
       InternalCreateAnswer(create_session_description_requests_.front());
     }
     create_session_description_requests_.pop();
   }
 }
 }  // namespace webrtc