Revert of TransportController refactoring.

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.
  */
 
 #include <set>
 
 #include "webrtc/p2p/base/dtlstransport.h"
-#include "webrtc/p2p/base/faketransportcontroller.h"
+#include "webrtc/p2p/base/fakesession.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/dscp.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/sslidentity.h"
 #include "webrtc/base/sslstreamadapter.h"
 #include "webrtc/base/stringutils.h"
+#include "webrtc/base/thread.h"
 
 #define MAYBE_SKIP_TEST(feature)                    \
   if (!(rtc::SSLStreamAdapter::feature())) {  \
     LOG(LS_INFO) << "Feature disabled... skipping"; \
     return;                                         \
   }
 
 static const char AES_CM_128_HMAC_SHA1_80[] = "AES_CM_128_HMAC_SHA1_80";
 static const char kIceUfrag1[] = "TESTICEUFRAG0001";
 static const char kIcePwd1[] = "TESTICEPWD00000000000001";
 static const size_t kPacketNumOffset = 8;
 static const size_t kPacketHeaderLen = 12;
 
 static bool IsRtpLeadByte(uint8 b) {
   return ((b & 0xC0) == 0x80);
 }
 
 using cricket::ConnectionRole;
 
 enum Flags { NF_REOFFER = 0x1, NF_EXPECT_FAILURE = 0x2 };
 
 class DtlsTestClient : public sigslot::has_slots<> {
  public:
-  DtlsTestClient(const std::string& name)
-      : name_(name),
-        packet_size_(0),
-        use_dtls_srtp_(false),
-        ssl_max_version_(rtc::SSL_PROTOCOL_DTLS_10),
-        negotiated_dtls_(false),
-        received_dtls_client_hello_(false),
-        received_dtls_server_hello_(false) {}
+  DtlsTestClient(const std::string& name,
+                 rtc::Thread* signaling_thread,
+                 rtc::Thread* worker_thread) :
+      name_(name),
+      signaling_thread_(signaling_thread),
+      worker_thread_(worker_thread),
+      packet_size_(0),
+      use_dtls_srtp_(false),
+      ssl_max_version_(rtc::SSL_PROTOCOL_DTLS_10),
+      negotiated_dtls_(false),
+      received_dtls_client_hello_(false),
+      received_dtls_server_hello_(false) {
+  }
   void CreateCertificate(rtc::KeyType key_type) {
     certificate_ = rtc::RTCCertificate::Create(
         rtc::scoped_ptr<rtc::SSLIdentity>(
             rtc::SSLIdentity::Generate(name_, key_type)).Pass());
   }
   const rtc::scoped_refptr<rtc::RTCCertificate>& certificate() {
     return certificate_;
   }
   void SetupSrtp() {
     ASSERT(certificate_);
     use_dtls_srtp_ = true;
   }
   void SetupMaxProtocolVersion(rtc::SSLProtocolVersion version) {
-    ASSERT(!transport_);
+    ASSERT(transport_.get() == NULL);
     ssl_max_version_ = version;
   }
   void SetupChannels(int count, cricket::IceRole role) {
     transport_.reset(new cricket::DtlsTransport<cricket::FakeTransport>(
-        "dtls content name", nullptr, certificate_));
+        signaling_thread_, worker_thread_, "dtls content name", nullptr,
+        certificate_));
     transport_->SetAsync(true);
     transport_->SetIceRole(role);
     transport_->SetIceTiebreaker(
         (role == cricket::ICEROLE_CONTROLLING) ? 1 : 2);
     transport_->SignalWritableState.connect(this,
         &DtlsTestClient::OnTransportWritableState);
 
     for (int i = 0; i < count; ++i) {
       cricket::DtlsTransportChannelWrapper* channel =
           static_cast<cricket::DtlsTransportChannelWrapper*>(
@@ skipping 20 matching lines @@
         static_cast<cricket::DtlsTransportChannelWrapper*>(ch);
     return (wrapper) ?
         static_cast<cricket::FakeTransportChannel*>(wrapper->channel()) : NULL;
   }
 
   // Offer DTLS if we have an identity; pass in a remote fingerprint only if
   // both sides support DTLS.
   void Negotiate(DtlsTestClient* peer, cricket::ContentAction action,
                  ConnectionRole local_role, ConnectionRole remote_role,
                  int flags) {
-    Negotiate(certificate_, certificate_ ? peer->certificate_ : nullptr, action,
-              local_role, remote_role, flags);
+    Negotiate(certificate_, certificate_ ? peer->certificate_ : nullptr,
+              action, local_role, remote_role, flags);
   }
 
   // Allow any DTLS configuration to be specified (including invalid ones).
   void Negotiate(const rtc::scoped_refptr<rtc::RTCCertificate>& local_cert,
                  const rtc::scoped_refptr<rtc::RTCCertificate>& remote_cert,
                  cricket::ContentAction action,
                  ConnectionRole local_role,
                  ConnectionRole remote_role,
                  int flags) {
     rtc::scoped_ptr<rtc::SSLFingerprint> local_fingerprint;
@@ skipping 23 matching lines @@
       // SRTP ciphers will be set only in the beginning.
       for (std::vector<cricket::DtlsTransportChannelWrapper*>::iterator it =
            channels_.begin(); it != channels_.end(); ++it) {
         std::vector<std::string> ciphers;
         ciphers.push_back(AES_CM_128_HMAC_SHA1_80);
         ASSERT_TRUE((*it)->SetSrtpCiphers(ciphers));
       }
     }
 
     cricket::TransportDescription local_desc(
-        std::vector<std::string>(), kIceUfrag1, kIcePwd1, cricket::ICEMODE_FULL,
-        local_role,
-        // If remote if the offerer and has no DTLS support, answer will be
+        std::vector<std::string>(), kIceUfrag1, kIcePwd1,
+        cricket::ICEMODE_FULL, local_role,
+         // If remote if the offerer and has no DTLS support, answer will be
         // without any fingerprint.
-        (action == cricket::CA_ANSWER && !remote_cert)
-            ? nullptr
-            : local_fingerprint.get(),
+        (action == cricket::CA_ANSWER && !remote_cert) ?
+            NULL : local_fingerprint.get(),
         cricket::Candidates());
 
     cricket::TransportDescription remote_desc(
-        std::vector<std::string>(), kIceUfrag1, kIcePwd1, cricket::ICEMODE_FULL,
-        remote_role, remote_fingerprint.get(), cricket::Candidates());
+        std::vector<std::string>(), kIceUfrag1, kIcePwd1,
+        cricket::ICEMODE_FULL, remote_role, remote_fingerprint.get(),
+        cricket::Candidates());
 
     bool expect_success = (flags & NF_EXPECT_FAILURE) ? false : true;
     // If |expect_success| is false, expect SRTD or SLTD to fail when
     // content action is CA_ANSWER.
     if (action == cricket::CA_OFFER) {
       ASSERT_TRUE(transport_->SetLocalTransportDescription(
           local_desc, cricket::CA_OFFER, NULL));
       ASSERT_EQ(expect_success, transport_->SetRemoteTransportDescription(
           remote_desc, cricket::CA_ANSWER, NULL));
     } else {
       ASSERT_TRUE(transport_->SetRemoteTransportDescription(
           remote_desc, cricket::CA_OFFER, NULL));
       ASSERT_EQ(expect_success, transport_->SetLocalTransportDescription(
           local_desc, cricket::CA_ANSWER, NULL));
     }
     negotiated_dtls_ = (local_cert && remote_cert);
   }
 
   bool Connect(DtlsTestClient* peer) {
     transport_->ConnectChannels();
     transport_->SetDestination(peer->transport_.get());
     return true;
   }
 
