Remove the dependency of TransportChannel and TransportChannelImpl.

webrtc/media/sctp/sctptransport_unittest.cc

 /*
  *  Copyright (c) 2013 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 112 matching lines @@
 };
 
 // SCTP Data Engine testing framework.
 class SctpTransportTest : public testing::Test, public sigslot::has_slots<> {
  protected:
   // usrsctp uses the NSS random number generator on non-Android platforms,
   // so we need to initialize SSL.
   static void SetUpTestCase() {}
 
   void SetupConnectedTransportsWithTwoStreams() {
-    fake_dtls1_.reset(new FakeTransportChannel("fake dtls 1", 0));
-    fake_dtls2_.reset(new FakeTransportChannel("fake dtls 2", 0));
+    fake_dtls1_.reset(new FakeDtlsTransport("fake dtls 1", 0));
+    fake_dtls2_.reset(new FakeDtlsTransport("fake dtls 2", 0));
     recv1_.reset(new SctpFakeDataReceiver());
     recv2_.reset(new SctpFakeDataReceiver());
     transport1_.reset(CreateTransport(fake_dtls1_.get(), recv1_.get()));
     transport1_->set_debug_name_for_testing("transport1");
     transport1_->SignalReadyToSendData.connect(
         this, &SctpTransportTest::OnChan1ReadyToSend);
     transport2_.reset(CreateTransport(fake_dtls2_.get(), recv2_.get()));
     transport2_->set_debug_name_for_testing("transport2");
     transport2_->SignalReadyToSendData.connect(
         this, &SctpTransportTest::OnChan2ReadyToSend);
@@ skipping 12 matching lines @@
     transport2_->Start(kTransport2Port, kTransport1Port);
   }
 
   bool AddStream(int sid) {
     bool ret = true;
     ret = ret && transport1_->OpenStream(sid);
     ret = ret && transport2_->OpenStream(sid);
     return ret;
   }
 
-  SctpTransport* CreateTransport(FakeTransportChannel* fake_dtls,
+  SctpTransport* CreateTransport(FakeDtlsTransport* fake_dtls,
                                  SctpFakeDataReceiver* recv) {
     SctpTransport* transport =
         new SctpTransport(rtc::Thread::Current(), fake_dtls);
     // When data is received, pass it to the SctpFakeDataReceiver.
     transport->SignalDataReceived.connect(
         recv, &SctpFakeDataReceiver::OnDataReceived);
     return transport;
   }
 
   bool SendData(SctpTransport* chan,
@@ skipping 22 matching lines @@
         thread->Dispatch(&msg);
       }
     }
     return !thread->IsQuitting();
   }
 
   SctpTransport* transport1() { return transport1_.get(); }
   SctpTransport* transport2() { return transport2_.get(); }
   SctpFakeDataReceiver* receiver1() { return recv1_.get(); }
   SctpFakeDataReceiver* receiver2() { return recv2_.get(); }
-  FakeTransportChannel* fake_dtls1() { return fake_dtls1_.get(); }
-  FakeTransportChannel* fake_dtls2() { return fake_dtls2_.get(); }
+  FakeDtlsTransport* fake_dtls1() { return fake_dtls1_.get(); }
+  FakeDtlsTransport* fake_dtls2() { return fake_dtls2_.get(); }
 
   int transport1_ready_to_send_count() {
     return transport1_ready_to_send_count_;
   }
   int transport2_ready_to_send_count() {
     return transport2_ready_to_send_count_;
   }
 
  private:
-  std::unique_ptr<FakeTransportChannel> fake_dtls1_;
-  std::unique_ptr<FakeTransportChannel> fake_dtls2_;
+  std::unique_ptr<FakeDtlsTransport> fake_dtls1_;
+  std::unique_ptr<FakeDtlsTransport> fake_dtls2_;
   std::unique_ptr<SctpFakeDataReceiver> recv1_;
   std::unique_ptr<SctpFakeDataReceiver> recv2_;
   std::unique_ptr<SctpTransport> transport1_;
   std::unique_ptr<SctpTransport> transport2_;
 
   int transport1_ready_to_send_count_ = 0;
   int transport2_ready_to_send_count_ = 0;
 
   void OnChan1ReadyToSend() { ++transport1_ready_to_send_count_; }
   void OnChan2ReadyToSend() { ++transport2_ready_to_send_count_; }
 };
 
 // Test that data can be sent end-to-end when an SCTP transport starts with one
 // transport channel (which is unwritable), and then switches to another
 // channel. A common scenario due to how BUNDLE works.
 TEST_F(SctpTransportTest, SwitchTransportChannel) {
-  FakeTransportChannel black_hole("black hole", 0);
-  FakeTransportChannel fake_dtls1("fake dtls 1", 0);
-  FakeTransportChannel fake_dtls2("fake dtls 2", 0);
+  FakeDtlsTransport black_hole("black hole", 0);
+  FakeDtlsTransport fake_dtls1("fake dtls 1", 0);
+  FakeDtlsTransport fake_dtls2("fake dtls 2", 0);
   SctpFakeDataReceiver recv1;
   SctpFakeDataReceiver recv2;
 
   // Construct transport1 with the "black hole" channel.
   std::unique_ptr<SctpTransport> transport1(
       CreateTransport(&black_hole, &recv1));
   std::unique_ptr<SctpTransport> transport2(
       CreateTransport(&fake_dtls2, &recv2));
 
   // Add a stream.
@@ skipping 35 matching lines @@
 // Calling Start a second time with a different port should fail.
 TEST_F(SctpTransportTest, CallingStartWithDifferentPortFails) {
   SetupConnectedTransportsWithTwoStreams();
   EXPECT_FALSE(transport1()->Start(kTransport1Port, 1234));
   EXPECT_FALSE(transport1()->Start(1234, kTransport2Port));
 }
 
 // A value of -1 for the local/remote port should be treated as the default
 // (5000).
 TEST_F(SctpTransportTest, NegativeOnePortTreatedAsDefault) {
-  FakeTransportChannel fake_dtls1("fake dtls 1", 0);
-  FakeTransportChannel fake_dtls2("fake dtls 2", 0);
+  FakeDtlsTransport fake_dtls1("fake dtls 1", 0);
+  FakeDtlsTransport fake_dtls2("fake dtls 2", 0);
   SctpFakeDataReceiver recv1;
   SctpFakeDataReceiver recv2;
   std::unique_ptr<SctpTransport> transport1(
       CreateTransport(&fake_dtls1, &recv1));
   std::unique_ptr<SctpTransport> transport2(
       CreateTransport(&fake_dtls2, &recv2));
 
   // Add a stream.
   transport1->OpenStream(1);
   transport2->OpenStream(1);
 
   // Tell them both to start, giving one transport the default port and the
   // other transport -1.
   transport1->Start(kSctpDefaultPort, kSctpDefaultPort);
   transport2->Start(-1, -1);
 
   // Connect the two fake DTLS channels.
   bool asymmetric = false;
   fake_dtls1.SetDestination(&fake_dtls2, asymmetric);
 
   // Make sure we end up able to send data.
   SendDataResult result;
   ASSERT_TRUE(SendData(transport1.get(), 1, "foo", &result));
   ASSERT_TRUE(SendData(transport2.get(), 1, "bar", &result));
   EXPECT_TRUE_WAIT(ReceivedData(&recv2, 1, "foo"), kDefaultTimeout);
   EXPECT_TRUE_WAIT(ReceivedData(&recv1, 1, "bar"), kDefaultTimeout);
 }
 
 TEST_F(SctpTransportTest, OpenStreamWithAlreadyOpenedStreamFails) {
-  FakeTransportChannel fake_dtls("fake dtls", 0);
+  FakeDtlsTransport fake_dtls("fake dtls", 0);
   SctpFakeDataReceiver recv;
   std::unique_ptr<SctpTransport> transport(CreateTransport(&fake_dtls, &recv));
   EXPECT_TRUE(transport->OpenStream(1));
   EXPECT_FALSE(transport->OpenStream(1));
 }
 
 TEST_F(SctpTransportTest, ResetStreamWithAlreadyResetStreamFails) {
-  FakeTransportChannel fake_dtls("fake dtls", 0);
+  FakeDtlsTransport fake_dtls("fake dtls", 0);
   SctpFakeDataReceiver recv;
   std::unique_ptr<SctpTransport> transport(CreateTransport(&fake_dtls, &recv));
   EXPECT_TRUE(transport->OpenStream(1));
   EXPECT_TRUE(transport->ResetStream(1));
   EXPECT_FALSE(transport->ResetStream(1));
 }
 
 // Test that SignalReadyToSendData is fired after Start has been called and the
 // DTLS channel is writable.
 TEST_F(SctpTransportTest, SignalReadyToSendDataAfterDtlsWritable) {
-  FakeTransportChannel fake_dtls("fake dtls", 0);
+  FakeDtlsTransport fake_dtls("fake dtls", 0);
   SctpFakeDataReceiver recv;
   std::unique_ptr<SctpTransport> transport(CreateTransport(&fake_dtls, &recv));
 
   SignalReadyToSendObserver signal_observer;
   transport->SignalReadyToSendData.connect(
       &signal_observer, &SignalReadyToSendObserver::OnSignaled);
 
   transport->Start(kSctpDefaultPort, kSctpDefaultPort);
   fake_dtls.SetWritable(true);
   EXPECT_TRUE_WAIT(signal_observer.IsSignaled(), kDefaultTimeout);
@@ skipping 196 matching lines @@
   AddStream(1);
   ASSERT_TRUE(SendData(transport1(), 1, "hi?", &result));
   EXPECT_EQ(SDR_SUCCESS, result);
   EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hi?"), kDefaultTimeout);
   transport1()->ResetStream(1);
   EXPECT_TRUE_WAIT(transport2_sig_receiver.StreamCloseCount(1) == 2,
                    kDefaultTimeout);
 }
 
 }  // namespace cricket