Remove BaseChannel's dependency on TransportController.

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.
  */
 
@@ skipping 127 matching lines @@
     channel1_.reset(
         CreateChannel(worker_thread, network_thread_, &media_engine_, ch1,
                       transport_controller1_.get(), flags1));
     channel2_.reset(
         CreateChannel(worker_thread, network_thread_, &media_engine_, ch2,
                       transport_controller2_.get(), flags2));
     channel1_->SignalMediaMonitor.connect(this,
                                           &ChannelTest<T>::OnMediaMonitor1);
     channel2_->SignalMediaMonitor.connect(this,
                                           &ChannelTest<T>::OnMediaMonitor2);
+    channel1_->SignalDestroyRtcpTransport.connect(
+        transport_controller1_.get(),
+        &cricket::FakeTransportController::OnDestroyRtcpTransport);
+    channel2_->SignalDestroyRtcpTransport.connect(
+        transport_controller2_.get(),
+        &cricket::FakeTransportController::OnDestroyRtcpTransport);
     if ((flags1 & DTLS) && (flags2 & DTLS)) {
       flags1 = (flags1 & ~SECURE);
       flags2 = (flags2 & ~SECURE);
     }
     CreateContent(flags1, kPcmuCodec, kH264Codec,
                   &local_media_content1_);
     CreateContent(flags2, kPcmuCodec, kH264Codec,
                   &local_media_content2_);
     CopyContent(local_media_content1_, &remote_media_content1_);
     CopyContent(local_media_content2_, &remote_media_content2_);
@@ skipping 25 matching lines @@
       AddLegacyStreamInContent(kSsrc2, flags2, &remote_media_content2_);
     }
   }
   typename T::Channel* CreateChannel(
       rtc::Thread* worker_thread,
       rtc::Thread* network_thread,
       cricket::MediaEngineInterface* engine,
       typename T::MediaChannel* ch,
       cricket::TransportController* transport_controller,
       int flags) {
+    rtc::Thread* signaling_thread =
+        transport_controller ? transport_controller->signaling_thread()
+                             : nullptr;
     typename T::Channel* channel = new typename T::Channel(
-        worker_thread, network_thread, engine, ch, transport_controller,
+        worker_thread, network_thread, signaling_thread, engine, ch,
         cricket::CN_AUDIO, (flags & RTCP) != 0, (flags & SECURE) != 0);
     rtc::CryptoOptions crypto_options;
     crypto_options.enable_gcm_crypto_suites = (flags & GCM_CIPHER) != 0;
     channel->SetCryptoOptions(crypto_options);
-    if (!channel->Init_w(nullptr)) {
+    cricket::TransportChannel* rtp_transport =
+        transport_controller->CreateTransportChannel(
+            channel->content_name(), cricket::ICE_CANDIDATE_COMPONENT_RTP);
+    cricket::TransportChannel* rtcp_transport = nullptr;
+    if (channel->NeedsRtcpTransport()) {
+      rtcp_transport = transport_controller->CreateTransportChannel(
+          channel->content_name(), cricket::ICE_CANDIDATE_COMPONENT_RTCP);
+    }
+    if (!channel->Init_w(rtp_transport, rtcp_transport)) {
       delete channel;
       channel = NULL;
     }
     return channel;
   }
 
   bool SendInitiate() {
     bool result = channel1_->SetLocalContent(&local_media_content1_,
                                              CA_OFFER, NULL);
     if (result) {
@@ skipping 166 matching lines @@
   bool CheckNoRtcp1() {
     return media_channel1_->CheckNoRtcp();
   }
   bool CheckNoRtcp2() {
     return media_channel2_->CheckNoRtcp();
   }
   // Checks that the channel is using GCM iff GCM_CIPHER is set in flags.
   // Returns true if so.
   bool CheckGcmCipher(typename T::Channel* channel, int flags) {
     int suite;
-    if (!channel->transport_channel()->GetSrtpCryptoSuite(&suite)) {
+    if (!channel->rtp_transport()->GetSrtpCryptoSuite(&suite)) {
       return false;
     }
 
     if (flags & GCM_CIPHER) {
       return rtc::IsGcmCryptoSuite(suite);
     } else {
       return (suite != rtc::SRTP_INVALID_CRYPTO_SUITE &&
           !rtc::IsGcmCryptoSuite(suite));
     }
   }
@@ skipping 109 matching lines @@
     EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
     ASSERT_EQ(1U, media_channel1_->codecs().size());
     EXPECT_TRUE(CodecMatches(content.codecs()[0],
                              media_channel1_->codecs()[0]));
   }
 
   // Test that SetLocalContent and SetRemoteContent properly set RTCP
   // mux.
   void TestSetContentsRtcpMux() {
     CreateChannels(RTCP, RTCP);
-    EXPECT_TRUE(channel1_->rtcp_transport_channel() != NULL);
-    EXPECT_TRUE(channel2_->rtcp_transport_channel() != NULL);
+    EXPECT_TRUE(channel1_->rtcp_transport() != NULL);
+    EXPECT_TRUE(channel2_->rtcp_transport() != NULL);
     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);
+    EXPECT_TRUE(channel1_->rtcp_transport() == NULL);
     // Only initiator supports mux. Should still have a separate RTCP channel.
     EXPECT_TRUE(channel2_->SetLocalContent(&content, CA_OFFER, NULL));
     content.set_rtcp_mux(false);
     EXPECT_TRUE(channel2_->SetRemoteContent(&content, CA_ANSWER, NULL));
-    EXPECT_TRUE(channel2_->rtcp_transport_channel() != NULL);
+    EXPECT_TRUE(channel2_->rtcp_transport() != NULL);
   }
 
   // Test that SetLocalContent and SetRemoteContent properly set RTCP
   // mux when a provisional answer is received.
   void TestSetContentsRtcpMuxWithPrAnswer() {
     CreateChannels(RTCP, RTCP);
-    EXPECT_TRUE(channel1_->rtcp_transport_channel() != NULL);
-    EXPECT_TRUE(channel2_->rtcp_transport_channel() != NULL);
+    EXPECT_TRUE(channel1_->rtcp_transport() != NULL);
+    EXPECT_TRUE(channel2_->rtcp_transport() != NULL);
     typename T::Content content;
     CreateContent(0, kPcmuCodec, kH264Codec, &content);
     content.set_rtcp_mux(true);
     EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, NULL));
     EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_PRANSWER, NULL));
