Remove the dependency of TransportChannel and TransportChannelImpl.

webrtc/pc/channel_unittest.cc

 /*
  *  Copyright 2009 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.
  */
 
 #include <memory>
 
 #include "webrtc/base/array_view.h"
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/fakeclock.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/sslstreamadapter.h"
 #include "webrtc/media/base/fakemediaengine.h"
 #include "webrtc/media/base/fakertp.h"
 #include "webrtc/media/base/mediachannel.h"
 #include "webrtc/media/base/testutils.h"
+#include "webrtc/p2p/base/dtlstransportinternal.h"
 #include "webrtc/p2p/base/faketransportcontroller.h"
-#include "webrtc/p2p/base/transportchannelimpl.h"
 #include "webrtc/pc/channel.h"
 
 #define MAYBE_SKIP_TEST(feature)                    \
   if (!(rtc::SSLStreamAdapter::feature())) {  \
     LOG(LS_INFO) << "Feature disabled... skipping"; \
     return;                                         \
   }
 
 using cricket::CA_OFFER;
 using cricket::CA_PRANSWER;
 using cricket::CA_ANSWER;
 using cricket::CA_UPDATE;
+using cricket::DtlsTransportInternal;
 using cricket::FakeVoiceMediaChannel;
 using cricket::StreamParams;
-using cricket::TransportChannel;
 
 namespace {
 const cricket::AudioCodec kPcmuCodec(0, "PCMU", 64000, 8000, 1);
 const cricket::AudioCodec kPcmaCodec(8, "PCMA", 64000, 8000, 1);
 const cricket::AudioCodec kIsacCodec(103, "ISAC", 40000, 16000, 1);
 const cricket::VideoCodec kH264Codec(97, "H264");
 const cricket::VideoCodec kH264SvcCodec(99, "H264-SVC");
 const cricket::DataCodec kGoogleDataCodec(101, "google-data");
 const uint32_t kSsrc1 = 0x1111;
 const uint32_t kSsrc2 = 0x2222;
@@ skipping 214 matching lines @@
     return true;
   }
 
   bool AddStream1(int id) {
     return channel1_->AddRecvStream(cricket::StreamParams::CreateLegacy(id));
   }
   bool RemoveStream1(int id) {
     return channel1_->RemoveRecvStream(id);
   }
 
