Reland of: Separating SCTP code from BaseChannel/MediaChannel.

webrtc/api/webrtcsession.h

 /*
  *  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.
  */
 
 #ifndef WEBRTC_API_WEBRTCSESSION_H_
 #define WEBRTC_API_WEBRTCSESSION_H_
 
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "webrtc/api/datachannel.h"
 #include "webrtc/api/dtmfsender.h"
 #include "webrtc/api/mediacontroller.h"
 #include "webrtc/api/peerconnectioninterface.h"
 #include "webrtc/api/statstypes.h"
 #include "webrtc/base/constructormagic.h"
+#include "webrtc/base/optional.h"
 #include "webrtc/base/sigslot.h"
 #include "webrtc/base/sslidentity.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/media/base/mediachannel.h"
 #include "webrtc/p2p/base/candidate.h"
 #include "webrtc/p2p/base/transportcontroller.h"
 #include "webrtc/pc/mediasession.h"
 
 #ifdef HAVE_QUIC
 #include "webrtc/api/quicdatatransport.h"
 #endif  // HAVE_QUIC
 
 namespace cricket {
 
 class ChannelManager;
-class DataChannel;
+class RtpDataChannel;
+class SctpTransportInternal;
+class SctpTransportInternalFactory;
 class StatsReport;
 class VideoChannel;
 class VoiceChannel;
 
 #ifdef HAVE_QUIC
 class QuicTransportChannel;
 #endif  // HAVE_QUIC
 
 }  // namespace cricket
 
 namespace webrtc {
 
 class IceRestartAnswerLatch;
 class JsepIceCandidate;
 class MediaStreamSignaling;
 class WebRtcSessionDescriptionFactory;
 
 extern const char kBundleWithoutRtcpMux[];
 extern const char kCreateChannelFailed[];
 extern const char kInvalidCandidates[];
 extern const char kInvalidSdp[];
 extern const char kMlineMismatch[];
 extern const char kPushDownTDFailed[];
 extern const char kSdpWithoutDtlsFingerprint[];
 extern const char kSdpWithoutSdesCrypto[];
 extern const char kSdpWithoutIceUfragPwd[];
 extern const char kSdpWithoutSdesAndDtlsDisabled[];
 extern const char kSessionError[];
 extern const char kSessionErrorDesc[];
-extern const char kDtlsSetupFailureRtp[];
-extern const char kDtlsSetupFailureRtcp[];
+extern const char kDtlsSrtpSetupFailureRtp[];
+extern const char kDtlsSrtpSetupFailureRtcp[];
 extern const char kEnableBundleFailed[];
 
 // Maximum number of received video streams that will be processed by webrtc
 // even if they are not signalled beforehand.
 extern const int kMaxUnsignalledRecvStreams;
 
 // ICE state callback interface.
 class IceObserver {
  public:
   IceObserver() {}
@@ skipping 69 matching lines @@
     STATE_INPROGRESS,        // Offer/answer exchange completed.
     STATE_CLOSED,            // Close() was called.
   };
 
   enum Error {
     ERROR_NONE = 0,       // no error
     ERROR_CONTENT = 1,    // channel errors in SetLocalContent/SetRemoteContent
     ERROR_TRANSPORT = 2,  // transport error of some kind
   };
 
+  // |sctp_factory| may be null, in which case SCTP is treated as unsupported.
   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);
   virtual ~WebRtcSession();
 
   // These are const to allow them to be called from const methods.
   rtc::Thread* network_thread() const { return network_thread_; }
   rtc::Thread* worker_thread() const { return worker_thread_; }
   rtc::Thread* signaling_thread() const { return signaling_thread_; }
 
   // The ID of this session.
   const std::string& id() const { return sid_; }
 
@@ skipping 14 matching lines @@
   sigslot::signal2<WebRtcSession*, State> SignalState;
 
   // Returns the last error in the session. See the enum above for details.
   Error error() const { return error_; }
   const std::string& error_desc() const { return error_desc_; }
 
   void RegisterIceObserver(IceObserver* observer) {
     ice_observer_ = observer;
   }
 
+  // Exposed for stats collecting.
   virtual cricket::VoiceChannel* voice_channel() {
     return voice_channel_.get();
   }
   virtual cricket::VideoChannel* video_channel() {
     return video_channel_.get();
   }