-    EXPECT_TRUE(channel1_->rtcp_transport_channel() != NULL);
+    EXPECT_TRUE(channel1_->rtcp_transport() != NULL);
     EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
     // Both sides agree on mux. Should no longer be a separate RTCP channel.
-    EXPECT_TRUE(channel1_->rtcp_transport_channel() == NULL);
+    EXPECT_TRUE(channel1_->rtcp_transport() == NULL);
     // Only initiator supports mux. Should still have a separate RTCP channel.
     EXPECT_TRUE(channel2_->SetLocalContent(&content, CA_OFFER, NULL));
     content.set_rtcp_mux(false);
     EXPECT_TRUE(channel2_->SetRemoteContent(&content, CA_PRANSWER, NULL));
     EXPECT_TRUE(channel2_->SetRemoteContent(&content, CA_ANSWER, NULL));
-    EXPECT_TRUE(channel2_->rtcp_transport_channel() != NULL);
+    EXPECT_TRUE(channel2_->rtcp_transport() != NULL);
   }
 
   // Test that SetRemoteContent properly deals with a content update.
   void TestSetRemoteContentUpdate() {
     CreateChannels(0, 0);
     typename T::Content content;
     CreateContent(RTCP | RTCP_MUX | SECURE,
                   kPcmuCodec, kH264Codec,
                   &content);
     EXPECT_EQ(0U, media_channel1_->codecs().size());
@@ skipping 361 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 =
-        channel1_->transport_channel();
+    cricket::TransportChannel* transport_channel1 = channel1_->rtp_transport();
     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);
@@ skipping 851 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 =
-          channel2_->transport_channel();
+      cricket::TransportChannel* transport_channel = channel2_->rtp_transport();
       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();
+    TransportChannel* rtp = channel1_->rtp_transport();
+    TransportChannel* rtcp = channel1_->rtcp_transport();
     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 29 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();
