Revert 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 RtpDataChannel;
-class SctpTransportInternal;
-class SctpTransportInternalFactory;
+class DataChannel;
 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 kDtlsSrtpSetupFailureRtp[];
-extern const char kDtlsSrtpSetupFailureRtcp[];
+extern const char kDtlsSetupFailureRtp[];
+extern const char kDtlsSetupFailureRtcp[];
 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::SctpTransportInternalFactory> sctp_factory);
+      std::unique_ptr<cricket::TransportController> transport_controller);
   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();
   }
-  // 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_;
+  virtual cricket::DataChannel* data_channel() {
+    return data_channel_.get();
   }
 
   cricket::BaseChannel* GetChannel(const std::string& content_name);
 
   cricket::SecurePolicy SdesPolicy() const;
 
-  // 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);
+  // 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);
 
   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 OnDtlsSrtpSetupFailure(cricket::BaseChannel*, bool rtcp);
+  void OnDtlsSetupFailure(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
-  // rtp_data_channel_/sctp_transport_ are created and destroyed. As a result
-  // of, for example, setting a new description.
+  // Called when voice_channel_, video_channel_ and data_channel_ 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);
 
-  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);
+  // 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);
 
   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_;
-  // |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;
-
+  std::unique_ptr<cricket::DataChannel> data_channel_;
   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_