Remove the dependency of TransportChannel and TransportChannelImpl.

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 142 matching lines @@
   void SignalDtlsSrtpSetupFailure_n(bool rtcp);
   void SignalDtlsSrtpSetupFailure_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 {
+  DtlsTransportInternal* transport_channel() const {
+    return transport_channel_;
+  }
+  DtlsTransportInternal* rtcp_transport_channel() const {

[pthatcher1, 2017/01/13 22:41:16]

We should call these rtp_dtls_transport and rtcp_dtls_transport.  Or something
with "dtls" in the name.

[Zhi Huang, 2017/01/16 10:38:25]

Done.

     return rtcp_transport_channel_;
   }
 
   // Made public for easier testing.
   //
   // Updates "ready to send" for an individual channel, and informs the media
   // channel that the transport is ready to send if each channel (in use) is
   // ready to send. This is more specific than just "writable"; it means the
   // last send didn't return ENOTCONN.
   //
@@ skipping 19 matching lines @@
   virtual MediaChannel* media_channel() const { return media_channel_; }
 
   // Sets the |transport_channel_| (and |rtcp_transport_channel_|, if
   // |rtcp_enabled_| is true). Gets the transport channels from
   // |transport_controller_|.
   // This method also updates writability and "ready-to-send" state.
   bool SetTransport_n(const std::string& transport_name);
 
   // This does not update writability or "ready-to-send" state; it just
   // disconnects from the old channel and connects to the new one.
-  void SetTransportChannel_n(bool rtcp, TransportChannel* new_channel);
+  void SetTransportChannel_n(bool rtcp, DtlsTransportInternal* new_channel);
 
   bool was_ever_writable() const { return was_ever_writable_; }
   void set_local_content_direction(MediaContentDirection direction) {
     local_content_direction_ = direction;
   }
   void set_remote_content_direction(MediaContentDirection direction) {
     remote_content_direction_ = direction;
   }
   // These methods verify that:
   // * The required content description directions have been set.
   // * The channel is enabled.
   // * And for sending:
   //   - The SRTP filter is active if it's needed.
   //   - The transport has been writable before, meaning it should be at least
   //     possible to succeed in sending a packet.
   //
   // When any of these properties change, UpdateMediaSendRecvState_w should be
   // called.
   bool IsReadyToReceiveMedia_w() const;
   bool IsReadyToSendMedia_w() const;
   rtc::Thread* signaling_thread() {
     return transport_controller_->signaling_thread();
   }
 
-  void ConnectToTransportChannel(TransportChannel* tc);
-  void DisconnectFromTransportChannel(TransportChannel* tc);
+  void ConnectToTransportChannel(DtlsTransportInternal* tc);
+  void DisconnectFromTransportChannel(DtlsTransportInternal* tc);

[pthatcher1, 2017/01/13 22:41:16]

This should be ConnectToTransport and DisconnectFromTransport (not channel).

[Zhi Huang, 2017/01/16 10:38:24]

Done.

 
   void FlushRtcpMessages_n();
 
   // NetworkInterface implementation, called by MediaEngine
   bool SendPacket(rtc::CopyOnWriteBuffer* packet,
                   const rtc::PacketOptions& options) override;
   bool SendRtcp(rtc::CopyOnWriteBuffer* packet,
                 const rtc::PacketOptions& options) override;
 
   // From TransportChannel
   void OnWritableState(rtc::PacketTransportInterface* transport);
   virtual void OnPacketRead(rtc::PacketTransportInterface* transport,
                             const char* data,
                             size_t len,
                             const rtc::PacketTime& packet_time,
                             int flags);
   void OnReadyToSend(rtc::PacketTransportInterface* transport);
 
-  void OnDtlsState(TransportChannel* channel, DtlsTransportState state);
+  void OnDtlsState(DtlsTransportInternal* channel, DtlsTransportState state);
 
   void OnSelectedCandidatePairChanged(
-      TransportChannel* channel,
+      IceTransportInternal* channel,
       CandidatePairInterface* selected_candidate_pair,
       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);
@@ skipping 18 matching lines @@
   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;
   // 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);
+  bool SetDtlsSrtpCryptoSuites_n(DtlsTransportInternal* 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.
   void UpdateMediaSendRecvState();
   virtual void UpdateMediaSendRecvState_w() = 0;
 
   // Gets the content info appropriate to the channel (audio or video).
   virtual const ContentInfo* GetFirstContent(
       const SessionDescription* sdesc) = 0;
@@ skipping 76 matching lines @@
   std::unique_ptr<ConnectionMonitor> connection_monitor_;
 
   // Transport related members that should be accessed from network thread.
   TransportController* const transport_controller_;
   std::string transport_name_;
   // Is RTCP used at all by this type of channel?
   // Expected to be true (as of typing this) for everything except data
   // channels.
   const bool rtcp_enabled_;
   // TODO(johan): Replace TransportChannel* with rtc::PacketTransportInterface*.
-  TransportChannel* transport_channel_ = nullptr;
+  DtlsTransportInternal* transport_channel_ = nullptr;
   std::vector<std::pair<rtc::Socket::Option, int> > socket_options_;
-  TransportChannel* rtcp_transport_channel_ = nullptr;
+  DtlsTransportInternal* rtcp_transport_channel_ = nullptr;

[pthatcher1, 2017/01/13 22:41:16]

Same here with the names.

[Zhi Huang, 2017/01/16 10:38:24]

Done.

   std::vector<std::pair<rtc::Socket::Option, int> > rtcp_socket_options_;
   SrtpFilter srtp_filter_;
   RtcpMuxFilter rtcp_mux_filter_;
   BundleFilter bundle_filter_;
   bool rtp_ready_to_send_ = false;
   bool rtcp_ready_to_send_ = false;
   bool writable_ = false;
   bool was_ever_writable_ = false;
   bool has_received_packet_ = false;
   bool dtls_keyed_ = false;
@@ skipping 321 matching lines @@
   // 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_