+    EXPECT_TRUE(channel1_->rtcp_transport() == NULL);
+    TransportChannel* rtp = channel1_->rtp_transport();
     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 150 matching lines @@
 
 // override to add NULL parameter
 template <>
 cricket::VideoChannel* ChannelTest<VideoTraits>::CreateChannel(
     rtc::Thread* worker_thread,
     rtc::Thread* network_thread,
     cricket::MediaEngineInterface* engine,
     cricket::FakeVideoMediaChannel* ch,
     cricket::TransportController* transport_controller,
     int flags) {
+  rtc::Thread* signaling_thread =
+      transport_controller ? transport_controller->signaling_thread() : nullptr;
   cricket::VideoChannel* channel = new cricket::VideoChannel(
-      worker_thread, network_thread, ch, transport_controller,
-      cricket::CN_VIDEO, (flags & RTCP) != 0, (flags & SECURE) != 0);
+      worker_thread, network_thread, signaling_thread, ch, cricket::CN_VIDEO,
+      (flags & RTCP) != 0, (flags & SECURE) != 0);
   rtc::CryptoOptions crypto_options;
   crypto_options.enable_gcm_crypto_suites = (flags & GCM_CIPHER) != 0;
   channel->SetCryptoOptions(crypto_options);
-  if (!channel->Init_w(nullptr)) {
+  cricket::TransportChannel* rtp_transport =
+      transport_controller->CreateTransportChannel(
+          channel->content_name(), cricket::ICE_CANDIDATE_COMPONENT_RTP);
+  cricket::TransportChannel* rtcp_transport = nullptr;
+  if (channel->NeedsRtcpTransport()) {
+    rtcp_transport = transport_controller->CreateTransportChannel(
+        channel->content_name(), cricket::ICE_CANDIDATE_COMPONENT_RTCP);
+  }
+  if (!channel->Init_w(rtp_transport, rtcp_transport)) {
     delete channel;
     channel = NULL;
   }
   return channel;
 }
 
 // override to add 0 parameter
 template<>
 bool ChannelTest<VideoTraits>::AddStream1(int id) {
   return channel1_->AddRecvStream(cricket::StreamParams::CreateLegacy(id));
@@ skipping 1245 matching lines @@
 
 // Override to avoid engine channel parameter.
 template <>
 cricket::RtpDataChannel* ChannelTest<DataTraits>::CreateChannel(
     rtc::Thread* worker_thread,
     rtc::Thread* network_thread,
     cricket::MediaEngineInterface* engine,
     cricket::FakeDataMediaChannel* ch,
     cricket::TransportController* transport_controller,
     int flags) {
+  rtc::Thread* signaling_thread =
+      transport_controller ? transport_controller->signaling_thread() : nullptr;
   cricket::RtpDataChannel* channel = new cricket::RtpDataChannel(
-      worker_thread, network_thread, ch, transport_controller, cricket::CN_DATA,
+      worker_thread, network_thread, signaling_thread, ch, cricket::CN_DATA,
       (flags & RTCP) != 0, (flags & SECURE) != 0);
   rtc::CryptoOptions crypto_options;
   crypto_options.enable_gcm_crypto_suites = (flags & GCM_CIPHER) != 0;
   channel->SetCryptoOptions(crypto_options);
-  if (!channel->Init_w(nullptr)) {
+  cricket::TransportChannel* rtp_transport =
+      transport_controller->CreateTransportChannel(
+          channel->content_name(), cricket::ICE_CANDIDATE_COMPONENT_RTP);
+  cricket::TransportChannel* rtcp_transport = nullptr;
+  if (channel->NeedsRtcpTransport()) {
+    rtcp_transport = transport_controller->CreateTransportChannel(
+        channel->content_name(), cricket::ICE_CANDIDATE_COMPONENT_RTCP);
+  }
+  if (!channel->Init_w(rtp_transport, rtcp_transport)) {
     delete channel;
     channel = NULL;
   }
   return channel;
 }
 
 template <>
 void ChannelTest<DataTraits>::CreateContent(
     int flags,
     const cricket::AudioCodec& audio_codec,
@@ skipping 314 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?