-  std::vector<cricket::TransportChannelImpl*> GetChannels1() {
+  std::vector<cricket::DtlsTransportInternal*> GetChannels1() {
     return transport_controller1_->channels_for_testing();
   }
 
-  std::vector<cricket::TransportChannelImpl*> GetChannels2() {
+  std::vector<cricket::DtlsTransportInternal*> GetChannels2() {
     return transport_controller2_->channels_for_testing();
   }
 
-  cricket::FakeTransportChannel* GetFakeChannel1(int component) {
-    return transport_controller1_->GetFakeTransportChannel_n(
+  cricket::FakeDtlsTransport* GetFakeChannel1(int component) {
+    return transport_controller1_->GetFakeDtlsTransport_n(
         channel1_->content_name(), component);
   }
 
-  cricket::FakeTransportChannel* GetFakeChannel2(int component) {
-    return transport_controller2_->GetFakeTransportChannel_n(
+  cricket::FakeDtlsTransport* GetFakeChannel2(int component) {
+    return transport_controller2_->GetFakeDtlsTransport_n(
         channel2_->content_name(), component);
   }
 
   void SendRtp1() {
     media_channel1_->SendRtp(rtp_packet_.data(), rtp_packet_.size(),
                              rtc::PacketOptions());
   }
   void SendRtp2() {
     media_channel2_->SendRtp(rtp_packet_.data(), rtp_packet_.size(),
                              rtc::PacketOptions());
@@ skipping 625 matching lines @@
 
   // Tests that when the transport channel signals a candidate pair change
   // event, the media channel will receive a call on the network route change.
   void TestNetworkRouteChanges() {
     constexpr uint16_t kLocalNetId = 1;
     constexpr uint16_t kRemoteNetId = 2;
     constexpr int kLastPacketId = 100;
 
     CreateChannels(0, 0);
 
-    cricket::TransportChannel* transport_channel1 =
+    cricket::DtlsTransportInternal* transport_channel1 =
         channel1_->transport_channel();
     ASSERT_TRUE(transport_channel1);
     typename T::MediaChannel* media_channel1 =
         static_cast<typename T::MediaChannel*>(channel1_->media_channel());
     ASSERT_TRUE(media_channel1);
 
     media_channel1->set_num_network_route_changes(0);
     network_thread_->Invoke<void>(RTC_FROM_HERE, [transport_channel1] {
       // The transport channel becomes disconnected.
-      transport_channel1->SignalSelectedCandidatePairChanged(
-          transport_channel1, nullptr, -1, false);
+      transport_channel1->ice_transport()->SignalSelectedCandidatePairChanged(
+          transport_channel1->ice_transport(), nullptr, -1, false);
     });
     WaitForThreads();
     EXPECT_EQ(1, media_channel1->num_network_route_changes());
     EXPECT_FALSE(media_channel1->last_network_route().connected);
     media_channel1->set_num_network_route_changes(0);
 
     network_thread_->Invoke<void>(RTC_FROM_HERE, [this, transport_channel1,
                                                   media_channel1, kLocalNetId,
                                                   kRemoteNetId, kLastPacketId] {
       // The transport channel becomes connected.
       rtc::SocketAddress local_address("192.168.1.1", 1000 /* port number */);
       rtc::SocketAddress remote_address("192.168.1.2", 2000 /* port number */);
       std::unique_ptr<cricket::CandidatePairInterface> candidate_pair(
           transport_controller1_->CreateFakeCandidatePair(
               local_address, kLocalNetId, remote_address, kRemoteNetId));
-      transport_channel1->SignalSelectedCandidatePairChanged(
-          transport_channel1, candidate_pair.get(), kLastPacketId, true);
+      transport_channel1->ice_transport()->SignalSelectedCandidatePairChanged(
+          transport_channel1->ice_transport(), candidate_pair.get(),
+          kLastPacketId, true);
     });
     WaitForThreads();
     EXPECT_EQ(1, media_channel1->num_network_route_changes());
     rtc::NetworkRoute expected_network_route(true, kLocalNetId, kRemoteNetId,
                                              kLastPacketId);
     EXPECT_EQ(expected_network_route, media_channel1->last_network_route());
     EXPECT_EQ(kLastPacketId,
               media_channel1->last_network_route().last_sent_packet_id);
     constexpr int kTransportOverheadPerPacket = 28;  // Ipv4(20) + UDP(8).
     EXPECT_EQ(kTransportOverheadPerPacket,
@@ skipping 824 matching lines @@
                              rtc::PacketOptions());
     WaitForThreads();
     EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_handler.error_);
     EXPECT_EQ(cricket::SrtpFilter::PROTECT, error_handler.mode_);
 
     // Testing failures in receiving packets.
     error_handler.error_ = cricket::SrtpFilter::ERROR_NONE;
     error_handler.mode_ = cricket::SrtpFilter::UNPROTECT;
 
     network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
-      cricket::TransportChannel* transport_channel =
+      cricket::DtlsTransportInternal* transport_channel =
           channel2_->transport_channel();
       transport_channel->SignalReadPacket(
           transport_channel, reinterpret_cast<const char*>(kBadPacket),
           sizeof(kBadPacket), rtc::PacketTime(), 0);
     });
     EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_handler.error_);
     EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, error_handler.mode_);
     // Terminate channels before the fake clock is destroyed.
     EXPECT_TRUE(SendTerminate());
   }
 
   void TestOnReadyToSend() {
     CreateChannels(RTCP, RTCP);
-    TransportChannel* rtp = channel1_->transport_channel();
-    TransportChannel* rtcp = channel1_->rtcp_transport_channel();
+    DtlsTransportInternal* rtp = channel1_->transport_channel();
+    DtlsTransportInternal* rtcp = channel1_->rtcp_transport_channel();
     EXPECT_FALSE(media_channel1_->ready_to_send());
 
     network_thread_->Invoke<void>(RTC_FROM_HERE,
                                   [rtp] { rtp->SignalReadyToSend(rtp); });
     WaitForThreads();
     EXPECT_FALSE(media_channel1_->ready_to_send());
 
     network_thread_->Invoke<void>(RTC_FROM_HERE,
                                   [rtcp] { rtcp->SignalReadyToSend(rtcp); });
     WaitForThreads();
@@ skipping 30 matching lines @@
 
   void TestOnReadyToSendWithRtcpMux() {
     CreateChannels(RTCP, RTCP);
     typename T::Content content;
     CreateContent(0, kPcmuCodec, kH264Codec, &content);
     // Both sides agree on mux. Should no longer be a separate RTCP channel.
     content.set_rtcp_mux(true);
     EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, NULL));
     EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
     EXPECT_TRUE(channel1_->rtcp_transport_channel() == NULL);
-    TransportChannel* rtp = channel1_->transport_channel();
+    DtlsTransportInternal* rtp = channel1_->transport_channel();
     EXPECT_FALSE(media_channel1_->ready_to_send());
     // In the case of rtcp mux, the SignalReadyToSend() from rtp channel
     // should trigger the MediaChannel's OnReadyToSend.
     network_thread_->Invoke<void>(RTC_FROM_HERE,
                                   [rtp] { rtp->SignalReadyToSend(rtp); });
     WaitForThreads();
     EXPECT_TRUE(media_channel1_->ready_to_send());
 
     network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
       channel1_->SetTransportChannelReadyToSend(false, false);
@@ skipping 1763 matching lines @@
   };
   rtc::CopyOnWriteBuffer payload(data, 3);
   cricket::SendDataResult result;
   ASSERT_TRUE(media_channel1_->SendData(params, payload, &result));
   EXPECT_EQ(params.ssrc,
             media_channel1_->last_sent_data_params().ssrc);
   EXPECT_EQ("foo", media_channel1_->last_sent_data());
 }
 
 // TODO(pthatcher): TestSetReceiver?