Adding "adapter" ORTC objects on top of ChannelManager/BaseChannel/etc.

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 80 matching lines @@
 template<class T>
 class ChannelTest : public testing::Test, public sigslot::has_slots<> {
  public:
   enum Flags {
     RTCP_MUX = 0x1,
     RTCP_MUX_REQUIRED = 0x2,
     SECURE = 0x4,
     SSRC_MUX = 0x8,
     DTLS = 0x10,
     GCM_CIPHER = 0x20,
-    // Use BaseChannel with PacketTransportInterface rather than
+    // Use BaseChannel with PacketTransportInternal rather than
     // DtlsTransportInternal.
     RAW_PACKET_TRANSPORT = 0x40,
   };
 
   ChannelTest(bool verify_playout,
               rtc::ArrayView<const uint8_t> rtp_data,
               rtc::ArrayView<const uint8_t> rtcp_data,
               NetworkIsWorker network_is_worker)
       : verify_playout_(verify_playout),
         rtp_packet_(rtp_data.data(), rtp_data.size()),
@@ skipping 24 matching lines @@
     }
     // Make sure RTCP_MUX_REQUIRED isn't set without RTCP_MUX.
     RTC_DCHECK_NE(RTCP_MUX_REQUIRED, flags1 & (RTCP_MUX | RTCP_MUX_REQUIRED));
     RTC_DCHECK_NE(RTCP_MUX_REQUIRED, flags2 & (RTCP_MUX | RTCP_MUX_REQUIRED));
     // Make sure if using raw packet transports, they're used for both
     // channels.
     RTC_DCHECK_EQ(flags1 & RAW_PACKET_TRANSPORT, flags2 & RAW_PACKET_TRANSPORT);
     rtc::Thread* worker_thread = rtc::Thread::Current();
     media_channel1_ = ch1;
     media_channel2_ = ch2;
