Revert of Refactoring that removes P2PTransport and DtlsTransport classes.

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/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;
@@ skipping 230 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() {
-    return transport_controller1_->channels_for_testing();
+  cricket::FakeTransport* GetTransport1() {
+    std::string name = channel1_->content_name();
+    return network_thread_->Invoke<cricket::FakeTransport*>(
+        RTC_FROM_HERE,
+        [this, name] { return transport_controller1_->GetTransport_n(name); });
   }
-
-  std::vector<cricket::TransportChannelImpl*> GetChannels2() {
-    return transport_controller2_->channels_for_testing();
-  }
-
-  cricket::FakeTransportChannel* GetFakeChannel1(int component) {
-    return transport_controller1_->GetFakeTransportChannel_n(
-        channel1_->content_name(), component);
-  }
-
-  cricket::FakeTransportChannel* GetFakeChannel2(int component) {
-    return transport_controller2_->GetFakeTransportChannel_n(
-        channel2_->content_name(), component);
+  cricket::FakeTransport* GetTransport2() {
+    std::string name = channel2_->content_name();
+    return network_thread_->Invoke<cricket::FakeTransport*>(
+        RTC_FROM_HERE,
+        [this, name] { return transport_controller2_->GetTransport_n(name); });
   }
 
   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 712 matching lines @@
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
     EXPECT_TRUE(SendTerminate());
   }
 
   // Send voice RTP data to the other side and ensure it gets there.
   void SendRtpToRtp() {
     CreateChannels(0, 0);
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
-    EXPECT_EQ(1U, GetChannels1().size());
-    EXPECT_EQ(1U, GetChannels2().size());
+    ASSERT_TRUE(GetTransport1());
+    ASSERT_TRUE(GetTransport2());
+    EXPECT_EQ(1U, GetTransport1()->channels().size());
+    EXPECT_EQ(1U, GetTransport2()->channels().size());
     SendRtp1();
     SendRtp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
   }
 
   void TestDeinit() {
     CreateChannels(RTCP, RTCP);
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
     SendRtp1();
     SendRtp2();
     SendRtcp1();
     SendRtcp2();
     // Do not wait, destroy channels.
     channel1_.reset(nullptr);
     channel2_.reset(nullptr);
   }
 
   // Check that RTCP is not transmitted if both sides don't support RTCP.
   void SendNoRtcpToNoRtcp() {
     CreateChannels(0, 0);
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
-    EXPECT_EQ(1U, GetChannels1().size());
-    EXPECT_EQ(1U, GetChannels2().size());
+    ASSERT_TRUE(GetTransport1());
+    ASSERT_TRUE(GetTransport2());
+    EXPECT_EQ(1U, GetTransport1()->channels().size());
+    EXPECT_EQ(1U, GetTransport2()->channels().size());
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Check that RTCP is not transmitted if the callee doesn't support RTCP.
   void SendNoRtcpToRtcp() {
     CreateChannels(0, RTCP);
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
-    EXPECT_EQ(1U, GetChannels1().size());
-    EXPECT_EQ(2U, GetChannels2().size());
+    ASSERT_TRUE(GetTransport1());
+    ASSERT_TRUE(GetTransport2());
+    EXPECT_EQ(1U, GetTransport1()->channels().size());
+    EXPECT_EQ(2U, GetTransport2()->channels().size());
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Check that RTCP is not transmitted if the caller doesn't support RTCP.
   void SendRtcpToNoRtcp() {
     CreateChannels(RTCP, 0);
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
-    EXPECT_EQ(2U, GetChannels1().size());
-    EXPECT_EQ(1U, GetChannels2().size());
+    ASSERT_TRUE(GetTransport1());
+    ASSERT_TRUE(GetTransport2());
+    EXPECT_EQ(2U, GetTransport1()->channels().size());
+    EXPECT_EQ(1U, GetTransport2()->channels().size());
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Check that RTCP is transmitted if both sides support RTCP.
   void SendRtcpToRtcp() {
     CreateChannels(RTCP, RTCP);
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
-    EXPECT_EQ(2U, GetChannels1().size());
-    EXPECT_EQ(2U, GetChannels2().size());
+    ASSERT_TRUE(GetTransport1());
+    ASSERT_TRUE(GetTransport2());
+    EXPECT_EQ(2U, GetTransport1()->channels().size());
+    EXPECT_EQ(2U, GetTransport2()->channels().size());
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtcp1());
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Check that RTCP is transmitted if only the initiator supports mux.
   void SendRtcpMuxToRtcp() {
     CreateChannels(RTCP | RTCP_MUX, RTCP);
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
-    EXPECT_EQ(2U, GetChannels1().size());
-    EXPECT_EQ(2U, GetChannels2().size());
+    ASSERT_TRUE(GetTransport1());
+    ASSERT_TRUE(GetTransport2());
+    EXPECT_EQ(2U, GetTransport1()->channels().size());
+    EXPECT_EQ(2U, GetTransport2()->channels().size());
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtcp1());
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Check that RTP and RTCP are transmitted ok when both sides support mux.
   void SendRtcpMuxToRtcpMux() {
     CreateChannels(RTCP | RTCP_MUX, RTCP | RTCP_MUX);
     EXPECT_TRUE(SendInitiate());
-    EXPECT_EQ(2U, GetChannels1().size());
-    EXPECT_EQ(1U, GetChannels2().size());
+    ASSERT_TRUE(GetTransport1());
+    ASSERT_TRUE(GetTransport2());
+    EXPECT_EQ(2U, GetTransport1()->channels().size());
+    EXPECT_EQ(1U, GetTransport2()->channels().size());
     EXPECT_TRUE(SendAccept());
-    EXPECT_EQ(1U, GetChannels1().size());
+    EXPECT_EQ(1U, GetTransport1()->channels().size());
     SendRtp1();
     SendRtp2();
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
     EXPECT_TRUE(CheckRtcp1());
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Check that RTP and RTCP are transmitted ok when both sides
   // support mux and one the offerer requires mux.
   void SendRequireRtcpMuxToRtcpMux() {
     CreateChannels(RTCP | RTCP_MUX, RTCP | RTCP_MUX);
     channel1_->ActivateRtcpMux();
     EXPECT_TRUE(SendInitiate());
-    EXPECT_EQ(1U, GetChannels1().size());
-    EXPECT_EQ(1U, GetChannels2().size());
+    ASSERT_TRUE(GetTransport1());
+    ASSERT_TRUE(GetTransport2());
+    EXPECT_EQ(1U, GetTransport1()->channels().size());
+    EXPECT_EQ(1U, GetTransport2()->channels().size());
     EXPECT_TRUE(SendAccept());
     SendRtp1();
     SendRtp2();
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
     EXPECT_TRUE(CheckRtcp1());
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Check that RTP and RTCP are transmitted ok when both sides
   // support mux and one the answerer requires rtcp mux.
   void SendRtcpMuxToRequireRtcpMux() {
     CreateChannels(RTCP | RTCP_MUX, RTCP | RTCP_MUX);
     channel2_->ActivateRtcpMux();
     EXPECT_TRUE(SendInitiate());
-    EXPECT_EQ(2U, GetChannels1().size());
-    EXPECT_EQ(1U, GetChannels2().size());
+    ASSERT_TRUE(GetTransport1());
+    ASSERT_TRUE(GetTransport2());
+    EXPECT_EQ(2U, GetTransport1()->channels().size());
+    EXPECT_EQ(1U, GetTransport2()->channels().size());
     EXPECT_TRUE(SendAccept());
-    EXPECT_EQ(1U, GetChannels1().size());
+    EXPECT_EQ(1U, GetTransport1()->channels().size());
     SendRtp1();
     SendRtp2();
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
     EXPECT_TRUE(CheckRtcp1());
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Check that RTP and RTCP are transmitted ok when both sides
   // require mux.
   void SendRequireRtcpMuxToRequireRtcpMux() {
     CreateChannels(RTCP | RTCP_MUX, RTCP | RTCP_MUX);
     channel1_->ActivateRtcpMux();
     channel2_->ActivateRtcpMux();
     EXPECT_TRUE(SendInitiate());
-    EXPECT_EQ(1U, GetChannels1().size());
-    EXPECT_EQ(1U, GetChannels2().size());
+    ASSERT_TRUE(GetTransport1());
+    ASSERT_TRUE(GetTransport2());
+    EXPECT_EQ(1U, GetTransport1()->channels().size());
+    EXPECT_EQ(1U, GetTransport2()->channels().size());
     EXPECT_TRUE(SendAccept());
-    EXPECT_EQ(1U, GetChannels1().size());
+    EXPECT_EQ(1U, GetTransport1()->channels().size());
     SendRtp1();
     SendRtp2();
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
     EXPECT_TRUE(CheckRtcp1());
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Check that SendAccept fails if the answerer doesn't support mux
   // and the offerer requires it.
   void SendRequireRtcpMuxToNoRtcpMux() {
     CreateChannels(RTCP | RTCP_MUX, RTCP);
     channel1_->ActivateRtcpMux();
     EXPECT_TRUE(SendInitiate());
-    EXPECT_EQ(1U, GetChannels1().size());
-    EXPECT_EQ(2U, GetChannels2().size());
+    ASSERT_TRUE(GetTransport1());
+    ASSERT_TRUE(GetTransport2());
+    EXPECT_EQ(1U, GetTransport1()->channels().size());
+    EXPECT_EQ(2U, GetTransport2()->channels().size());
     EXPECT_FALSE(SendAccept());
   }
 
   // Check that RTCP data sent by the initiator before the accept is not muxed.
   void SendEarlyRtcpMuxToRtcp() {
     CreateChannels(RTCP | RTCP_MUX, RTCP);
     EXPECT_TRUE(SendInitiate());
-    EXPECT_EQ(2U, GetChannels1().size());
-    EXPECT_EQ(2U, GetChannels2().size());
+    ASSERT_TRUE(GetTransport1());
+    ASSERT_TRUE(GetTransport2());
+    EXPECT_EQ(2U, GetTransport1()->channels().size());
+    EXPECT_EQ(2U, GetTransport2()->channels().size());
 
     // RTCP can be sent before the call is accepted, if the transport is ready.
     // It should not be muxed though, as the remote side doesn't support mux.
     SendRtcp1();
     WaitForThreads();
     EXPECT_TRUE(CheckNoRtp2());
     EXPECT_TRUE(CheckRtcp2());
 
     // Send RTCP packet from callee and verify that it is received.
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckRtcp1());
 
     // Complete call setup and ensure everything is still OK.
     EXPECT_TRUE(SendAccept());
-    EXPECT_EQ(2U, GetChannels1().size());
+    EXPECT_EQ(2U, GetTransport1()->channels().size());
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckRtcp1());
   }
 
 
   // Check that RTCP data is not muxed until both sides have enabled muxing,
   // but that we properly demux before we get the accept message, since there
   // is a race between RTP data and the jingle accept.
   void SendEarlyRtcpMuxToRtcpMux() {
     CreateChannels(RTCP | RTCP_MUX, RTCP | RTCP_MUX);
     EXPECT_TRUE(SendInitiate());
-    EXPECT_EQ(2U, GetChannels1().size());
-    EXPECT_EQ(1U, GetChannels2().size());
+    ASSERT_TRUE(GetTransport1());
+    ASSERT_TRUE(GetTransport2());
+    EXPECT_EQ(2U, GetTransport1()->channels().size());
+    EXPECT_EQ(1U, GetTransport2()->channels().size());
 
     // RTCP can't be sent yet, since the RTCP transport isn't writable, and
     // we haven't yet received the accept that says we should mux.
     SendRtcp1();
     WaitForThreads();
     EXPECT_TRUE(CheckNoRtcp2());
 
     // Send muxed RTCP packet from callee and verify that it is received.
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckRtcp1());
 
     // Complete call setup and ensure everything is still OK.
     EXPECT_TRUE(SendAccept());
-    EXPECT_EQ(1U, GetChannels1().size());
+    EXPECT_EQ(1U, GetTransport1()->channels().size());
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckRtcp1());
   }
 
   // Test that we properly send SRTP with RTCP in both directions.
   // You can pass in DTLS and/or RTCP_MUX as flags.
   void SendSrtpToSrtp(int flags1_in = 0, int flags2_in = 0) {
@@ skipping 67 matching lines @@
   // sent and received. The test uses SRTP, RTCP mux and SSRC mux.
   void SendEarlyMediaUsingRtcpMuxSrtp() {
       int sequence_number1_1 = 0, sequence_number2_2 = 0;
 
       CreateChannels(SSRC_MUX | RTCP | RTCP_MUX | SECURE,
                      SSRC_MUX | RTCP | RTCP_MUX | SECURE);
       EXPECT_TRUE(SendOffer());
       EXPECT_TRUE(SendProvisionalAnswer());
       EXPECT_TRUE(channel1_->secure());
       EXPECT_TRUE(channel2_->secure());
-      EXPECT_EQ(2U, GetChannels1().size());
-      EXPECT_EQ(2U, GetChannels2().size());
+      ASSERT_TRUE(GetTransport1());
+      ASSERT_TRUE(GetTransport2());
+      EXPECT_EQ(2U, GetTransport1()->channels().size());
+      EXPECT_EQ(2U, GetTransport2()->channels().size());
       WaitForThreads();  // Wait for 'sending' flag go through network thread.
       SendCustomRtcp1(kSsrc1);
       SendCustomRtp1(kSsrc1, ++sequence_number1_1);
       WaitForThreads();
       EXPECT_TRUE(CheckCustomRtcp2(kSsrc1));
       EXPECT_TRUE(CheckCustomRtp2(kSsrc1, sequence_number1_1));
 
       // Send packets from callee and verify that it is received.
       SendCustomRtcp2(kSsrc2);
       SendCustomRtp2(kSsrc2, ++sequence_number2_2);
       WaitForThreads();
       EXPECT_TRUE(CheckCustomRtcp1(kSsrc2));
       EXPECT_TRUE(CheckCustomRtp1(kSsrc2, sequence_number2_2));
 
       // Complete call setup and ensure everything is still OK.
       EXPECT_TRUE(SendFinalAnswer());
-      EXPECT_EQ(1U, GetChannels1().size());
-      EXPECT_EQ(1U, GetChannels2().size());
+      EXPECT_EQ(1U, GetTransport1()->channels().size());
+      EXPECT_EQ(1U, GetTransport2()->channels().size());
       EXPECT_TRUE(channel1_->secure());
       EXPECT_TRUE(channel2_->secure());
       SendCustomRtcp1(kSsrc1);
       SendCustomRtp1(kSsrc1, ++sequence_number1_1);
       SendCustomRtcp2(kSsrc2);
       SendCustomRtp2(kSsrc2, ++sequence_number2_2);
       WaitForThreads();
       EXPECT_TRUE(CheckCustomRtcp2(kSsrc1));
       EXPECT_TRUE(CheckCustomRtp2(kSsrc1, sequence_number1_1));
       EXPECT_TRUE(CheckCustomRtcp1(kSsrc2));
@@ skipping 45 matching lines @@
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Test that the mediachannel retains its sending state after the transport
   // becomes non-writable.
   void SendWithWritabilityLoss() {
     CreateChannels(0, 0);
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
-    EXPECT_EQ(1U, GetChannels1().size());
-    EXPECT_EQ(1U, GetChannels2().size());
+    ASSERT_TRUE(GetTransport1());
+    ASSERT_TRUE(GetTransport2());
+    EXPECT_EQ(1U, GetTransport1()->channels().size());
+    EXPECT_EQ(1U, GetTransport2()->channels().size());
     SendRtp1();
     SendRtp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
 
     // Lose writability, which should fail.
     network_thread_->Invoke<void>(
-        RTC_FROM_HERE, [this] { GetFakeChannel1(1)->SetWritable(false); });
+        RTC_FROM_HERE, [this] { GetTransport1()->SetWritable(false); });
     SendRtp1();
     SendRtp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckNoRtp2());
 
     // Regain writability
     network_thread_->Invoke<void>(
-        RTC_FROM_HERE, [this] { GetFakeChannel1(1)->SetWritable(true); });
+        RTC_FROM_HERE, [this] { GetTransport1()->SetWritable(true); });
     EXPECT_TRUE(media_channel1_->sending());
     SendRtp1();
     SendRtp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
 
     // Lose writability completely
     network_thread_->Invoke<void>(
-        RTC_FROM_HERE, [this] { GetFakeChannel1(1)->SetDestination(nullptr); });
+        RTC_FROM_HERE, [this] { GetTransport1()->SetDestination(NULL); });
     EXPECT_TRUE(media_channel1_->sending());
 
     // Should fail also.
     SendRtp1();
     SendRtp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckNoRtp2());
 
     // Gain writability back
     network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
-      GetFakeChannel1(1)->SetDestination(GetFakeChannel2(1));
+      GetTransport1()->SetDestination(GetTransport2());
     });
     EXPECT_TRUE(media_channel1_->sending());
     SendRtp1();
     SendRtp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
   }
 
   void SendBundleToBundle(
       const int* pl_types, int len, bool rtcp_mux, bool secure) {
     ASSERT_EQ(2, len);
     int sequence_number1_1 = 0, sequence_number2_2 = 0;
     // Only pl_type1 was added to the bundle filter for both |channel1_|
     // and |channel2_|.
     int pl_type1 = pl_types[0];
     int pl_type2 = pl_types[1];
     int flags = SSRC_MUX | RTCP;
     if (secure) flags |= SECURE;
     uint32_t expected_channels = 2U;
     if (rtcp_mux) {
       flags |= RTCP_MUX;
       expected_channels = 1U;
     }
     CreateChannels(flags, flags);
     EXPECT_TRUE(SendInitiate());
-    EXPECT_EQ(2U, GetChannels1().size());
-    EXPECT_EQ(expected_channels, GetChannels2().size());
+    ASSERT_TRUE(GetTransport1());
+    ASSERT_TRUE(GetTransport2());
+    EXPECT_EQ(2U, GetTransport1()->channels().size());
+    EXPECT_EQ(expected_channels, GetTransport2()->channels().size());
     EXPECT_TRUE(SendAccept());
-    EXPECT_EQ(expected_channels, GetChannels1().size());
-    EXPECT_EQ(expected_channels, GetChannels2().size());
+    EXPECT_EQ(expected_channels, GetTransport1()->channels().size());
+    EXPECT_EQ(expected_channels, GetTransport2()->channels().size());
     EXPECT_TRUE(channel1_->bundle_filter()->FindPayloadType(pl_type1));
     EXPECT_TRUE(channel2_->bundle_filter()->FindPayloadType(pl_type1));
     EXPECT_FALSE(channel1_->bundle_filter()->FindPayloadType(pl_type2));
     EXPECT_FALSE(channel2_->bundle_filter()->FindPayloadType(pl_type2));
 
     // Both channels can receive pl_type1 only.
     SendCustomRtp1(kSsrc1, ++sequence_number1_1, pl_type1);
     SendCustomRtp2(kSsrc2, ++sequence_number2_2, pl_type1);
     WaitForThreads();
     EXPECT_TRUE(CheckCustomRtp2(kSsrc1, sequence_number1_1, pl_type1));
@@ skipping 159 matching lines @@
         sdesc3.get(), cricket::CA_ANSWER, &err));
     EXPECT_TRUE(media_channel1_->HasSendStream(1));
     EXPECT_FALSE(media_channel1_->HasRecvStream(2));
     EXPECT_TRUE(media_channel1_->HasRecvStream(3));
   }
 
   void TestFlushRtcp() {
     CreateChannels(RTCP, RTCP);
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
-    EXPECT_EQ(2U, GetChannels1().size());
-    EXPECT_EQ(2U, GetChannels2().size());
+    ASSERT_TRUE(GetTransport1());
+    ASSERT_TRUE(GetTransport2());
+    EXPECT_EQ(2U, GetTransport1()->channels().size());
+    EXPECT_EQ(2U, GetTransport2()->channels().size());
 
     // Send RTCP1 from a different thread.
     ScopedCallThread send_rtcp([this] { SendRtcp1(); });
     // The sending message is only posted.  channel2_ should be empty.
     EXPECT_TRUE(CheckNoRtcp2());
     rtc::Thread* wait_for[] = {send_rtcp.thread()};
     WaitForThreads(wait_for);  // Ensure rtcp was posted
 
     // When channel1_ is deleted, the RTCP packet should be sent out to
     // channel2_.
@@ skipping 1923 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?