Revert of Make P2PTransportChannel inherit from IceTransportInternal.

webrtc/p2p/base/dtlstransportchannel_unittest.cc

 /*
  *  Copyright 2011 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 70 matching lines @@
     ASSERT(certificate_);
     use_dtls_srtp_ = true;
   }
   void SetupMaxProtocolVersion(rtc::SSLProtocolVersion version) {
     ssl_max_version_ = version;
   }
   void SetupChannels(int count, cricket::IceRole role, int async_delay_ms = 0) {
     transport_.reset(
         new cricket::JsepTransport("dtls content name", certificate_));
     for (int i = 0; i < count; ++i) {
-      cricket::FakeIceTransport* fake_ice_channel =
-          new cricket::FakeIceTransport(transport_->mid(), i);
+      cricket::FakeTransportChannel* fake_ice_channel =
+          new cricket::FakeTransportChannel(transport_->mid(), i);
       fake_ice_channel->SetAsync(true);
       fake_ice_channel->SetAsyncDelay(async_delay_ms);
       // Hook the raw packets so that we can verify they are encrypted.
       fake_ice_channel->SignalReadPacket.connect(
           this, &DtlsTestClient::OnFakeTransportChannelReadPacket);
 
       cricket::DtlsTransportChannelWrapper* channel =
           new cricket::DtlsTransportChannelWrapper(fake_ice_channel);
       channel->SetLocalCertificate(certificate_);
       channel->SetIceRole(role);
       channel->SetIceTiebreaker((role == cricket::ICEROLE_CONTROLLING) ? 1 : 2);
       channel->SetSslMaxProtocolVersion(ssl_max_version_);
       channel->SignalWritableState.connect(this,
         &DtlsTestClient::OnTransportChannelWritableState);
       channel->SignalReadPacket.connect(this,
         &DtlsTestClient::OnTransportChannelReadPacket);
       channel->SignalSentPacket.connect(
           this, &DtlsTestClient::OnTransportChannelSentPacket);
       channels_.push_back(
           std::unique_ptr<cricket::DtlsTransportChannelWrapper>(channel));
       fake_channels_.push_back(
-          std::unique_ptr<cricket::FakeIceTransport>(fake_ice_channel));
+          std::unique_ptr<cricket::FakeTransportChannel>(fake_ice_channel));
       transport_->AddChannel(channel, i);
     }
   }
 
   cricket::JsepTransport* transport() { return transport_.get(); }
 
-  cricket::FakeIceTransport* GetFakeChannel(int component) {
+  cricket::FakeTransportChannel* GetFakeChannel(int component) {
     for (const auto& ch : fake_channels_) {
       if (ch->component() == component) {
         return ch.get();
       }
     }
     return nullptr;
   }
 
   cricket::DtlsTransportChannelWrapper* GetDtlsChannel(int component) {
     for (const auto& ch : channels_) {
@@ skipping 295 matching lines @@
         ASSERT_TRUE(VerifyEncryptedPacket(data, size));
       } else if (IsRtpLeadByte(data[0])) {
         ASSERT_TRUE(VerifyPacket(data, size, NULL));
       }
     }
   }
 
  private:
   std::string name_;
   rtc::scoped_refptr<rtc::RTCCertificate> certificate_;
-  std::vector<std::unique_ptr<cricket::FakeIceTransport>> fake_channels_;
+  std::vector<std::unique_ptr<cricket::FakeTransportChannel>> fake_channels_;
   std::vector<std::unique_ptr<cricket::DtlsTransportChannelWrapper>> channels_;
   std::unique_ptr<cricket::JsepTransport> transport_;
   size_t packet_size_ = 0u;
   std::set<int> received_;
   bool use_dtls_srtp_ = false;
   rtc::SSLProtocolVersion ssl_max_version_ = rtc::SSL_PROTOCOL_DTLS_12;
   int received_dtls_client_hellos_ = 0;
   int received_dtls_server_hellos_ = 0;
   rtc::SentPacket sent_packet_;
 };
@@ skipping 184 matching lines @@
   bool use_dtls_srtp_;
   rtc::SSLProtocolVersion ssl_expected_version_;
 };
 
 class DtlsTransportChannelTest : public DtlsTransportChannelTestBase,
                                  public ::testing::Test {};
 
 // Test that transport negotiation of ICE, no DTLS works properly.
 TEST_F(DtlsTransportChannelTest, TestChannelSetupIce) {
   Negotiate();
-  cricket::FakeIceTransport* channel1 = client1_.GetFakeChannel(0);
-  cricket::FakeIceTransport* channel2 = client2_.GetFakeChannel(0);
+  cricket::FakeTransportChannel* channel1 = client1_.GetFakeChannel(0);
+  cricket::FakeTransportChannel* channel2 = client2_.GetFakeChannel(0);
   ASSERT_TRUE(channel1 != NULL);
   ASSERT_TRUE(channel2 != NULL);
   EXPECT_EQ(cricket::ICEROLE_CONTROLLING, channel1->GetIceRole());
   EXPECT_EQ(1U, channel1->IceTiebreaker());
   EXPECT_EQ(kIceUfrag1, channel1->ice_ufrag());
   EXPECT_EQ(kIcePwd1, channel1->ice_pwd());
   EXPECT_EQ(cricket::ICEROLE_CONTROLLED, channel2->GetIceRole());
   EXPECT_EQ(2U, channel2->IceTiebreaker());
 }
 
@@ skipping 529 matching lines @@
             std::vector<DtlsTransportEvent>{
                 CALLER_RECEIVES_CLIENTHELLO, CALLER_RECEIVES_FINGERPRINT,
                 CALLER_WRITABLE, HANDSHAKE_FINISHES},
             std::vector<DtlsTransportEvent>{
                 CALLER_RECEIVES_CLIENTHELLO, CALLER_WRITABLE,
                 CALLER_RECEIVES_FINGERPRINT, HANDSHAKE_FINISHES},
             std::vector<DtlsTransportEvent>{CALLER_RECEIVES_CLIENTHELLO,
                                             CALLER_WRITABLE, HANDSHAKE_FINISHES,
                                             CALLER_RECEIVES_FINGERPRINT}),
         ::testing::Bool()));