-  bool all_channels_writable() const {
-    return transport_->all_channels_writable();
-  }
+  bool writable() const { return transport_->writable(); }
 
   void CheckRole(rtc::SSLRole role) {
     if (role == rtc::SSL_CLIENT) {
       ASSERT_FALSE(received_dtls_client_hello_);
       ASSERT_TRUE(received_dtls_server_hello_);
     } else {
       ASSERT_TRUE(received_dtls_client_hello_);
       ASSERT_FALSE(received_dtls_server_hello_);
     }
   }
@@ skipping 117 matching lines @@
   }
 
   void OnTransportChannelReadPacket(cricket::TransportChannel* channel,
                                     const char* data, size_t size,
                                     const rtc::PacketTime& packet_time,
                                     int flags) {
     uint32 packet_num = 0;
     ASSERT_TRUE(VerifyPacket(data, size, &packet_num));
     received_.insert(packet_num);
     // Only DTLS-SRTP packets should have the bypass flag set.
-    int expected_flags =
-        (certificate_ && IsRtpLeadByte(data[0])) ? cricket::PF_SRTP_BYPASS : 0;
+    int expected_flags = (certificate_ && IsRtpLeadByte(data[0])) ?
+        cricket::PF_SRTP_BYPASS : 0;
     ASSERT_EQ(expected_flags, flags);
   }
 
   // Hook into the raw packet stream to make sure DTLS packets are encrypted.
   void OnFakeTransportChannelReadPacket(cricket::TransportChannel* channel,
                                         const char* data, size_t size,
                                         const rtc::PacketTime& time,
                                         int flags) {
     // Flags shouldn't be set on the underlying TransportChannel packets.
     ASSERT_EQ(0, flags);
@@ skipping 13 matching lines @@
           ASSERT_TRUE(VerifyEncryptedPacket(data, size));
         } else if (IsRtpLeadByte(data[0])) {
           ASSERT_TRUE(VerifyPacket(data, size, NULL));
         }
       }
     }
   }
 
  private:
   std::string name_;
