Remove the dependency of TransportChannel and TransportChannelImpl.

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 78 matching lines @@
         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);
       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);
+      cricket::DtlsTransport* channel =
+          new cricket::DtlsTransport(fake_ice_channel);
       channel->SetLocalCertificate(certificate_);
-      channel->SetIceRole(role);
-      channel->SetIceTiebreaker((role == cricket::ICEROLE_CONTROLLING) ? 1 : 2);
+      channel->ice_transport()->SetIceRole(role);
+      channel->ice_transport()->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));
+      channels_.push_back(std::unique_ptr<cricket::DtlsTransport>(channel));
       fake_channels_.push_back(
           std::unique_ptr<cricket::FakeIceTransport>(fake_ice_channel));
       transport_->AddChannel(channel, i);
     }
   }
 
   cricket::JsepTransport* transport() { return transport_.get(); }
 
   cricket::FakeIceTransport* GetFakeChannel(int component) {
     for (const auto& ch : fake_channels_) {
       if (ch->component() == component) {
         return ch.get();
       }
     }
     return nullptr;
   }
 
-  cricket::DtlsTransportChannelWrapper* GetDtlsChannel(int component) {
+  cricket::DtlsTransport* GetDtlsChannel(int component) {
     for (const auto& ch : channels_) {
       if (ch->component() == component) {
         return ch.get();
       }
     }
     return nullptr;
   }
 
   // Offer DTLS if we have an identity; pass in a remote fingerprint only if
   // both sides support DTLS.
@@ skipping 83 matching lines @@
       return false;
     }
     for (const auto& channel : channels_) {
       if (!channel->writable()) {
         return false;
       }
     }
     return true;
   }
 
-  bool all_raw_channels_writable() const {
+  bool all_ice_transport_writable() const {

[pthatcher1, 2017/01/17 20:16:48]

all_ice_transports_writable()

     if (channels_.empty()) {
       return false;
     }
     for (const auto& channel : channels_) {

[pthatcher1, 2017/01/17 20:16:48]

transport : transports_

-      if (!channel->channel()->writable()) {
+      if (!channel->ice_transport()->writable()) {
         return false;
       }
     }
     return true;
   }
 
   int received_dtls_client_hellos() const {
     return received_dtls_client_hellos_;
   }
 
@@ skipping 178 matching lines @@
       } 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::DtlsTransportChannelWrapper>> channels_;
+  std::vector<std::unique_ptr<cricket::DtlsTransport>> 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 537 matching lines @@
   // BoringSSL API. Skip the test if not built with BoringSSL.
   MAYBE_SKIP_TEST(IsBoringSsl);
 
   PrepareDtls(true, true, rtc::KT_DEFAULT);
   // Exchange transport descriptions.
   Negotiate(cricket::CONNECTIONROLE_ACTPASS, cricket::CONNECTIONROLE_ACTIVE);
 
   // Make client2_ writable, but not client1_.
   // This means client1_ will send DTLS client hellos but get no response.
   EXPECT_TRUE(client2_.Connect(&client1_, true));
-  EXPECT_TRUE_SIMULATED_WAIT(client2_.all_raw_channels_writable(), kTimeout,
+  EXPECT_TRUE_SIMULATED_WAIT(client2_.all_ice_transport_writable(), kTimeout,
                              fake_clock_);
 
   // Wait for the first client hello to be sent.
   EXPECT_EQ_WAIT(1, client1_.received_dtls_client_hellos(), kTimeout);
-  EXPECT_FALSE(client1_.all_raw_channels_writable());
+  EXPECT_FALSE(client1_.all_ice_transport_writable());
 
   static int timeout_schedule_ms[] = {50,   100,  200,   400,   800,   1600,
                                       3200, 6400, 12800, 25600, 51200, 60000};
 
   int expected_hellos = 1;
   for (size_t i = 0;
        i < (sizeof(timeout_schedule_ms) / sizeof(timeout_schedule_ms[0]));
        ++i) {
     // For each expected retransmission time, advance the fake clock a
     // millisecond before the expected time and verify that no unexpected
@@ skipping 84 matching lines @@
             ++(remote_desc.identity_fingerprint->digest[0]);
             // Even if certificate verification fails inside this method,
             // it should return true as long as the fingerprint was formatted
             // correctly.
             EXPECT_TRUE(client1_.transport()->SetRemoteTransportDescription(
                 remote_desc, cricket::CA_ANSWER, nullptr));
           }
           break;
         case CALLER_WRITABLE:
           EXPECT_TRUE(client1_.Connect(&client2_, true));
-          EXPECT_TRUE_SIMULATED_WAIT(client1_.all_raw_channels_writable(),
+          EXPECT_TRUE_SIMULATED_WAIT(client1_.all_ice_transport_writable(),
                                      kTimeout, fake_clock_);
           break;
         case CALLER_RECEIVES_CLIENTHELLO:
           // Sanity check that a ClientHello hasn't already been received.
           EXPECT_EQ(0, client1_.received_dtls_client_hellos());
           // Making client2_ writable will cause it to send the ClientHello.
           EXPECT_TRUE(client2_.Connect(&client1_, true));
-          EXPECT_TRUE_SIMULATED_WAIT(client2_.all_raw_channels_writable(),
+          EXPECT_TRUE_SIMULATED_WAIT(client2_.all_ice_transport_writable(),
                                      kTimeout, fake_clock_);
           EXPECT_EQ_SIMULATED_WAIT(1, client1_.received_dtls_client_hellos(),
                                    kTimeout, fake_clock_);
           break;
         case HANDSHAKE_FINISHES:
           // Sanity check that the handshake hasn't already finished.
           EXPECT_FALSE(client1_.GetDtlsChannel(0)->IsDtlsConnected() ||
                        client1_.GetDtlsChannel(0)->dtls_state() ==
                            cricket::DTLS_TRANSPORT_FAILED);
           EXPECT_TRUE_SIMULATED_WAIT(
@@ skipping 58 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()));