Revert of Moving MediaStreamSignaling logic into PeerConnection.

talk/app/webrtc/webrtcsession.cc

 /*
  * libjingle
  * Copyright 2012 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 20 matching lines @@
 
 #include <algorithm>
 #include <vector>
 #include <set>
 
 #include "talk/app/webrtc/jsepicecandidate.h"
 #include "talk/app/webrtc/jsepsessiondescription.h"
 #include "talk/app/webrtc/mediaconstraintsinterface.h"
 #include "talk/app/webrtc/mediastreamsignaling.h"
 #include "talk/app/webrtc/peerconnectioninterface.h"
-#include "talk/app/webrtc/sctputils.h"
 #include "talk/app/webrtc/webrtcsessiondescriptionfactory.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/videocapturer.h"
 #include "talk/session/media/channel.h"
 #include "talk/session/media/channelmanager.h"
 #include "talk/session/media/mediasession.h"
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
@@ skipping 478 matching lines @@
         return true;
       }
     }
     return false;
   }
 
  private:
   bool ice_restart_;
 };
 
-WebRtcSession::WebRtcSession(cricket::ChannelManager* channel_manager,
-                             rtc::Thread* signaling_thread,
-                             rtc::Thread* worker_thread,
-                             cricket::PortAllocator* port_allocator)
+WebRtcSession::WebRtcSession(
+    cricket::ChannelManager* channel_manager,
+    rtc::Thread* signaling_thread,
+    rtc::Thread* worker_thread,
+    cricket::PortAllocator* port_allocator,
+    MediaStreamSignaling* mediastream_signaling)
     : cricket::BaseSession(signaling_thread,
                            worker_thread,
                            port_allocator,
                            rtc::ToString(rtc::CreateRandomId64() & LLONG_MAX),
                            false),
       // RFC 3264: The numeric value of the session id and version in the
       // o line MUST be representable with a "64 bit signed integer".
       // Due to this constraint session id |sid_| is max limited to LLONG_MAX.
       channel_manager_(channel_manager),
+      mediastream_signaling_(mediastream_signaling),
       ice_observer_(NULL),
       ice_connection_state_(PeerConnectionInterface::kIceConnectionNew),
       ice_connection_receiving_(true),
       older_version_remote_peer_(false),
       dtls_enabled_(false),
       data_channel_type_(cricket::DCT_NONE),
       ice_restart_latch_(new IceRestartAnswerLatch),
       metrics_observer_(NULL) {
   transport_controller()->SignalConnectionState.connect(
       this, &WebRtcSession::OnTransportControllerConnectionState);
@@ skipping 71 matching lines @@
       &value, NULL) && value) {
     LOG(LS_INFO) << "Allowing RTP data engine.";
     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;
     }
   }
+  if (data_channel_type_ != cricket::DCT_NONE) {
+    mediastream_signaling_->SetDataChannelFactory(this);
+  }
 
   // Find DSCP constraint.
   if (FindConstraint(
         constraints,
         MediaConstraintsInterface::kEnableDscp,
         &value, NULL)) {
     audio_options_.dscp.Set(value);
     video_options_.dscp.Set(value);
   }
 
@@ skipping 77 matching lines @@
       JsepSessionDescription::kMaxVideoCodecWidth,
       JsepSessionDescription::kMaxVideoCodecHeight,
       JsepSessionDescription::kDefaultVideoCodecFramerate,
       JsepSessionDescription::kDefaultVideoCodecPreference);
   channel_manager_->SetDefaultVideoEncoderConfig(
       cricket::VideoEncoderConfig(default_codec));
 
   if (!dtls_enabled_) {
     // Construct with DTLS disabled.
     webrtc_session_desc_factory_.reset(new WebRtcSessionDescriptionFactory(
-        signaling_thread(), channel_manager_, this, id()));
+        signaling_thread(), channel_manager_, mediastream_signaling_, this,
+        id(), data_channel_type_));
   } else {
     // Construct with DTLS enabled.
     if (!certificate) {
       // Use the |dtls_identity_store| to generate a certificate.
       RTC_DCHECK(dtls_identity_store);
       webrtc_session_desc_factory_.reset(new WebRtcSessionDescriptionFactory(
-          signaling_thread(), channel_manager_, dtls_identity_store.Pass(),
-          this, id()));
+          signaling_thread(), channel_manager_, mediastream_signaling_,
+          dtls_identity_store.Pass(), this, id(), data_channel_type_));
     } else {
       // Use the already generated certificate.
       webrtc_session_desc_factory_.reset(new WebRtcSessionDescriptionFactory(
-          signaling_thread(), channel_manager_, certificate, this, id()));
+          signaling_thread(), channel_manager_, mediastream_signaling_,
+          certificate, this, id(), data_channel_type_));
     }
   }
 
   webrtc_session_desc_factory_->SignalCertificateReady.connect(
       this, &WebRtcSession::OnCertificateReady);
 
   if (options.disable_encryption) {
     webrtc_session_desc_factory_->SetSdesPolicy(cricket::SEC_DISABLED);
   }
   port_allocator()->set_candidate_filter(
@@ skipping 41 matching lines @@
     LOG(LS_INFO) << "Local and Remote descriptions must be applied to get "
                  << "SSL Role of the session.";
     return false;
   }
 
   return transport_controller()->GetSslRole(role);
 }
 
 void WebRtcSession::CreateOffer(
     CreateSessionDescriptionObserver* observer,
-    const PeerConnectionInterface::RTCOfferAnswerOptions& options,
-    const cricket::MediaSessionOptions& session_options) {
-  webrtc_session_desc_factory_->CreateOffer(observer, options, session_options);
+    const PeerConnectionInterface::RTCOfferAnswerOptions& options) {
+  webrtc_session_desc_factory_->CreateOffer(observer, options);
 }
 
-void WebRtcSession::CreateAnswer(
-    CreateSessionDescriptionObserver* observer,
-    const MediaConstraintsInterface* constraints,
-    const cricket::MediaSessionOptions& session_options) {
-  webrtc_session_desc_factory_->CreateAnswer(observer, constraints,
-                                             session_options);
+void WebRtcSession::CreateAnswer(CreateSessionDescriptionObserver* observer,
+                                 const MediaConstraintsInterface* constraints) {
+  webrtc_session_desc_factory_->CreateAnswer(observer, constraints);
 }
 
 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 37 matching lines @@
     // that we stored, and those from the remote description.
     if (!saved_candidates_.empty()) {
       // If there are saved candidates which arrived before the local
       // description was set, copy those to the remote description.
       CopySavedCandidates(remote_desc_.get());
     }
     // Push remote candidates in remote description to transport channels.
     UseCandidatesInSessionDescription(remote_desc_.get());
   }
 
+  // Update state and SSRC of local MediaStreams and DataChannels based on the
+  // local session description.
+  mediastream_signaling_->OnLocalDescriptionChanged(local_desc_.get());
+
+  rtc::SSLRole role;
+  if (data_channel_type_ == cricket::DCT_SCTP && GetSslRole(&role)) {
+    mediastream_signaling_->OnDtlsRoleReadyForSctp(role);
+  }
   if (error() != cricket::BaseSession::ERROR_NONE) {
     return BadLocalSdp(desc->type(), GetSessionErrorMsg(), err_desc);
   }
   return true;
 }
 
 bool WebRtcSession::SetRemoteDescription(SessionDescriptionInterface* desc,
                                          std::string* err_desc) {
   ASSERT(signaling_thread()->IsCurrent());
 
@@ skipping 16 matching lines @@
   // Remove unused channels if MediaContentDescription is rejected.
   RemoveUnusedChannels(desc->description());
 
   // NOTE: Candidates allocation will be initiated only when SetLocalDescription
   // is called.
   set_remote_description(desc->description()->Copy());
   if (!UpdateSessionState(action, cricket::CS_REMOTE, err_desc)) {
     return false;
   }
 
+  // Update remote MediaStreams.
+  mediastream_signaling_->OnRemoteDescriptionChanged(desc);
   if (local_description() && !UseCandidatesInSessionDescription(desc)) {
     return BadRemoteSdp(desc->type(), kInvalidCandidates, err_desc);
   }
 
   // Copy all saved candidates.
   CopySavedCandidates(desc);
 
   // Check if this new SessionDescription contains new ice ufrag and password
   // that indicates the remote peer requests ice restart.
   bool ice_restart =
       ice_restart_latch_->CheckForRemoteIceRestart(remote_desc_.get(), desc);
   // We retain all received candidates only if ICE is not restarted.
   // When ICE is restarted, all previous candidates belong to an old generation
   // and should not be kept.
   if (!ice_restart) {
     WebRtcSessionDescriptionFactory::CopyCandidatesFromSessionDescription(
         remote_desc_.get(), desc);
   }
 
   remote_desc_.reset(desc_temp.release());
 
+  rtc::SSLRole role;
+  if (data_channel_type_ == cricket::DCT_SCTP && GetSslRole(&role)) {
+    mediastream_signaling_->OnDtlsRoleReadyForSctp(role);
+  }
+
   if (error() != cricket::BaseSession::ERROR_NONE) {
     return BadRemoteSdp(desc->type(), GetSessionErrorMsg(), err_desc);
   }
 
   // Set the the ICE connection state to connecting since the connection may
   // become writable with peer reflexive candidates before any remote candidate
   // is signaled.
   // TODO(pthatcher): This is a short-term solution for crbug/446908. A real fix
   // is to have a new signal the indicates a change in checking state from the
   // transport and expose a new checking() member from transport that can be
@@ skipping 412 matching lines @@
 
 bool WebRtcSession::ConnectDataChannel(DataChannel* webrtc_data_channel) {
   if (!data_channel_) {
     LOG(LS_ERROR) << "ConnectDataChannel called when data_channel_ is NULL.";
     return false;
   }
   data_channel_->SignalReadyToSendData.connect(webrtc_data_channel,
                                                &DataChannel::OnChannelReady);
   data_channel_->SignalDataReceived.connect(webrtc_data_channel,
                                             &DataChannel::OnDataReceived);
-  data_channel_->SignalStreamClosedRemotely.connect(
-      webrtc_data_channel, &DataChannel::OnStreamClosedRemotely);
   return true;
 }
 
 void WebRtcSession::DisconnectDataChannel(DataChannel* webrtc_data_channel) {
   if (!data_channel_) {
     LOG(LS_ERROR) << "DisconnectDataChannel called when data_channel_ is NULL.";
     return;
   }
   data_channel_->SignalReadyToSendData.disconnect(webrtc_data_channel);
   data_channel_->SignalDataReceived.disconnect(webrtc_data_channel);
-  data_channel_->SignalStreamClosedRemotely.disconnect(webrtc_data_channel);
 }
 
 void WebRtcSession::AddSctpDataStream(int sid) {
   if (!data_channel_) {
     LOG(LS_ERROR) << "AddDataChannelStreams called when data_channel_ is NULL.";
     return;
   }
   data_channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(sid));
   data_channel_->AddSendStream(cricket::StreamParams::CreateLegacy(sid));
 }
 
 void WebRtcSession::RemoveSctpDataStream(int sid) {
+  mediastream_signaling_->RemoveSctpDataChannel(sid);
+
   if (!data_channel_) {
     LOG(LS_ERROR) << "RemoveDataChannelStreams called when data_channel_ is "
                   << "NULL.";
     return;
   }
   data_channel_->RemoveRecvStream(sid);
   data_channel_->RemoveSendStream(sid);
 }
 
 bool WebRtcSession::ReadyToSendData() const {
   return data_channel_ && data_channel_->ready_to_send_data();
 }
 
+rtc::scoped_refptr<DataChannel> WebRtcSession::CreateDataChannel(
+    const std::string& label,
+    const InternalDataChannelInit* config) {
+  if (state() == STATE_RECEIVEDTERMINATE) {
+    return NULL;
+  }
+  if (data_channel_type_ == cricket::DCT_NONE) {
+    LOG(LS_ERROR) << "CreateDataChannel: Data is not supported in this call.";
+    return NULL;
+  }
+  InternalDataChannelInit new_config =
+      config ? (*config) : InternalDataChannelInit();
+  if (data_channel_type_ == cricket::DCT_SCTP) {
+    if (new_config.id < 0) {
+      rtc::SSLRole role;
+      if (GetSslRole(&role) &&
+          !mediastream_signaling_->AllocateSctpSid(role, &new_config.id)) {
+        LOG(LS_ERROR) << "No id can be allocated for the SCTP data channel.";
+        return NULL;
+      }
+    } else if (!mediastream_signaling_->IsSctpSidAvailable(new_config.id)) {
+      LOG(LS_ERROR) << "Failed to create a SCTP data channel "
+                    << "because the id is already in use or out of range.";
+      return NULL;
+    }
+  }
+
+  rtc::scoped_refptr<DataChannel> channel(DataChannel::Create(
+      this, data_channel_type_, label, new_config));
+  if (channel && !mediastream_signaling_->AddDataChannel(channel))
+    return NULL;
+
+  return channel;
+}
+
 cricket::DataChannelType WebRtcSession::data_channel_type() const {
   return data_channel_type_;
 }
 
 bool WebRtcSession::IceRestartPending() const {
   return ice_restart_latch_->Get();
 }
 
 void WebRtcSession::ResetIceRestartLatch() {
   ice_restart_latch_->Reset();
@@ skipping 248 matching lines @@
   }
   return true;
 }
 
 void WebRtcSession::RemoveUnusedChannels(const SessionDescription* desc) {
   // Destroy video_channel_ first since it may have a pointer to the
   // voice_channel_.
   const cricket::ContentInfo* video_info =
       cricket::GetFirstVideoContent(desc);
   if ((!video_info || video_info->rejected) && video_channel_) {
+    mediastream_signaling_->OnVideoChannelClose();
     SignalVideoChannelDestroyed();
     const std::string content_name = video_channel_->content_name();
     channel_manager_->DestroyVideoChannel(video_channel_.release());
   }
 
   const cricket::ContentInfo* voice_info =
       cricket::GetFirstAudioContent(desc);
   if ((!voice_info || voice_info->rejected) && voice_channel_) {
+    mediastream_signaling_->OnAudioChannelClose();
     SignalVoiceChannelDestroyed();
     const std::string content_name = voice_channel_->content_name();
     channel_manager_->DestroyVoiceChannel(voice_channel_.release());
   }
 
   const cricket::ContentInfo* data_info =
       cricket::GetFirstDataContent(desc);
   if ((!data_info || data_info->rejected) && data_channel_) {
+    mediastream_signaling_->OnDataChannelClose();
     SignalDataChannelDestroyed();
     const std::string content_name = data_channel_->content_name();
     channel_manager_->DestroyDataChannel(data_channel_.release());
   }
 }
 
 // TODO(mallinath) - Add a correct error code if the channels are not created
 // due to BUNDLE is enabled but rtcp-mux is disabled.
 bool WebRtcSession::CreateChannels(const SessionDescription* desc) {
   // Creating the media channels and transport proxies.
@@ skipping 54 matching lines @@
 bool WebRtcSession::CreateVoiceChannel(const cricket::ContentInfo* content) {
   voice_channel_.reset(channel_manager_->CreateVoiceChannel(
       media_controller_.get(), transport_controller(), content->name, true,
       audio_options_));
   if (!voice_channel_) {
     return false;
   }
 
   voice_channel_->SignalDtlsSetupFailure.connect(
       this, &WebRtcSession::OnDtlsSetupFailure);
-
-  SignalVoiceChannelCreated();
   return true;
 }
 
 bool WebRtcSession::CreateVideoChannel(const cricket::ContentInfo* content) {
   video_channel_.reset(channel_manager_->CreateVideoChannel(
       media_controller_.get(), transport_controller(), content->name, true,
       video_options_));
   if (!video_channel_) {
     return false;
   }
 
   video_channel_->SignalDtlsSetupFailure.connect(
       this, &WebRtcSession::OnDtlsSetupFailure);
-
-  SignalVideoChannelCreated();
   return true;
 }
 
 bool WebRtcSession::CreateDataChannel(const cricket::ContentInfo* content) {
   bool sctp = (data_channel_type_ == cricket::DCT_SCTP);
   data_channel_.reset(channel_manager_->CreateDataChannel(
       transport_controller(), content->name, !sctp, data_channel_type_));
   if (!data_channel_) {
     return false;
   }
 
   if (sctp) {
+    mediastream_signaling_->OnDataTransportCreatedForSctp();
     data_channel_->SignalDataReceived.connect(
         this, &WebRtcSession::OnDataChannelMessageReceived);
+    data_channel_->SignalStreamClosedRemotely.connect(
+        mediastream_signaling_,
+        &MediaStreamSignaling::OnRemoteSctpDataChannelClosed);
   }
 
   data_channel_->SignalDtlsSetupFailure.connect(
       this, &WebRtcSession::OnDtlsSetupFailure);
-
-  SignalDataChannelCreated();
   return true;
 }
 
 void WebRtcSession::OnDtlsSetupFailure(cricket::BaseChannel*, bool rtcp) {
   SetError(BaseSession::ERROR_TRANSPORT, rtcp ? kDtlsSetupFailureRtcp :
            kDtlsSetupFailureRtp);
 }
 
 void WebRtcSession::CopySavedCandidates(
     SessionDescriptionInterface* dest_desc) {
   if (!dest_desc) {
     ASSERT(false);
     return;
   }
   for (size_t i = 0; i < saved_candidates_.size(); ++i) {
     dest_desc->AddCandidate(saved_candidates_[i]);
     delete saved_candidates_[i];
   }
   saved_candidates_.clear();
 }
 
 void WebRtcSession::OnDataChannelMessageReceived(
     cricket::DataChannel* channel,
     const cricket::ReceiveDataParams& params,
     const rtc::Buffer& payload) {
-  RTC_DCHECK(data_channel_type_ == cricket::DCT_SCTP);
-  if (params.type == cricket::DMT_CONTROL && IsOpenMessage(payload)) {
-    // Received OPEN message; parse and signal that a new data channel should
-    // be created.
-    std::string label;
-    InternalDataChannelInit config;
-    config.id = params.ssrc;
-    if (!ParseDataChannelOpenMessage(payload, &label, &config)) {
-      LOG(LS_WARNING) << "Failed to parse the OPEN message for sid "
-                      << params.ssrc;
-      return;
-    }
-    config.open_handshake_role = InternalDataChannelInit::kAcker;
-    SignalDataChannelOpenMessage(label, config);
+  ASSERT(data_channel_type_ == cricket::DCT_SCTP);
+  if (params.type == cricket::DMT_CONTROL &&
+      mediastream_signaling_->IsSctpSidAvailable(params.ssrc)) {
+    // Received CONTROL on unused sid, process as an OPEN message.
+    mediastream_signaling_->AddDataChannelFromOpenMessage(params, payload);
   }
-  // Otherwise ignore the message.
+  // otherwise ignore the message.
 }
 
 // Returns false if bundle is enabled and rtcp_mux is disabled.
 bool WebRtcSession::ValidateBundleSettings(const SessionDescription* desc) {
   bool bundle_enabled = desc->HasGroup(cricket::GROUP_TYPE_BUNDLE);
   if (!bundle_enabled)
     return true;
 
   const cricket::ContentGroup* bundle_group =
       desc->GetGroupByName(cricket::GROUP_TYPE_BUNDLE);
@@ skipping 272 matching lines @@
   if (!srtp_cipher.empty()) {
     metrics_observer_->IncrementSparseEnumCounter(
         srtp_counter_type, rtc::GetSrtpCryptoSuiteFromName(srtp_cipher));
   }
   if (ssl_cipher) {
     metrics_observer_->IncrementSparseEnumCounter(ssl_counter_type, ssl_cipher);
   }
 }
 
 }  // namespace webrtc