Reland of: Separating SCTP code from BaseChannel/MediaChannel.

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.
  */
 
@@ skipping 15 matching lines @@
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/bind.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"
 #include "webrtc/call/call.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/base/videocapturer.h"
+#include "webrtc/media/sctp/sctptransportinternal.h"
 #include "webrtc/p2p/base/portallocator.h"
 #include "webrtc/p2p/base/transportchannel.h"
 #include "webrtc/pc/channel.h"
 #include "webrtc/pc/channelmanager.h"
 #include "webrtc/pc/mediasession.h"
 
 #ifdef HAVE_QUIC
 #include "webrtc/p2p/quic/quictransportchannel.h"
 #endif  // HAVE_QUIC
 
@@ skipping 21 matching lines @@
 const char kPushDownTDFailed[] =
     "Failed to push down transport description:";
 const char kSdpWithoutDtlsFingerprint[] =
     "Called with SDP without DTLS fingerprint.";
 const char kSdpWithoutSdesCrypto[] =
     "Called with SDP without SDES crypto.";
 const char kSdpWithoutIceUfragPwd[] =
     "Called with SDP without ice-ufrag and ice-pwd.";
 const char kSessionError[] = "Session error code: ";
 const char kSessionErrorDesc[] = "Session error description: ";
-const char kDtlsSetupFailureRtp[] =
+const char kDtlsSrtpSetupFailureRtp[] =
     "Couldn't set up DTLS-SRTP on RTP channel.";
-const char kDtlsSetupFailureRtcp[] =
+const char kDtlsSrtpSetupFailureRtcp[] =
     "Couldn't set up DTLS-SRTP on RTCP channel.";
 const char kEnableBundleFailed[] = "Failed to enable BUNDLE.";
 
 IceCandidatePairType GetIceCandidatePairCounter(
     const cricket::Candidate& local,
     const cricket::Candidate& remote) {
   const auto& l = local.type();
   const auto& r = remote.type();
   const auto& host = LOCAL_PORT_TYPE;
   const auto& srflx = STUN_PORT_TYPE;
@@ skipping 194 matching lines @@
     const auto* found =
         cricket::GetStreamBySsrc(video_content->streams(), ssrc);
     if (found) {
       *track_id = found->id;
       return true;
     }
   }
   return false;
 }
 
+// Get the SCTP port out of a SessionDescription.
+// Return -1 if not found.
+static int GetSctpPort(const SessionDescription* session_description) {
+  const ContentInfo* content_info = GetFirstDataContent(session_description);
+  RTC_DCHECK(content_info);
+  if (!content_info) {
+    return -1;
+  }
+  const cricket::DataContentDescription* data =
+      static_cast<const cricket::DataContentDescription*>(
+          (content_info->description));
+  std::string value;
+  cricket::DataCodec match_pattern(cricket::kGoogleSctpDataCodecPlType,
+                                   cricket::kGoogleSctpDataCodecName);
+  for (const cricket::DataCodec& codec : data->codecs()) {
+    if (!codec.Matches(match_pattern)) {
+      continue;
+    }
+    if (codec.GetParam(cricket::kCodecParamPort, &value)) {
+      return rtc::FromString<int>(value);
+    }
+  }
+  return -1;
+}
+
 static bool BadSdp(const std::string& source,
                    const std::string& type,
                    const std::string& reason,
                    std::string* err_desc) {
   std::ostringstream desc;
   desc << "Failed to set " << source;
   if (!type.empty()) {
     desc << " " << type;
   }
   desc << " sdp: " << reason;
@@ skipping 129 matching lines @@
   }
   return false;
 }
 
 WebRtcSession::WebRtcSession(
     webrtc::MediaControllerInterface* media_controller,
     rtc::Thread* network_thread,
     rtc::Thread* worker_thread,
     rtc::Thread* signaling_thread,
     cricket::PortAllocator* port_allocator,
-    std::unique_ptr<cricket::TransportController> transport_controller)
+    std::unique_ptr<cricket::TransportController> transport_controller,
+    std::unique_ptr<cricket::SctpTransportInternalFactory> sctp_factory)
     : network_thread_(network_thread),
       worker_thread_(worker_thread),
       signaling_thread_(signaling_thread),
       // 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.
       sid_(rtc::ToString(rtc::CreateRandomId64() & LLONG_MAX)),
       transport_controller_(std::move(transport_controller)),