-  virtual cricket::DataChannel* data_channel() {
-    return data_channel_.get();
+  // Only valid when using deprecated RTP data channels.
+  virtual cricket::RtpDataChannel* rtp_data_channel() {
+    return rtp_data_channel_.get();
+  }
+  virtual rtc::Optional<std::string> sctp_content_name() const {
+    return sctp_content_name_;
+  }
+  virtual rtc::Optional<std::string> sctp_transport_name() const {
+    return sctp_transport_name_;
   }
 
   cricket::BaseChannel* GetChannel(const std::string& content_name);
 
   cricket::SecurePolicy SdesPolicy() const;
 
-  // Get current ssl role from transport.
-  bool GetSslRole(const std::string& transport_name, rtc::SSLRole* role);
-
-  // Get current SSL role for this channel's transport.
-  // If |transport| is null, returns false.
-  bool GetSslRole(const cricket::BaseChannel* channel, rtc::SSLRole* role);
+  // Get current SSL role used by SCTP's underlying transport.
+  bool GetSctpSslRole(rtc::SSLRole* role);
+  // Get SSL role for an arbitrary m= section (handles bundling correctly).
+  // TODO(deadbeef): This is only used internally by the session description
+  // factory, it shouldn't really be public).
+  bool GetSslRole(const std::string& content_name, rtc::SSLRole* role);
 
   void CreateOffer(
       CreateSessionDescriptionObserver* observer,
       const PeerConnectionInterface::RTCOfferAnswerOptions& options,
       const cricket::MediaSessionOptions& session_options);
   void CreateAnswer(CreateSessionDescriptionObserver* observer,
                     const cricket::MediaSessionOptions& session_options);
   // The ownership of |desc| will be transferred after this call.
   bool SetLocalDescription(SessionDescriptionInterface* desc,
                            std::string* err_desc);
   // The ownership of |desc| will be transferred after this call.
   bool SetRemoteDescription(SessionDescriptionInterface* desc,
                             std::string* err_desc);
+
   bool ProcessIceMessage(const IceCandidateInterface* ice_candidate);
 
   bool RemoveRemoteIceCandidates(
       const std::vector<cricket::Candidate>& candidates);
 
   cricket::IceConfig ParseIceConfig(
       const PeerConnectionInterface::RTCConfiguration& config) const;
 
   void SetIceConfig(const cricket::IceConfig& ice_config);
 
@@ skipping 74 matching lines @@
   // Returns true if the ICE restart flag above was set, and no ICE restart has
   // occurred yet for this transport (by applying a local description with
   // changed ufrag/password). If the transport has been deleted as a result of
   // bundling, returns false.
   bool NeedsIceRestart(const std::string& content_name) const;
 
   // Called when an RTCCertificate is generated or retrieved by
   // WebRTCSessionDescriptionFactory. Should happen before setLocalDescription.
   void OnCertificateReady(
       const rtc::scoped_refptr<rtc::RTCCertificate>& certificate);
-  void OnDtlsSetupFailure(cricket::BaseChannel*, bool rtcp);
+  void OnDtlsSrtpSetupFailure(cricket::BaseChannel*, bool rtcp);
 
   // For unit test.
   bool waiting_for_certificate_for_testing() const;
   const rtc::scoped_refptr<rtc::RTCCertificate>& certificate_for_testing();
 
   void set_metrics_observer(
       webrtc::MetricsObserverInterface* metrics_observer) {
     metrics_observer_ = metrics_observer;
     transport_controller_->SetMetricsObserver(metrics_observer);
   }
 
-  // Called when voice_channel_, video_channel_ and data_channel_ are created
-  // and destroyed. As a result of, for example, setting a new description.
+  // Called when voice_channel_, video_channel_ and
+  // rtp_data_channel_/sctp_transport_ are created and destroyed. As a result
+  // of, for example, setting a new description.
   sigslot::signal0<> SignalVoiceChannelCreated;
   sigslot::signal0<> SignalVoiceChannelDestroyed;
   sigslot::signal0<> SignalVideoChannelCreated;
   sigslot::signal0<> SignalVideoChannelDestroyed;
   sigslot::signal0<> SignalDataChannelCreated;
   sigslot::signal0<> SignalDataChannelDestroyed;
   // Called when the whole session is destroyed.
   sigslot::signal0<> SignalDestroyed;
 
   // Called when a valid data channel OPEN message is received.
@@ skipping 37 matching lines @@
   virtual void SetError(Error error, const std::string& error_desc);
 
   bool UpdateSessionState(Action action, cricket::ContentSource source,
                           std::string* err_desc);
   static Action GetAction(const std::string& type);
   // Push the media parts of the local or remote session description
   // down to all of the channels.
   bool PushdownMediaDescription(cricket::ContentAction action,
                                 cricket::ContentSource source,
                                 std::string* error_desc);
+  bool PushdownSctpParameters_n(cricket::ContentSource source);
 
   bool PushdownTransportDescription(cricket::ContentSource source,
                                     cricket::ContentAction action,
                                     std::string* error_desc);
 
   // Helper methods to push local and remote transport descriptions.
   bool PushdownLocalTransportDescription(
       const cricket::SessionDescription* sdesc,
       cricket::ContentAction action,
       std::string* error_desc);
@@ skipping 44 matching lines @@
   bool CreateVoiceChannel(const cricket::ContentInfo* content,
                           const std::string* bundle_transport);
   bool CreateVideoChannel(const cricket::ContentInfo* content,
                           const std::string* bundle_transport);
   bool CreateDataChannel(const cricket::ContentInfo* content,
                          const std::string* bundle_transport);
 
   std::unique_ptr<SessionStats> GetStats_n(
       const ChannelNamePairs& channel_name_pairs);
 
-  // Listens to SCTP CONTROL messages on unused SIDs and process them as OPEN
-  // messages.
-  void OnDataChannelMessageReceived(cricket::DataChannel* channel,
-                                    const cricket::ReceiveDataParams& params,
-                                    const rtc::CopyOnWriteBuffer& payload);
+  bool CreateSctpTransport_n(const std::string& content_name,
+                             const std::string& transport_name);
+  // For bundling.
+  void ChangeSctpTransport_n(const std::string& transport_name);
+  void DestroySctpTransport_n();
+  // SctpTransport signal handlers. Needed to marshal signals from the network
+  // to signaling thread.
+  void OnSctpTransportReadyToSendData_n();
+  // This may be called with "false" if the direction of the m= section causes
+  // us to tear down the SCTP connection.
+  void OnSctpTransportReadyToSendData_s(bool ready);
+  void OnSctpTransportDataReceived_n(const cricket::ReceiveDataParams& params,
+                                     const rtc::CopyOnWriteBuffer& payload);
+  // Beyond just firing the signal to the signaling thread, listens to SCTP
+  // CONTROL messages on unused SIDs and processes them as OPEN messages.
+  void OnSctpTransportDataReceived_s(const cricket::ReceiveDataParams& params,
+                                     const rtc::CopyOnWriteBuffer& payload);
+  void OnSctpStreamClosedRemotely_n(int sid);
 
   std::string BadStateErrMsg(State state);
   void SetIceConnectionState(PeerConnectionInterface::IceConnectionState state);
   void SetIceConnectionReceiving(bool receiving);
 
   bool ValidateBundleSettings(const cricket::SessionDescription* desc);
   bool HasRtcpMuxEnabled(const cricket::ContentInfo* content);
   // Below methods are helper methods which verifies SDP.
   bool ValidateSessionDescription(const SessionDescriptionInterface* sdesc,
                                   cricket::ContentSource source,
@@ skipping 12 matching lines @@
   // description should be used. Output |valid| is true if the candidate media
   // index is valid.
   bool ReadyToUseRemoteCandidate(const IceCandidateInterface* candidate,
                                  const SessionDescriptionInterface* remote_desc,
                                  bool* valid);
 
   // Returns true if SRTP (either using DTLS-SRTP or SDES) is required by
   // this session.
   bool SrtpRequired() const;
 
+  // TransportController signal handlers.
   void OnTransportControllerConnectionState(cricket::IceConnectionState state);
   void OnTransportControllerReceiving(bool receiving);
   void OnTransportControllerGatheringState(cricket::IceGatheringState state);
   void OnTransportControllerCandidatesGathered(
       const std::string& transport_name,
       const std::vector<cricket::Candidate>& candidates);
   void OnTransportControllerCandidatesRemoved(
       const std::vector<cricket::Candidate>& candidates);
+  void OnTransportControllerDtlsHandshakeError(rtc::SSLHandshakeError error);
 
   std::string GetSessionErrorMsg();
 
   // Invoked when TransportController connection completion is signaled.
   // Reports stats for all transports in use.
   void ReportTransportStats();
 
   // Gather the usage of IPv4/IPv6 as best connection.
   void ReportBestConnectionState(const cricket::TransportStats& stats);
 
   void ReportNegotiatedCiphers(const cricket::TransportStats& stats);
 
   void OnSentPacket_w(const rtc::SentPacket& sent_packet);
 
   const std::string GetTransportName(const std::string& content_name);
 
-  void OnDtlsHandshakeError(rtc::SSLHandshakeError error);
-
   rtc::Thread* const network_thread_;
   rtc::Thread* const worker_thread_;
   rtc::Thread* const signaling_thread_;
 
   State state_ = STATE_INIT;
   Error error_ = ERROR_NONE;
   std::string error_desc_;
 
   const std::string sid_;
   bool initial_offerer_ = false;
 
   const std::unique_ptr<cricket::TransportController> transport_controller_;
+  const std::unique_ptr<cricket::SctpTransportInternalFactory> sctp_factory_;
   MediaControllerInterface* media_controller_;
   std::unique_ptr<cricket::VoiceChannel> voice_channel_;
   std::unique_ptr<cricket::VideoChannel> video_channel_;
-  std::unique_ptr<cricket::DataChannel> data_channel_;
+  // |rtp_data_channel_| is used if in RTP data channel mode, |sctp_transport_|
+  // when using SCTP.
+  std::unique_ptr<cricket::RtpDataChannel> rtp_data_channel_;
+
+  std::unique_ptr<cricket::SctpTransportInternal> sctp_transport_;
+  // |sctp_transport_name_| keeps track of what DTLS transport the SCTP
+  // transport is using (which can change due to bundling).
+  rtc::Optional<std::string> sctp_transport_name_;
+  // |sctp_content_name_| is the content name (MID) in SDP.
+  rtc::Optional<std::string> sctp_content_name_;
+  // Value cached on signaling thread. Only updated when SctpReadyToSendData
+  // fires on the signaling thread.
+  bool sctp_ready_to_send_data_ = false;
+  // Same as signals provided by SctpTransport, but these are guaranteed to
+  // fire on the signaling thread, whereas SctpTransport fires on the networking
+  // thread.
+  // |sctp_invoker_| is used so that any signals queued on the signaling thread
+  // from the network thread are immediately discarded if the SctpTransport is
+  // destroyed (due to m= section being rejected).
+  // TODO(deadbeef): Use a proxy object to ensure that method calls/signals
+  // are marshalled to the right thread. Could almost use proxy.h for this,
+  // but it doesn't have a mechanism for marshalling sigslot::signals
+  std::unique_ptr<rtc::AsyncInvoker> sctp_invoker_;
+  sigslot::signal1<bool> SignalSctpReadyToSendData;
+  sigslot::signal2<const cricket::ReceiveDataParams&,
+                   const rtc::CopyOnWriteBuffer&>
+      SignalSctpDataReceived;
+  sigslot::signal1<int> SignalSctpStreamClosedRemotely;
+
   cricket::ChannelManager* channel_manager_;
   IceObserver* ice_observer_;
   PeerConnectionInterface::IceConnectionState ice_connection_state_;
   bool ice_connection_receiving_;
   std::unique_ptr<SessionDescriptionInterface> current_local_description_;
   std::unique_ptr<SessionDescriptionInterface> pending_local_description_;
   std::unique_ptr<SessionDescriptionInterface> current_remote_description_;
   std::unique_ptr<SessionDescriptionInterface> pending_remote_description_;
   // If the remote peer is using a older version of implementation.
   bool older_version_remote_peer_;
@@ skipping 29 matching lines @@
 
 #ifdef HAVE_QUIC
   std::unique_ptr<QuicDataTransport> quic_data_transport_;
 #endif  // HAVE_QUIC
 
   RTC_DISALLOW_COPY_AND_ASSIGN(WebRtcSession);
 };
 }  // namespace webrtc
 
 #endif  // WEBRTC_API_WEBRTCSESSION_H_