-    rtc::PacketTransportInterface* rtp1 = nullptr;
-    rtc::PacketTransportInterface* rtcp1 = nullptr;
-    rtc::PacketTransportInterface* rtp2 = nullptr;
-    rtc::PacketTransportInterface* rtcp2 = nullptr;
+    rtc::PacketTransportInternal* rtp1 = nullptr;
+    rtc::PacketTransportInternal* rtcp1 = nullptr;
+    rtc::PacketTransportInternal* rtp2 = nullptr;
+    rtc::PacketTransportInternal* rtcp2 = nullptr;
     // Based on flags, create fake DTLS or raw packet transports.
     if (flags1 & RAW_PACKET_TRANSPORT) {
       fake_rtp_packet_transport1_.reset(
           new rtc::FakePacketTransport("channel1_rtp"));
       rtp1 = fake_rtp_packet_transport1_.get();
       if (!(flags1 & RTCP_MUX_REQUIRED)) {
         fake_rtcp_packet_transport1_.reset(
             new rtc::FakePacketTransport("channel1_rtcp"));
         rtcp1 = fake_rtcp_packet_transport1_.get();
       }
@@ skipping 88 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::DtlsTransportInternal* fake_rtp_dtls_transport,
       cricket::DtlsTransportInternal* fake_rtcp_dtls_transport,
-      rtc::PacketTransportInterface* fake_rtp_packet_transport,
-      rtc::PacketTransportInterface* fake_rtcp_packet_transport,
+      rtc::PacketTransportInternal* fake_rtp_packet_transport,
+      rtc::PacketTransportInternal* fake_rtcp_packet_transport,
       int flags) {
     rtc::Thread* signaling_thread = rtc::Thread::Current();
     typename T::Channel* channel = new typename T::Channel(
         worker_thread, network_thread, signaling_thread, engine, ch,
         cricket::CN_AUDIO, (flags & RTCP_MUX_REQUIRED) != 0,
         (flags & SECURE) != 0);
     rtc::CryptoOptions crypto_options;
     crypto_options.enable_gcm_crypto_suites = (flags & GCM_CIPHER) != 0;
     channel->SetCryptoOptions(crypto_options);
     if (!channel->NeedsRtcpTransport()) {
@@ skipping 1835 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::DtlsTransportInternal* fake_rtp_dtls_transport,
     cricket::DtlsTransportInternal* fake_rtcp_dtls_transport,
-    rtc::PacketTransportInterface* fake_rtp_packet_transport,
-    rtc::PacketTransportInterface* fake_rtcp_packet_transport,
+    rtc::PacketTransportInternal* fake_rtp_packet_transport,
+    rtc::PacketTransportInternal* fake_rtcp_packet_transport,
     int flags) {
   rtc::Thread* signaling_thread = rtc::Thread::Current();
   cricket::VideoChannel* channel = new cricket::VideoChannel(
       worker_thread, network_thread, signaling_thread, ch, cricket::CN_VIDEO,
       (flags & RTCP_MUX_REQUIRED) != 0, (flags & SECURE) != 0);
   rtc::CryptoOptions crypto_options;
   crypto_options.enable_gcm_crypto_suites = (flags & GCM_CIPHER) != 0;
   channel->SetCryptoOptions(crypto_options);
   if (!channel->NeedsRtcpTransport()) {
     fake_rtcp_dtls_transport = nullptr;
@@ skipping 1216 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::DtlsTransportInternal* fake_rtp_dtls_transport,
     cricket::DtlsTransportInternal* fake_rtcp_dtls_transport,
-    rtc::PacketTransportInterface* fake_rtp_packet_transport,
-    rtc::PacketTransportInterface* fake_rtcp_packet_transport,
+    rtc::PacketTransportInternal* fake_rtp_packet_transport,
+    rtc::PacketTransportInternal* fake_rtcp_packet_transport,
     int flags) {
   rtc::Thread* signaling_thread = rtc::Thread::Current();
   cricket::RtpDataChannel* channel = new cricket::RtpDataChannel(
       worker_thread, network_thread, signaling_thread, ch, cricket::CN_DATA,
       (flags & RTCP_MUX_REQUIRED) != 0, (flags & SECURE) != 0);
   rtc::CryptoOptions crypto_options;
   crypto_options.enable_gcm_crypto_suites = (flags & GCM_CIPHER) != 0;
   channel->SetCryptoOptions(crypto_options);
   if (!channel->NeedsRtcpTransport()) {
     fake_rtcp_dtls_transport = nullptr;
@@ skipping 383 matching lines @@
   cricket::FakeDtlsTransport new_rtp_transport(
       "bar", cricket::ICE_CANDIDATE_COMPONENT_RTP);
   cricket::FakeDtlsTransport new_rtcp_transport(
       "baz", cricket::ICE_CANDIDATE_COMPONENT_RTCP);
   EXPECT_DEATH(
       voice_channel_.SetTransports(&new_rtp_transport, &new_rtcp_transport),
       "");
 }
 
 // Not expected to support going from DtlsTransportInternal to
-// PacketTransportInterface.
+// PacketTransportInternal.
 TEST_F(BaseChannelDeathTest, SetTransportsDtlsToNonDtls) {
   ASSERT_TRUE(voice_channel_.Init_w(
       &fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_,
       &fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_));
   EXPECT_DEATH(
-      voice_channel_.SetTransports(static_cast<rtc::PacketTransportInterface*>(
-                                       &fake_rtp_dtls_transport_),
-                                   static_cast<rtc::PacketTransportInterface*>(
-                                       &fake_rtp_dtls_transport_)),
+      voice_channel_.SetTransports(
+          static_cast<rtc::PacketTransportInternal*>(&fake_rtp_dtls_transport_),
+          static_cast<rtc::PacketTransportInternal*>(
+              &fake_rtp_dtls_transport_)),
       "");
 }
 
-// Not expected to support going from PacketTransportInterface to
+// Not expected to support going from PacketTransportInternal to
 // DtlsTransportInternal.
 TEST_F(BaseChannelDeathTest, SetTransportsNonDtlsToDtls) {
   ASSERT_TRUE(voice_channel_.Init_w(nullptr, nullptr, &fake_rtp_dtls_transport_,
                                     &fake_rtcp_dtls_transport_));
   EXPECT_DEATH(voice_channel_.SetTransports(&fake_rtp_dtls_transport_,
                                             &fake_rtp_dtls_transport_),
                "");
 }
 
 #endif  // RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
 
 // TODO(pthatcher): TestSetReceiver?