+      sctp_factory_(std::move(sctp_factory)),
       media_controller_(media_controller),
       channel_manager_(media_controller_->channel_manager()),
       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),
       metrics_observer_(NULL) {
   transport_controller_->SetIceRole(cricket::ICEROLE_CONTROLLED);
   transport_controller_->SignalConnectionState.connect(
       this, &WebRtcSession::OnTransportControllerConnectionState);
   transport_controller_->SignalReceiving.connect(
       this, &WebRtcSession::OnTransportControllerReceiving);
   transport_controller_->SignalGatheringState.connect(
       this, &WebRtcSession::OnTransportControllerGatheringState);
   transport_controller_->SignalCandidatesGathered.connect(
       this, &WebRtcSession::OnTransportControllerCandidatesGathered);
   transport_controller_->SignalCandidatesRemoved.connect(
       this, &WebRtcSession::OnTransportControllerCandidatesRemoved);
   transport_controller_->SignalDtlsHandshakeError.connect(
-      this, &WebRtcSession::OnDtlsHandshakeError);
+      this, &WebRtcSession::OnTransportControllerDtlsHandshakeError);
 }
 
 WebRtcSession::~WebRtcSession() {
   ASSERT(signaling_thread()->IsCurrent());
   // Destroy video_channel_ first since it may have a pointer to the
   // voice_channel_.
   if (video_channel_) {
     SignalVideoChannelDestroyed();
     channel_manager_->DestroyVideoChannel(video_channel_.release());
   }
   if (voice_channel_) {
     SignalVoiceChannelDestroyed();
     channel_manager_->DestroyVoiceChannel(voice_channel_.release());
   }
-  if (data_channel_) {
+  if (rtp_data_channel_) {
     SignalDataChannelDestroyed();
-    channel_manager_->DestroyDataChannel(data_channel_.release());
+    channel_manager_->DestroyRtpDataChannel(rtp_data_channel_.release());
+  }
+  if (sctp_transport_) {
+    SignalDataChannelDestroyed();

[pthatcher1, 2016/12/23 01:39:31]

Should this be SignalSctpTransportDestroyed()?

[Taylor Brandstetter, 2016/12/23 06:29:05]

It could also be an RtpDataChannel though.

+    network_thread_->Invoke<void>(
+        RTC_FROM_HERE, rtc::Bind(&WebRtcSession::DestroySctpTransport_n, this));
   }
 #ifdef HAVE_QUIC
   if (quic_data_transport_) {
     quic_data_transport_.reset();
   }
 #endif
   SignalDestroyed();
 
   LOG(LS_INFO) << "Session: " << id() << " is destroyed.";
 }
@@ skipping 89 matching lines @@
   if (options.disable_encryption) {
     webrtc_session_desc_factory_->SetSdesPolicy(cricket::SEC_DISABLED);
   }
 
   return true;
 }
 
 void WebRtcSession::Close() {
   SetState(STATE_CLOSED);
   RemoveUnusedChannels(nullptr);
-  ASSERT(!voice_channel_);
-  ASSERT(!video_channel_);
-  ASSERT(!data_channel_);
+  RTC_DCHECK(!voice_channel_);
+  RTC_DCHECK(!video_channel_);
+  RTC_DCHECK(!rtp_data_channel_);
+  RTC_DCHECK(!sctp_transport_);
   media_controller_->Close();
 }
 
 cricket::BaseChannel* WebRtcSession::GetChannel(
     const std::string& content_name) {
   if (voice_channel() && voice_channel()->content_name() == content_name) {
     return voice_channel();
   }
   if (video_channel() && video_channel()->content_name() == content_name) {
     return video_channel();
   }
-  if (data_channel() && data_channel()->content_name() == content_name) {
-    return data_channel();
+  if (rtp_data_channel() &&
+      rtp_data_channel()->content_name() == content_name) {
+    return rtp_data_channel();
   }
   return nullptr;
 }
 
 cricket::SecurePolicy WebRtcSession::SdesPolicy() const {
   return webrtc_session_desc_factory_->SdesPolicy();
 }
 
-bool WebRtcSession::GetSslRole(const std::string& transport_name,
+bool WebRtcSession::GetSctpSslRole(rtc::SSLRole* role) {
+  if (!local_description() || !remote_description()) {
+    LOG(LS_INFO) << "Local and Remote descriptions must be applied to get the "
+                 << "SSL Role of the SCTP transport.";
+    return false;
+  }
+  if (!sctp_transport_) {
+    LOG(LS_INFO) << "Non-rejected SCTP m= section is needed to get the "
+                 << "SSL Role of the SCTP transport.";
+    return false;
+  }
+
+  return transport_controller_->GetSslRole(sctp_transport_name_, role);
+}
+
+bool WebRtcSession::GetSslRole(const std::string& content_name,
                                rtc::SSLRole* role) {
   if (!local_description() || !remote_description()) {
-    LOG(LS_INFO) << "Local and Remote descriptions must be applied to get "
+    LOG(LS_INFO) << "Local and Remote descriptions must be applied to get the "
                  << "SSL Role of the session.";
     return false;
   }
 
-  return transport_controller_->GetSslRole(transport_name, role);
-}
-
-bool WebRtcSession::GetSslRole(const cricket::BaseChannel* channel,
-                               rtc::SSLRole* role) {
-  return channel && GetSslRole(channel->transport_name(), role);
+  return transport_controller_->GetSslRole(GetTransportName(content_name),
+                                           role);
 }
 
 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(
@@ skipping 263 matching lines @@
       return true;
     } else if (source == cricket::CS_LOCAL) {
       return ch->PushdownLocalDescription(local_description()->description(),
                                           action, err);
     } else {
       return ch->PushdownRemoteDescription(remote_description()->description(),
                                            action, err);
     }
   };
 
-  return (set_content(voice_channel()) &&
-          set_content(video_channel()) &&
-          set_content(data_channel()));
+  bool ret = (set_content(voice_channel()) && set_content(video_channel()) &&
+              set_content(rtp_data_channel()));
+  // Need complete offer/answer before starting SCTP, according to
+  // https://tools.ietf.org/html/draft-ietf-mmusic-sctp-sdp-19
+  if (sctp_transport_ && local_description() && remote_description()) {
+    ret &= network_thread_->Invoke<bool>(
+        RTC_FROM_HERE,
+        rtc::Bind(&WebRtcSession::PushdownSctpParameters_n, this, source));
+  }
+  return ret;
+}
+
+bool WebRtcSession::PushdownSctpParameters_n(cricket::ContentSource source) {
+  RTC_DCHECK(network_thread_->IsCurrent());
+  RTC_DCHECK(local_description());
+  RTC_DCHECK(remote_description());
+  // Apply the SCTP port (which is hidden inside a DataCodec structure...)
+  // When we support "max-message-size", that would also be pushed down here.
+  return sctp_transport_->Start(
+      GetSctpPort(local_description()->description()),
+      GetSctpPort(remote_description()->description()));
 }
 
 bool WebRtcSession::PushdownTransportDescription(cricket::ContentSource source,
                                                  cricket::ContentAction action,
                                                  std::string* error_desc) {
   RTC_DCHECK(signaling_thread()->IsCurrent());
 
   if (source == cricket::CS_LOCAL) {
     return PushdownLocalTransportDescription(local_description()->description(),
                                              action, error_desc);
@@ skipping 51 matching lines @@
   }
   const TransportInfo* transport_info =
       description->GetTransportInfoByName(content_name);
   if (!transport_info) {
     return false;
   }
   *tdesc = transport_info->description;
   return true;
 }
 
