Revert of Separating SCTP code from BaseChannel/MediaChannel.

webrtc/pc/channel.h

 /*
  *  Copyright 2004 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 131 matching lines @@
 
   BundleFilter* bundle_filter() { return &bundle_filter_; }
 
   const std::vector<StreamParams>& local_streams() const {
     return local_streams_;
   }
   const std::vector<StreamParams>& remote_streams() const {
     return remote_streams_;
   }
 
-  sigslot::signal2<BaseChannel*, bool> SignalDtlsSrtpSetupFailure;
-  void SignalDtlsSrtpSetupFailure_n(bool rtcp);
-  void SignalDtlsSrtpSetupFailure_s(bool rtcp);
+  sigslot::signal2<BaseChannel*, bool> SignalDtlsSetupFailure;
+  void SignalDtlsSetupFailure_n(bool rtcp);
+  void SignalDtlsSetupFailure_s(bool rtcp);
 
   // Used for latency measurements.
   sigslot::signal1<BaseChannel*> SignalFirstPacketReceived;
 
   // Forward TransportChannel SignalSentPacket to worker thread.
   sigslot::signal1<const rtc::SentPacket&> SignalSentPacket;
 
   // Only public for unit tests.  Otherwise, consider private.
   TransportChannel* transport_channel() const { return transport_channel_; }
   TransportChannel* rtcp_transport_channel() const {
@@ skipping 89 matching lines @@
       int last_sent_packet_id,
       bool ready_to_send);
 
   bool PacketIsRtcp(const rtc::PacketTransportInterface* transport,
                     const char* data,
                     size_t len);
   bool SendPacket(bool rtcp,
                   rtc::CopyOnWriteBuffer* packet,
                   const rtc::PacketOptions& options);
 
-  bool WantsPacket(bool rtcp, const rtc::CopyOnWriteBuffer* packet);
+  virtual bool WantsPacket(bool rtcp, const rtc::CopyOnWriteBuffer* packet);
   void HandlePacket(bool rtcp, rtc::CopyOnWriteBuffer* packet,
                     const rtc::PacketTime& packet_time);
   void OnPacketReceived(bool rtcp,
                         const rtc::CopyOnWriteBuffer& packet,
                         const rtc::PacketTime& packet_time);
 
   void EnableMedia_w();
   void DisableMedia_w();
 
   // Performs actions if the RTP/RTCP writable state changed. This should
   // be called whenever a channel's writable state changes or when RTCP muxing
   // becomes active/inactive.
   void UpdateWritableState_n();
   void ChannelWritable_n();
   void ChannelNotWritable_n();
 
   bool AddRecvStream_w(const StreamParams& sp);
   bool RemoveRecvStream_w(uint32_t ssrc);
   bool AddSendStream_w(const StreamParams& sp);
   bool RemoveSendStream_w(uint32_t ssrc);
-  bool ShouldSetupDtlsSrtp_n() const;
+  virtual bool ShouldSetupDtlsSrtp_n() const;
   // Do the DTLS key expansion and impose it on the SRTP/SRTCP filters.
   // |rtcp_channel| indicates whether to set up the RTP or RTCP filter.
   bool SetupDtlsSrtp_n(bool rtcp_channel);
   void MaybeSetupDtlsSrtp_n();
   // Set the DTLS-SRTP cipher policy on this channel as appropriate.
   bool SetDtlsSrtpCryptoSuites_n(TransportChannel* tc, bool rtcp);
 
   // Should be called whenever the conditions for
   // IsReadyToReceiveMedia/IsReadyToSendMedia are satisfied (or unsatisfied).
   // Updates the send/recv state of the media channel.
@@ skipping 312 matching lines @@
   std::unique_ptr<VideoMediaMonitor> media_monitor_;
 
   // Last VideoSendParameters sent down to the media_channel() via
   // SetSendParameters.
   VideoSendParameters last_send_params_;
   // Last VideoRecvParameters sent down to the media_channel() via
   // SetRecvParameters.
   VideoRecvParameters last_recv_params_;
 };
 
-// RtpDataChannel is a specialization for data.
-class RtpDataChannel : public BaseChannel {
+// DataChannel is a specialization for data.
+class DataChannel : public BaseChannel {
  public:
-  RtpDataChannel(rtc::Thread* worker_thread,
-                 rtc::Thread* network_thread,
-                 DataMediaChannel* media_channel,
-                 TransportController* transport_controller,
-                 const std::string& content_name,
-                 bool rtcp,
-                 bool srtp_required);
-  ~RtpDataChannel();
+  DataChannel(rtc::Thread* worker_thread,
+              rtc::Thread* network_thread,
+              DataMediaChannel* media_channel,
+              TransportController* transport_controller,
+              const std::string& content_name,
+              bool rtcp,
+              bool srtp_required);
+  ~DataChannel();
   bool Init_w(const std::string* bundle_transport_name);
 
   virtual bool SendData(const SendDataParams& params,
                         const rtc::CopyOnWriteBuffer& payload,
                         SendDataResult* result);
 
   void StartMediaMonitor(int cms);
   void StopMediaMonitor();
 
   // Should be called on the signaling thread only.
   bool ready_to_send_data() const {
     return ready_to_send_data_;
   }
 
-  sigslot::signal2<RtpDataChannel*, const DataMediaInfo&> SignalMediaMonitor;
-  sigslot::signal2<RtpDataChannel*, const std::vector<ConnectionInfo>&>
+  sigslot::signal2<DataChannel*, const DataMediaInfo&> SignalMediaMonitor;
+  sigslot::signal2<DataChannel*, const std::vector<ConnectionInfo>&>
       SignalConnectionMonitor;
-
-  sigslot::signal2<const ReceiveDataParams&, const rtc::CopyOnWriteBuffer&>
-      SignalDataReceived;
+  sigslot::signal3<DataChannel*, const ReceiveDataParams&,
+      const rtc::CopyOnWriteBuffer&> SignalDataReceived;
   // Signal for notifying when the channel becomes ready to send data.
   // That occurs when the channel is enabled, the transport is writable,
   // both local and remote descriptions are set, and the channel is unblocked.
   sigslot::signal1<bool> SignalReadyToSendData;
+  // Signal for notifying that the remote side has closed the DataChannel.
+  sigslot::signal1<uint32_t> SignalStreamClosedRemotely;
   cricket::MediaType media_type() override { return cricket::MEDIA_TYPE_DATA; }
 
  protected:
   // downcasts a MediaChannel.
   DataMediaChannel* media_channel() const override {
     return static_cast<DataMediaChannel*>(BaseChannel::media_channel());
   }
 
  private:
   struct SendDataMessageData : public rtc::MessageData {
@@ skipping 22 matching lines @@
           payload(data, len) {
     }
     const ReceiveDataParams params;
     const rtc::CopyOnWriteBuffer payload;
   };
 
   typedef rtc::TypedMessageData<bool> DataChannelReadyToSendMessageData;
 
   // overrides from BaseChannel
   const ContentInfo* GetFirstContent(const SessionDescription* sdesc) override;
-  // Checks that data channel type is RTP.
-  bool CheckDataChannelTypeFromContent(const DataContentDescription* content,
-                                       std::string* error_desc);
+  // If data_channel_type_ is DCT_NONE, set it.  Otherwise, check that
+  // it's the same as what was set previously.  Returns false if it's
+  // set to one type one type and changed to another type later.
+  bool SetDataChannelType(DataChannelType new_data_channel_type,
+                          std::string* error_desc);
+  // Same as SetDataChannelType, but extracts the type from the
+  // DataContentDescription.
+  bool SetDataChannelTypeFromContent(const DataContentDescription* content,
+                                     std::string* error_desc);
   bool SetLocalContent_w(const MediaContentDescription* content,
                          ContentAction action,
                          std::string* error_desc) override;
   bool SetRemoteContent_w(const MediaContentDescription* content,
                           ContentAction action,
                           std::string* error_desc) override;
   void UpdateMediaSendRecvState_w() override;
+  bool WantsPacket(bool rtcp, const rtc::CopyOnWriteBuffer* packet) override;
 
   void OnMessage(rtc::Message* pmsg) override;
   void GetSrtpCryptoSuites_n(std::vector<int>* crypto_suites) const override;
   void OnConnectionMonitorUpdate(
       ConnectionMonitor* monitor,
       const std::vector<ConnectionInfo>& infos) override;
   void OnMediaMonitorUpdate(DataMediaChannel* media_channel,
                             const DataMediaInfo& info);
+  bool ShouldSetupDtlsSrtp_n() const override;
   void OnDataReceived(
       const ReceiveDataParams& params, const char* data, size_t len);
   void OnDataChannelError(uint32_t ssrc, DataMediaChannel::Error error);
   void OnDataChannelReadyToSend(bool writable);
+  void OnStreamClosedRemotely(uint32_t sid);
 
   std::unique_ptr<DataMediaMonitor> media_monitor_;
-  bool ready_to_send_data_ = false;
+  // TODO(pthatcher): Make a separate SctpDataChannel and
+  // RtpDataChannel instead of using this.
+  DataChannelType data_channel_type_;
+  bool ready_to_send_data_;
 
   // Last DataSendParameters sent down to the media_channel() via
   // SetSendParameters.
   DataSendParameters last_send_params_;
   // Last DataRecvParameters sent down to the media_channel() via
   // SetRecvParameters.
   DataRecvParameters last_recv_params_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_PC_CHANNEL_H_