+  rtc::Thread* signaling_thread_;
+  rtc::Thread* worker_thread_;
   rtc::scoped_refptr<rtc::RTCCertificate> certificate_;
   rtc::scoped_ptr<cricket::FakeTransport> transport_;
   std::vector<cricket::DtlsTransportChannelWrapper*> channels_;
   size_t packet_size_;
   std::set<int> received_;
   bool use_dtls_srtp_;
   rtc::SSLProtocolVersion ssl_max_version_;
   bool negotiated_dtls_;
   bool received_dtls_client_hello_;
   bool received_dtls_server_hello_;
 };
 
 
 class DtlsTransportChannelTest : public testing::Test {
  public:
-  DtlsTransportChannelTest()
-      : client1_("P1"),
-        client2_("P2"),
-        channel_ct_(1),
-        use_dtls_(false),
-        use_dtls_srtp_(false),
-        ssl_expected_version_(rtc::SSL_PROTOCOL_DTLS_10) {}
+  DtlsTransportChannelTest() :
+      client1_("P1", rtc::Thread::Current(),
+               rtc::Thread::Current()),
+      client2_("P2", rtc::Thread::Current(),
+               rtc::Thread::Current()),
+      channel_ct_(1),
+      use_dtls_(false),
+      use_dtls_srtp_(false),
+      ssl_expected_version_(rtc::SSL_PROTOCOL_DTLS_10) {
+  }
 
   void SetChannelCount(size_t channel_ct) {
     channel_ct_ = static_cast<int>(channel_ct);
   }
   void SetMaxProtocolVersions(rtc::SSLProtocolVersion c1,
                               rtc::SSLProtocolVersion c2) {
     client1_.SetupMaxProtocolVersion(c1);
     client2_.SetupMaxProtocolVersion(c2);
     ssl_expected_version_ = std::min(c1, c2);
   }
@@ skipping 21 matching lines @@
   }
 
   bool Connect(ConnectionRole client1_role, ConnectionRole client2_role) {
     Negotiate(client1_role, client2_role);
 
     bool rv = client1_.Connect(&client2_);
     EXPECT_TRUE(rv);
     if (!rv)
       return false;
 
-    EXPECT_TRUE_WAIT(
-        client1_.all_channels_writable() && client2_.all_channels_writable(),
-        10000);
-    if (!client1_.all_channels_writable() || !client2_.all_channels_writable())
+    EXPECT_TRUE_WAIT(client1_.writable() && client2_.writable(), 10000);
+    if (!client1_.writable() || !client2_.writable())
       return false;
 
     // Check that we used the right roles.
     if (use_dtls_) {
       rtc::SSLRole client1_ssl_role =
           (client1_role == cricket::CONNECTIONROLE_ACTIVE ||
            (client2_role == cricket::CONNECTIONROLE_PASSIVE &&
             client1_role == cricket::CONNECTIONROLE_ACTPASS)) ?
               rtc::SSL_CLIENT : rtc::SSL_SERVER;
 
@@ skipping 356 matching lines @@
   MAYBE_SKIP_TEST(HaveDtlsSrtp);
   SetChannelCount(2);
   PrepareDtls(true, true, rtc::KT_DEFAULT);
   PrepareDtlsSrtp(true, true);
   Negotiate();
 
   Renegotiate(&client1_, cricket::CONNECTIONROLE_ACTPASS,
               cricket::CONNECTIONROLE_ACTIVE, NF_REOFFER);
   bool rv = client1_.Connect(&client2_);
   EXPECT_TRUE(rv);
-  EXPECT_TRUE_WAIT(
-      client1_.all_channels_writable() && client2_.all_channels_writable(),
-      10000);
+  EXPECT_TRUE_WAIT(client1_.writable() && client2_.writable(), 10000);
 
   TestTransfer(0, 1000, 100, true);
   TestTransfer(1, 1000, 100, true);
 }
 
 // Test Certificates state after negotiation but before connection.
 TEST_F(DtlsTransportChannelTest, TestCertificatesBeforeConnect) {
   MAYBE_SKIP_TEST(HaveDtls);
   PrepareDtls(true, true, rtc::KT_DEFAULT);
   Negotiate();
 
   rtc::scoped_refptr<rtc::RTCCertificate> certificate1;
   rtc::scoped_refptr<rtc::RTCCertificate> certificate2;
   rtc::scoped_ptr<rtc::SSLCertificate> remote_cert1;
   rtc::scoped_ptr<rtc::SSLCertificate> remote_cert2;
 
   // After negotiation, each side has a distinct local certificate, but still no
   // remote certificate, because connection has not yet occurred.
-  ASSERT_TRUE(client1_.transport()->GetLocalCertificate(&certificate1));
-  ASSERT_TRUE(client2_.transport()->GetLocalCertificate(&certificate2));
+  ASSERT_TRUE(client1_.transport()->GetCertificate(&certificate1));
+  ASSERT_TRUE(client2_.transport()->GetCertificate(&certificate2));
   ASSERT_NE(certificate1->ssl_certificate().ToPEMString(),
             certificate2->ssl_certificate().ToPEMString());
   ASSERT_FALSE(
       client1_.transport()->GetRemoteSSLCertificate(remote_cert1.accept()));
   ASSERT_FALSE(remote_cert1 != NULL);
   ASSERT_FALSE(
       client2_.transport()->GetRemoteSSLCertificate(remote_cert2.accept()));
   ASSERT_FALSE(remote_cert2 != NULL);
 }
 
 // Test Certificates state after connection.
 TEST_F(DtlsTransportChannelTest, TestCertificatesAfterConnect) {
   MAYBE_SKIP_TEST(HaveDtls);
   PrepareDtls(true, true, rtc::KT_DEFAULT);
   ASSERT_TRUE(Connect());
 
   rtc::scoped_refptr<rtc::RTCCertificate> certificate1;
   rtc::scoped_refptr<rtc::RTCCertificate> certificate2;
   rtc::scoped_ptr<rtc::SSLCertificate> remote_cert1;
   rtc::scoped_ptr<rtc::SSLCertificate> remote_cert2;
 
   // After connection, each side has a distinct local certificate.
-  ASSERT_TRUE(client1_.transport()->GetLocalCertificate(&certificate1));
-  ASSERT_TRUE(client2_.transport()->GetLocalCertificate(&certificate2));
+  ASSERT_TRUE(client1_.transport()->GetCertificate(&certificate1));
+  ASSERT_TRUE(client2_.transport()->GetCertificate(&certificate2));
   ASSERT_NE(certificate1->ssl_certificate().ToPEMString(),
             certificate2->ssl_certificate().ToPEMString());
 
   // Each side's remote certificate is the other side's local certificate.
   ASSERT_TRUE(
       client1_.transport()->GetRemoteSSLCertificate(remote_cert1.accept()));
   ASSERT_EQ(remote_cert1->ToPEMString(),
             certificate2->ssl_certificate().ToPEMString());
   ASSERT_TRUE(
       client2_.transport()->GetRemoteSSLCertificate(remote_cert2.accept()));
   ASSERT_EQ(remote_cert2->ToPEMString(),
             certificate1->ssl_certificate().ToPEMString());
 }