-std::unique_ptr<SessionStats> WebRtcSession::GetStats_s() {
-  ASSERT(signaling_thread()->IsCurrent());
-  ChannelNamePairs channel_name_pairs;
-  if (voice_channel()) {
-    channel_name_pairs.voice = rtc::Optional<ChannelNamePair>(ChannelNamePair(
-        voice_channel()->content_name(), voice_channel()->transport_name()));
-  }
-  if (video_channel()) {
-    channel_name_pairs.video = rtc::Optional<ChannelNamePair>(ChannelNamePair(
-        video_channel()->content_name(), video_channel()->transport_name()));
-  }
-  if (data_channel()) {
-    channel_name_pairs.data = rtc::Optional<ChannelNamePair>(ChannelNamePair(
-        data_channel()->content_name(), data_channel()->transport_name()));
-  }
-  return GetStats(channel_name_pairs);
-}
-
-std::unique_ptr<SessionStats> WebRtcSession::GetStats(
-    const ChannelNamePairs& channel_name_pairs) {
-  if (network_thread()->IsCurrent()) {
-    return GetStats_n(channel_name_pairs);
-  }
-  return network_thread()->Invoke<std::unique_ptr<SessionStats>>(
-      RTC_FROM_HERE,
-      rtc::Bind(&WebRtcSession::GetStats_n, this, channel_name_pairs));
-}
-
-bool WebRtcSession::GetLocalCertificate(
-    const std::string& transport_name,
-    rtc::scoped_refptr<rtc::RTCCertificate>* certificate) {
-  return transport_controller_->GetLocalCertificate(transport_name,
-                                                    certificate);
-}
-
-std::unique_ptr<rtc::SSLCertificate> WebRtcSession::GetRemoteSSLCertificate(
-    const std::string& transport_name) {
-  return transport_controller_->GetRemoteSSLCertificate(transport_name);
-}
-
 bool WebRtcSession::EnableBundle(const cricket::ContentGroup& bundle) {
   const std::string* first_content_name = bundle.FirstContentName();
   if (!first_content_name) {
     LOG(LS_WARNING) << "Tried to BUNDLE with no contents.";
     return false;
   }
   const std::string& transport_name = *first_content_name;
-  cricket::BaseChannel* first_channel = GetChannel(transport_name);
 
 #ifdef HAVE_QUIC
   if (quic_data_transport_ &&
       bundle.HasContentName(quic_data_transport_->content_name()) &&
       quic_data_transport_->transport_name() != transport_name) {
     LOG(LS_ERROR) << "Unable to BUNDLE " << quic_data_transport_->content_name()
                   << " on " << transport_name << "with QUIC.";
   }
 #endif
 
-  auto maybe_set_transport = [this, bundle, transport_name,
-                              first_channel](cricket::BaseChannel* ch) {
+  auto maybe_set_transport = [this, bundle,
+                              transport_name](cricket::BaseChannel* ch) {
     if (!ch || !bundle.HasContentName(ch->content_name())) {
       return true;
     }
 
     if (ch->transport_name() == transport_name) {
       LOG(LS_INFO) << "BUNDLE already enabled for " << ch->content_name()
                    << " on " << transport_name << ".";
       return true;
     }
 
     if (!ch->SetTransport(transport_name)) {
       LOG(LS_WARNING) << "Failed to enable BUNDLE for " << ch->content_name();
       return false;
     }
     LOG(LS_INFO) << "Enabled BUNDLE for " << ch->content_name() << " on "
                  << transport_name << ".";
     return true;
   };
 
   if (!maybe_set_transport(voice_channel()) ||
       !maybe_set_transport(video_channel()) ||
-      !maybe_set_transport(data_channel())) {
+      !maybe_set_transport(rtp_data_channel())) {
     return false;
   }
+  // For SCTP, transport creation/deletion happens here instead of in the
+  // object itself.
+  if (sctp_transport_ && transport_name != sctp_transport_name_ &&
+      bundle.HasContentName(sctp_content_name_)) {
+    network_thread_->Invoke<void>(
+        RTC_FROM_HERE,
+        rtc::Bind(&WebRtcSession::ChangeSctpTransport_n, this, transport_name));
+  }
 
   return true;
 }
 
 bool WebRtcSession::ProcessIceMessage(const IceCandidateInterface* candidate) {
   if (!remote_description()) {
     LOG(LS_ERROR) << "ProcessIceMessage: ICE candidates can't be added "
                   << "without any remote session description.";
     return false;
   }
@@ skipping 152 matching lines @@
   return true;
 }
 
 sigslot::signal0<>* WebRtcSession::GetOnDestroyedSignal() {
   return &SignalDestroyed;
 }
 
 bool WebRtcSession::SendData(const cricket::SendDataParams& params,
                              const rtc::CopyOnWriteBuffer& payload,
                              cricket::SendDataResult* result) {
-  if (!data_channel_) {
-    LOG(LS_ERROR) << "SendData called when data_channel_ is NULL.";
+  if (!rtp_data_channel_ && !sctp_transport_) {
+    LOG(LS_ERROR) << "SendData called when rtp_data_channel_ "
+                  << "and sctp_transport_ are NULL.";
     return false;
   }
-  return data_channel_->SendData(params, payload, result);
+  return rtp_data_channel_
+             ? rtp_data_channel_->SendData(params, payload, result)
+             : network_thread_->Invoke<bool>(
+                   RTC_FROM_HERE,
+                   Bind(&cricket::SctpTransportInternal::SendData,
+                        sctp_transport_.get(), params, payload, result));

[pthatcher1, 2016/12/23 01:39:31]

Similar to passing a "fire events on this thread" being passed to SctpTransport,
if the SctpTransport automatically hops to the network thread when it's called
from a thread other than the network thread, then would be a nice safety that
would work for both ORTC and WebRtcSession.

 }
 
 bool WebRtcSession::ConnectDataChannel(DataChannel* webrtc_data_channel) {
-  if (!data_channel_) {
+  if (!rtp_data_channel_ && !sctp_transport_) {
     // Don't log an error here, because DataChannels are expected to call
     // ConnectDataChannel in this state. It's the only way to initially tell
     // whether or not the underlying transport is ready.
     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);
+  if (rtp_data_channel_) {
+    rtp_data_channel_->SignalReadyToSendData.connect(
+        webrtc_data_channel, &DataChannel::OnChannelReady);
+    rtp_data_channel_->SignalDataReceived.connect(webrtc_data_channel,
+                                                  &DataChannel::OnDataReceived);
+  } else {
+    SignalSctpReadyToSendData.connect(webrtc_data_channel,
+                                      &DataChannel::OnChannelReady);
+    SignalSctpDataReceived.connect(webrtc_data_channel,
+                                   &DataChannel::OnDataReceived);
+    SignalSctpStreamClosedRemotely.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.";
+  if (!rtp_data_channel_ && !sctp_transport_) {
+    LOG(LS_ERROR) << "DisconnectDataChannel called when rtp_data_channel_ and "
+                     "sctp_transport_ are NULL.";
     return;
   }
-  data_channel_->SignalReadyToSendData.disconnect(webrtc_data_channel);
-  data_channel_->SignalDataReceived.disconnect(webrtc_data_channel);
-  data_channel_->SignalStreamClosedRemotely.disconnect(webrtc_data_channel);
+  if (rtp_data_channel_) {
+    rtp_data_channel_->SignalReadyToSendData.disconnect(webrtc_data_channel);
+    rtp_data_channel_->SignalDataReceived.disconnect(webrtc_data_channel);
+  } else {
+    SignalSctpReadyToSendData.disconnect(webrtc_data_channel);
+    SignalSctpDataReceived.disconnect(webrtc_data_channel);
+    SignalSctpStreamClosedRemotely.disconnect(webrtc_data_channel);
+  }
 }
 
 void WebRtcSession::AddSctpDataStream(int sid) {
-  if (!data_channel_) {
-    LOG(LS_ERROR) << "AddDataChannelStreams called when data_channel_ is NULL.";
+  if (!sctp_transport_) {
+    LOG(LS_ERROR) << "AddSctpDataStream called when sctp_transport_ is NULL.";
     return;
   }
-  data_channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(sid));
-  data_channel_->AddSendStream(cricket::StreamParams::CreateLegacy(sid));
+  network_thread_->Invoke<void>(
+      RTC_FROM_HERE, rtc::Bind(&cricket::SctpTransportInternal::OpenStream,
+                               sctp_transport_.get(), sid));
 }
 
 void WebRtcSession::RemoveSctpDataStream(int sid) {
-  if (!data_channel_) {
-    LOG(LS_ERROR) << "RemoveDataChannelStreams called when data_channel_ is "
+  if (!sctp_transport_) {
+    LOG(LS_ERROR) << "RemoveSctpDataStream called when sctp_transport_ is "
                   << "NULL.";
     return;
   }
-  data_channel_->RemoveRecvStream(sid);
-  data_channel_->RemoveSendStream(sid);
+  network_thread_->Invoke<void>(
+      RTC_FROM_HERE, rtc::Bind(&cricket::SctpTransportInternal::ResetStream,
+                               sctp_transport_.get(), sid));
 }
 
 bool WebRtcSession::ReadyToSendData() const {
-  return data_channel_ && data_channel_->ready_to_send_data();
+  return (rtp_data_channel_ && rtp_data_channel_->ready_to_send_data()) ||
+         sctp_ready_to_send_data_;
+}
+
+std::unique_ptr<SessionStats> WebRtcSession::GetStats_s() {
+  ASSERT(signaling_thread()->IsCurrent());
+  ChannelNamePairs channel_name_pairs;
+  if (voice_channel()) {
+    channel_name_pairs.voice = rtc::Optional<ChannelNamePair>(ChannelNamePair(
+        voice_channel()->content_name(), voice_channel()->transport_name()));
+  }
+  if (video_channel()) {
+    channel_name_pairs.video = rtc::Optional<ChannelNamePair>(ChannelNamePair(
+        video_channel()->content_name(), video_channel()->transport_name()));
+  }
+  if (rtp_data_channel()) {
+    channel_name_pairs.data = rtc::Optional<ChannelNamePair>(
+        ChannelNamePair(rtp_data_channel()->content_name(),
+                        rtp_data_channel()->transport_name()));
+  }
+  if (sctp_transport_) {
+    channel_name_pairs.data = rtc::Optional<ChannelNamePair>(
+        ChannelNamePair(sctp_content_name_, sctp_transport_name_));
+  }
+  return GetStats(channel_name_pairs);
+}
+
+std::unique_ptr<SessionStats> WebRtcSession::GetStats(
+    const ChannelNamePairs& channel_name_pairs) {
+  if (network_thread()->IsCurrent()) {
+    return GetStats_n(channel_name_pairs);
+  }
+  return network_thread()->Invoke<std::unique_ptr<SessionStats>>(
+      RTC_FROM_HERE,
+      rtc::Bind(&WebRtcSession::GetStats_n, this, channel_name_pairs));
+}
+
+bool WebRtcSession::GetLocalCertificate(
+    const std::string& transport_name,
+    rtc::scoped_refptr<rtc::RTCCertificate>* certificate) {
+  return transport_controller_->GetLocalCertificate(transport_name,
+                                                    certificate);
+}
+
+std::unique_ptr<rtc::SSLCertificate> WebRtcSession::GetRemoteSSLCertificate(
+    const std::string& transport_name) {
+  return transport_controller_->GetRemoteSSLCertificate(transport_name);
 }
 
 cricket::DataChannelType WebRtcSession::data_channel_type() const {
   return data_channel_type_;
 }
 
 bool WebRtcSession::IceRestartPending(const std::string& content_name) const {
   return pending_ice_restarts_.find(content_name) !=
          pending_ice_restarts_.end();
 }
 
 void WebRtcSession::SetNeedsIceRestartFlag() {
   transport_controller_->SetNeedsIceRestartFlag();
 }
 
 bool WebRtcSession::NeedsIceRestart(const std::string& content_name) const {
   return transport_controller_->NeedsIceRestart(content_name);
 }
 
 void WebRtcSession::OnCertificateReady(
     const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) {
   transport_controller_->SetLocalCertificate(certificate);
 }
 
+void WebRtcSession::OnDtlsSrtpSetupFailure(cricket::BaseChannel*, bool rtcp) {
+  SetError(ERROR_TRANSPORT,
+           rtcp ? kDtlsSrtpSetupFailureRtcp : kDtlsSrtpSetupFailureRtp);
+}
+
 bool WebRtcSession::waiting_for_certificate_for_testing() const {
   return webrtc_session_desc_factory_->waiting_for_certificate_for_testing();
 }
 
 const rtc::scoped_refptr<rtc::RTCCertificate>&
 WebRtcSession::certificate_for_testing() {
   return transport_controller_->certificate_for_testing();
 }
 
 void WebRtcSession::SetIceConnectionState(
@@ skipping 109 matching lines @@
   }
 
   if (local_description()) {
     mutable_local_description()->RemoveCandidates(candidates);
   }
   if (ice_observer_) {
     ice_observer_->OnIceCandidatesRemoved(candidates);
   }
 }
 
-// Enabling voice and video channel.
+void WebRtcSession::OnTransportControllerDtlsHandshakeError(
+    rtc::SSLHandshakeError error) {
+  if (metrics_observer_) {
+    metrics_observer_->IncrementEnumCounter(
+        webrtc::kEnumCounterDtlsHandshakeError, static_cast<int>(error),
+        static_cast<int>(rtc::SSLHandshakeError::MAX_VALUE));
+  }
+}
+
+// Enabling voice and video (and RTP data) channel.
 void WebRtcSession::EnableChannels() {
   if (voice_channel_ && !voice_channel_->enabled())
     voice_channel_->Enable(true);
 
   if (video_channel_ && !video_channel_->enabled())
     video_channel_->Enable(true);
 
-  if (data_channel_ && !data_channel_->enabled())
-    data_channel_->Enable(true);
+  if (rtp_data_channel_ && !rtp_data_channel_->enabled())
+    rtp_data_channel_->Enable(true);
 }
 
 // Returns the media index for a local ice candidate given the content name.
 bool WebRtcSession::GetLocalCandidateMediaIndex(const std::string& content_name,
                                                 int* sdp_mline_index) {
   if (!local_description() || !sdp_mline_index) {
     return false;
   }
 
   bool content_found = false;
@@ skipping 89 matching lines @@
   const cricket::ContentInfo* voice_info =
       cricket::GetFirstAudioContent(desc);
   if ((!voice_info || voice_info->rejected) && voice_channel_) {
     SignalVoiceChannelDestroyed();
     channel_manager_->DestroyVoiceChannel(voice_channel_.release());
   }
 
   const cricket::ContentInfo* data_info =
       cricket::GetFirstDataContent(desc);
   if (!data_info || data_info->rejected) {
-    if (data_channel_) {
+    if (rtp_data_channel_) {
       SignalDataChannelDestroyed();
-      channel_manager_->DestroyDataChannel(data_channel_.release());
+      channel_manager_->DestroyRtpDataChannel(rtp_data_channel_.release());
+    }
+    if (sctp_transport_) {
+      SignalDataChannelDestroyed();
+      network_thread_->Invoke<void>(
+          RTC_FROM_HERE,
+          rtc::Bind(&WebRtcSession::DestroySctpTransport_n, this));
     }
 #ifdef HAVE_QUIC
     // Clean up the existing QuicDataTransport and its QuicTransportChannels.
     if (quic_data_transport_) {
       quic_data_transport_.reset();
     }
 #endif
   }
 }
 
@@ skipping 40 matching lines @@
   const cricket::ContentInfo* video = cricket::GetFirstVideoContent(desc);
   if (video && !video->rejected && !video_channel_) {
     if (!CreateVideoChannel(video,
                             GetBundleTransportName(video, bundle_group))) {
       LOG(LS_ERROR) << "Failed to create video channel.";
       return false;
     }
   }
 
   const cricket::ContentInfo* data = cricket::GetFirstDataContent(desc);
-  if (data_channel_type_ != cricket::DCT_NONE &&
-      data && !data->rejected && !data_channel_) {
+  if (data_channel_type_ != cricket::DCT_NONE && data && !data->rejected &&
+      !rtp_data_channel_ && !sctp_transport_) {
     if (!CreateDataChannel(data, GetBundleTransportName(data, bundle_group))) {
       LOG(LS_ERROR) << "Failed to create data channel.";
       return false;
     }
   }
 
   return true;
 }
 
 bool WebRtcSession::CreateVoiceChannel(const cricket::ContentInfo* content,
                                        const std::string* bundle_transport) {
   bool require_rtcp_mux =
       rtcp_mux_policy_ == PeerConnectionInterface::kRtcpMuxPolicyRequire;
   bool create_rtcp_transport_channel = !require_rtcp_mux;
   voice_channel_.reset(channel_manager_->CreateVoiceChannel(
       media_controller_, transport_controller_.get(), content->name,
       bundle_transport, create_rtcp_transport_channel, SrtpRequired(),
       audio_options_));
   if (!voice_channel_) {
     return false;
   }
   if (require_rtcp_mux) {
     voice_channel_->ActivateRtcpMux();
   }
 
-  voice_channel_->SignalDtlsSetupFailure.connect(
-      this, &WebRtcSession::OnDtlsSetupFailure);
+  voice_channel_->SignalDtlsSrtpSetupFailure.connect(
+      this, &WebRtcSession::OnDtlsSrtpSetupFailure);
 
   SignalVoiceChannelCreated();
   voice_channel_->SignalSentPacket.connect(this,
                                            &WebRtcSession::OnSentPacket_w);
   return true;
 }
 
 bool WebRtcSession::CreateVideoChannel(const cricket::ContentInfo* content,
                                        const std::string* bundle_transport) {
   bool require_rtcp_mux =
       rtcp_mux_policy_ == PeerConnectionInterface::kRtcpMuxPolicyRequire;
   bool create_rtcp_transport_channel = !require_rtcp_mux;
   video_channel_.reset(channel_manager_->CreateVideoChannel(
       media_controller_, transport_controller_.get(), content->name,
       bundle_transport, create_rtcp_transport_channel, SrtpRequired(),
       video_options_));
   if (!video_channel_) {
     return false;
   }
   if (require_rtcp_mux) {
     video_channel_->ActivateRtcpMux();
   }
-  video_channel_->SignalDtlsSetupFailure.connect(
-      this, &WebRtcSession::OnDtlsSetupFailure);
+  video_channel_->SignalDtlsSrtpSetupFailure.connect(
+      this, &WebRtcSession::OnDtlsSrtpSetupFailure);
 
   SignalVideoChannelCreated();
   video_channel_->SignalSentPacket.connect(this,
                                            &WebRtcSession::OnSentPacket_w);
   return true;
 }
 
 bool WebRtcSession::CreateDataChannel(const cricket::ContentInfo* content,
                                       const std::string* bundle_transport) {
+  const std::string transport_name =
+      bundle_transport ? *bundle_transport : content->name;
 #ifdef HAVE_QUIC
   if (data_channel_type_ == cricket::DCT_QUIC) {
     RTC_DCHECK(transport_controller_->quic());
-    const std::string transport_name =
-        bundle_transport ? *bundle_transport : content->name;
     quic_data_transport_->SetTransport(transport_name);
     return true;
   }
 #endif  // HAVE_QUIC
   bool sctp = (data_channel_type_ == cricket::DCT_SCTP);
-  bool require_rtcp_mux =
-      rtcp_mux_policy_ == PeerConnectionInterface::kRtcpMuxPolicyRequire;
-  bool create_rtcp_transport_channel = !sctp && !require_rtcp_mux;
-  data_channel_.reset(channel_manager_->CreateDataChannel(
-      media_controller_, transport_controller_.get(), content->name,
-      bundle_transport, create_rtcp_transport_channel, SrtpRequired(),
-      data_channel_type_));
-  if (!data_channel_) {
-    return false;
-  }
-  if (require_rtcp_mux) {
-    data_channel_->ActivateRtcpMux();
+  if (sctp) {
+    if (!sctp_factory_) {
+      LOG(LS_ERROR)
+          << "Trying to create SCTP transport, but didn't compile with "
+             "SCTP support (HAVE_SCTP)";
+      return false;
+    }
+    if (!network_thread_->Invoke<bool>(
+            RTC_FROM_HERE, rtc::Bind(&WebRtcSession::CreateSctpTransport_n,
+                                     this, content->name, transport_name))) {
+      return false;
+    };
+  } else {
+    bool require_rtcp_mux =
+        rtcp_mux_policy_ == PeerConnectionInterface::kRtcpMuxPolicyRequire;
+    bool create_rtcp_transport_channel = !sctp && !require_rtcp_mux;
+    rtp_data_channel_.reset(channel_manager_->CreateRtpDataChannel(
+        media_controller_, transport_controller_.get(), content->name,
+        bundle_transport, create_rtcp_transport_channel, SrtpRequired()));
+    if (!rtp_data_channel_) {
+      return false;
+    }
+    if (require_rtcp_mux) {
+      rtp_data_channel_->ActivateRtcpMux();
+    }
+    rtp_data_channel_->SignalDtlsSrtpSetupFailure.connect(
+        this, &WebRtcSession::OnDtlsSrtpSetupFailure);
+    rtp_data_channel_->SignalSentPacket.connect(this,
+                                                &WebRtcSession::OnSentPacket_w);
   }
 
-  if (sctp) {
-    data_channel_->SignalDataReceived.connect(
-        this, &WebRtcSession::OnDataChannelMessageReceived);
-  }
-
-  data_channel_->SignalDtlsSetupFailure.connect(
-      this, &WebRtcSession::OnDtlsSetupFailure);
-
   SignalDataChannelCreated();
-  data_channel_->SignalSentPacket.connect(this, &WebRtcSession::OnSentPacket_w);
   return true;
 }
 
 std::unique_ptr<SessionStats> WebRtcSession::GetStats_n(
     const ChannelNamePairs& channel_name_pairs) {
   ASSERT(network_thread()->IsCurrent());
   std::unique_ptr<SessionStats> session_stats(new SessionStats());
   for (const auto channel_name_pair : { &channel_name_pairs.voice,
                                         &channel_name_pairs.video,
                                         &channel_name_pairs.data }) {
     if (*channel_name_pair) {
       cricket::TransportStats transport_stats;
       if (!transport_controller_->GetStats((*channel_name_pair)->transport_name,
                                            &transport_stats)) {
         return nullptr;
       }
       session_stats->proxy_to_transport[(*channel_name_pair)->content_name] =
           (*channel_name_pair)->transport_name;
       session_stats->transport_stats[(*channel_name_pair)->transport_name] =
           std::move(transport_stats);
     }
   }
   return session_stats;
 }
 
-void WebRtcSession::OnDtlsSetupFailure(cricket::BaseChannel*, bool rtcp) {
-  SetError(ERROR_TRANSPORT,
-           rtcp ? kDtlsSetupFailureRtcp : kDtlsSetupFailureRtp);
+bool WebRtcSession::CreateSctpTransport_n(const std::string& content_name,
+                                          const std::string& transport_name) {
+  RTC_DCHECK(network_thread_->IsCurrent());
+  RTC_DCHECK(sctp_factory_);
+  cricket::TransportChannel* tc =
+      transport_controller_->CreateTransportChannel_n(
+          transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
+  sctp_transport_ = sctp_factory_->CreateSctpTransport(tc);
+  RTC_DCHECK(sctp_transport_);
+  sctp_invoker_.reset(new rtc::AsyncInvoker());
+  sctp_transport_->SignalReadyToSendData.connect(
+      this, &WebRtcSession::OnSctpTransportReadyToSendData_n);
+  sctp_transport_->SignalDataReceived.connect(
+      this, &WebRtcSession::OnSctpTransportDataReceived_n);
+  sctp_transport_->SignalStreamClosedRemotely.connect(
+      this, &WebRtcSession::OnSctpStreamClosedRemotely_n);
+  sctp_transport_name_ = transport_name;
+  sctp_content_name_ = content_name;
+  return true;
 }
 
-void WebRtcSession::OnDataChannelMessageReceived(
-    cricket::DataChannel* channel,
+void WebRtcSession::ChangeSctpTransport_n(const std::string& transport_name) {
+  RTC_DCHECK(network_thread_->IsCurrent());
+  RTC_DCHECK(sctp_transport_);
+  std::string old_sctp_transport_name = sctp_transport_name_;
+  sctp_transport_name_ = transport_name;
+  cricket::TransportChannel* tc =
+      transport_controller_->CreateTransportChannel_n(
+          sctp_transport_name_, cricket::ICE_CANDIDATE_COMPONENT_RTP);
+  sctp_transport_->SetTransportChannel(tc);
+  transport_controller_->DestroyTransportChannel_n(
+      old_sctp_transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
+}
+
+void WebRtcSession::DestroySctpTransport_n() {
+  RTC_DCHECK(network_thread_->IsCurrent());
+  sctp_transport_.reset(nullptr);
+  sctp_invoker_.reset(nullptr);
+  sctp_ready_to_send_data_ = false;
+}
+
+void WebRtcSession::OnSctpTransportReadyToSendData_n() {
+  RTC_DCHECK(data_channel_type_ == cricket::DCT_SCTP);
+  RTC_DCHECK(network_thread_->IsCurrent());
+  sctp_invoker_->AsyncInvoke<void>(
+      RTC_FROM_HERE, signaling_thread_,
+      rtc::Bind(&WebRtcSession::OnSctpTransportReadyToSendData_s, this, true));
+}
+
+void WebRtcSession::OnSctpTransportReadyToSendData_s(bool ready) {
+  RTC_DCHECK(signaling_thread_->IsCurrent());
+  sctp_ready_to_send_data_ = ready;
+  SignalSctpReadyToSendData(ready);
+}
+
+void WebRtcSession::OnSctpTransportDataReceived_n(
     const cricket::ReceiveDataParams& params,
     const rtc::CopyOnWriteBuffer& payload) {
   RTC_DCHECK(data_channel_type_ == cricket::DCT_SCTP);
+  RTC_DCHECK(network_thread_->IsCurrent());
+  sctp_invoker_->AsyncInvoke<void>(
+      RTC_FROM_HERE, signaling_thread_,
+      rtc::Bind(&WebRtcSession::OnSctpTransportDataReceived_s, this, params,
+                payload));
+}
+
+void WebRtcSession::OnSctpTransportDataReceived_s(
+    const cricket::ReceiveDataParams& params,
+    const rtc::CopyOnWriteBuffer& payload) {
+  RTC_DCHECK(signaling_thread_->IsCurrent());
   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);
+  } else {
+    // Otherwise just forward the signal.
+    SignalSctpDataReceived(params, payload);
   }
-  // Otherwise ignore the message.
+}
+
+void WebRtcSession::OnSctpStreamClosedRemotely_n(int sid) {
+  RTC_DCHECK(data_channel_type_ == cricket::DCT_SCTP);
+  RTC_DCHECK(network_thread_->IsCurrent());
+  sctp_invoker_->AsyncInvoke<void>(
+      RTC_FROM_HERE, signaling_thread_,
+      rtc::Bind(&sigslot::signal1<int>::operator(),
+                &SignalSctpStreamClosedRemotely, sid));
 }
 
 // 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 173 matching lines @@
 void WebRtcSession::ReportTransportStats() {
   // Use a set so we don't report the same stats twice if two channels share
   // a transport.
   std::set<std::string> transport_names;
   if (voice_channel()) {
     transport_names.insert(voice_channel()->transport_name());
   }
   if (video_channel()) {
     transport_names.insert(video_channel()->transport_name());
   }
-  if (data_channel()) {
-    transport_names.insert(data_channel()->transport_name());
+  if (rtp_data_channel()) {
+    transport_names.insert(rtp_data_channel()->transport_name());
+  }
+  if (sctp_transport_) {
+    transport_names.insert(sctp_transport_name_);
   }
   for (const auto& name : transport_names) {
     cricket::TransportStats stats;
     if (transport_controller_->GetStats(name, &stats)) {
       ReportBestConnectionState(stats);
       ReportNegotiatedCiphers(stats);
     }
   }
 }
 // Walk through the ConnectionInfos to gather best connection usage
@@ skipping 96 matching lines @@
 const std::string WebRtcSession::GetTransportName(
     const std::string& content_name) {
   cricket::BaseChannel* channel = GetChannel(content_name);
   if (!channel) {
 #ifdef HAVE_QUIC
     if (data_channel_type_ == cricket::DCT_QUIC && quic_data_transport_ &&
         content_name == quic_data_transport_->transport_name()) {
       return quic_data_transport_->transport_name();
     }
 #endif
+    if (sctp_transport_ && content_name == sctp_content_name_) {
+      return sctp_transport_name_;
+    }
     // Return an empty string if failed to retrieve the transport name.
     return "";
   }
   return channel->transport_name();
 }
 
-void WebRtcSession::OnDtlsHandshakeError(rtc::SSLHandshakeError error) {
-  if (metrics_observer_) {
-    metrics_observer_->IncrementEnumCounter(
-        webrtc::kEnumCounterDtlsHandshakeError, static_cast<int>(error),
-        static_cast<int>(rtc::SSLHandshakeError::MAX_VALUE));
-  }
-}
 }  // namespace webrtc