Revert of Refactoring that removes P2PTransport and DtlsTransport classes.

webrtc/p2p/base/faketransportcontroller.h

 /*
  *  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.
  */
 
 #ifndef WEBRTC_P2P_BASE_FAKETRANSPORTCONTROLLER_H_
 #define WEBRTC_P2P_BASE_FAKETRANSPORTCONTROLLER_H_
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "webrtc/p2p/base/candidatepairinterface.h"
+#include "webrtc/p2p/base/transport.h"
 #include "webrtc/p2p/base/transportchannel.h"
 #include "webrtc/p2p/base/transportcontroller.h"
 #include "webrtc/p2p/base/transportchannelimpl.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/fakesslidentity.h"
 #include "webrtc/base/messagequeue.h"
 #include "webrtc/base/sigslot.h"
 #include "webrtc/base/sslfingerprint.h"
 #include "webrtc/base/thread.h"
 
 #ifdef HAVE_QUIC
 #include "webrtc/p2p/quic/quictransport.h"
 #endif
 
 namespace cricket {
 
+class FakeTransport;
+
 namespace {
 struct PacketMessageData : public rtc::MessageData {
   PacketMessageData(const char* data, size_t len) : packet(data, len) {}
   rtc::Buffer packet;
 };
 }  // namespace
 
 // Fake transport channel class, which can be passed to anything that needs a
 // transport channel. Can be informed of another FakeTransportChannel via
 // SetDestination.
@@ skipping 286 matching lines @@
   std::string remote_ice_pwd_;
   IceMode remote_ice_mode_ = ICEMODE_FULL;
   rtc::SSLProtocolVersion ssl_max_version_ = rtc::SSL_PROTOCOL_DTLS_12;
   rtc::SSLFingerprint dtls_fingerprint_;
   rtc::SSLRole ssl_role_ = rtc::SSL_CLIENT;
   size_t connection_count_ = 0;
   IceGatheringState gathering_state_ = kIceGatheringNew;
   bool had_connection_ = false;
 };
 
+// Fake transport class, which can be passed to anything that needs a Transport.
+// Can be informed of another FakeTransport via SetDestination (low-tech way
+// of doing candidates)
+class FakeTransport : public Transport {
+ public:
+  typedef std::map<int, FakeTransportChannel*> ChannelMap;
+
+  explicit FakeTransport(const std::string& name) : Transport(name, nullptr) {}
+
+  // Note that we only have a constructor with the allocator parameter so it can
+  // be wrapped by a DtlsTransport.
+  FakeTransport(const std::string& name, PortAllocator* allocator)
+      : Transport(name, nullptr) {}
+
+  ~FakeTransport() { DestroyAllChannels(); }
+
+  const ChannelMap& channels() const { return channels_; }
+
+  // If async, will send packets by "Post"-ing to message queue instead of
+  // synchronously "Send"-ing.
+  void SetAsync(bool async) { async_ = async; }
+  void SetAsyncDelay(int delay_ms) { async_delay_ms_ = delay_ms; }
+
+  // If |asymmetric| is true, only set the destination for this transport, and
+  // not |dest|.
+  void SetDestination(FakeTransport* dest, bool asymmetric = false) {
+    dest_ = dest;
+    for (const auto& kv : channels_) {
+      kv.second->SetLocalCertificate(certificate_);
+      SetChannelDestination(kv.first, kv.second, asymmetric);
+    }
+  }
+
+  void SetWritable(bool writable) {
+    for (const auto& kv : channels_) {
+      kv.second->SetWritable(writable);
+    }
+  }
+
+  void SetLocalCertificate(
+      const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) override {
+    certificate_ = certificate;
+  }
+  bool GetLocalCertificate(
+      rtc::scoped_refptr<rtc::RTCCertificate>* certificate) override {
+    if (!certificate_)
+      return false;
+
+    *certificate = certificate_;
+    return true;
+  }
+
+  bool GetSslRole(rtc::SSLRole* role) const override {
+    if (channels_.empty()) {
+      return false;
+    }
+    return channels_.begin()->second->GetSslRole(role);
+  }
+
+  bool SetSslMaxProtocolVersion(rtc::SSLProtocolVersion version) override {
+    ssl_max_version_ = version;
+    for (const auto& kv : channels_) {
+      kv.second->set_ssl_max_protocol_version(ssl_max_version_);
+    }
+    return true;
+  }
+  rtc::SSLProtocolVersion ssl_max_protocol_version() const {
+    return ssl_max_version_;
+  }
+
+  using Transport::local_description;
+  using Transport::remote_description;
+  using Transport::VerifyCertificateFingerprint;
+  using Transport::NegotiateRole;
+
+ protected:
+  TransportChannelImpl* CreateTransportChannel(int component) override {
+    if (channels_.find(component) != channels_.end()) {
+      return nullptr;
+    }
+    FakeTransportChannel* channel = new FakeTransportChannel(name(), component);
+    channel->set_ssl_max_protocol_version(ssl_max_version_);
+    channel->SetAsync(async_);
+    channel->SetAsyncDelay(async_delay_ms_);
+    SetChannelDestination(component, channel, false);
+    channels_[component] = channel;
+    return channel;
+  }
+
+  void DestroyTransportChannel(TransportChannelImpl* channel) override {
+    channels_.erase(channel->component());
+    delete channel;
+  }
+
+ private:
+  FakeTransportChannel* GetFakeChannel(int component) {
+    auto it = channels_.find(component);
+    return (it != channels_.end()) ? it->second : nullptr;
+  }
+
+  void SetChannelDestination(int component,
+                             FakeTransportChannel* channel,
+                             bool asymmetric) {
+    FakeTransportChannel* dest_channel = nullptr;
+    if (dest_) {
+      dest_channel = dest_->GetFakeChannel(component);
+      if (dest_channel && !asymmetric) {
+        dest_channel->SetLocalCertificate(dest_->certificate_);
+      }
+    }
+    channel->SetDestination(dest_channel, asymmetric);
+  }
+
+  // Note, this is distinct from the Channel map owned by Transport.
+  // This map just tracks the FakeTransportChannels created by this class.
+  // It's mainly needed so that we can access a FakeTransportChannel directly,
+  // even if wrapped by a DtlsTransportChannelWrapper.
+  ChannelMap channels_;
+  FakeTransport* dest_ = nullptr;
+  bool async_ = false;
+  int async_delay_ms_ = 0;
+  rtc::scoped_refptr<rtc::RTCCertificate> certificate_;
+  rtc::SSLProtocolVersion ssl_max_version_ = rtc::SSL_PROTOCOL_DTLS_12;
+};
+
+#ifdef HAVE_QUIC
+class FakeQuicTransport : public QuicTransport {
+ public:
+  FakeQuicTransport(const std::string& transport_name)
+      : QuicTransport(transport_name, nullptr, nullptr) {}
+
+ protected:
+  QuicTransportChannel* CreateTransportChannel(int component) override {
+    FakeTransportChannel* fake_ice_transport_channel =
+        new FakeTransportChannel(name(), component);
+    return new QuicTransportChannel(fake_ice_transport_channel);
+  }
+};
+#endif
+
 // Fake candidate pair class, which can be passed to BaseChannel for testing
 // purposes.
 class FakeCandidatePair : public CandidatePairInterface {
  public:
   FakeCandidatePair(const Candidate& local_candidate,
                     const Candidate& remote_candidate)
       : local_candidate_(local_candidate),
         remote_candidate_(remote_candidate) {}
   const Candidate& local_candidate() const override { return local_candidate_; }
   const Candidate& remote_candidate() const override {
     return remote_candidate_;
   }
 
  private:
   Candidate local_candidate_;
   Candidate remote_candidate_;
 };
 
 // Fake TransportController class, which can be passed into a BaseChannel object
 // for test purposes. Can be connected to other FakeTransportControllers via
 // Connect().
 //
 // This fake is unusual in that for the most part, it's implemented with the
 // real TransportController code, but with fake TransportChannels underneath.
 class FakeTransportController : public TransportController {
  public:
   FakeTransportController()
       : TransportController(rtc::Thread::Current(),
                             rtc::Thread::Current(),
-                            nullptr) {}
+                            nullptr),
+        fail_create_channel_(false) {}
 
   explicit FakeTransportController(bool redetermine_role_on_ice_restart)
       : TransportController(rtc::Thread::Current(),
                             rtc::Thread::Current(),
                             nullptr,
-                            redetermine_role_on_ice_restart) {}
+                            redetermine_role_on_ice_restart),
+        fail_create_channel_(false) {}
 
   explicit FakeTransportController(IceRole role)
       : TransportController(rtc::Thread::Current(),
                             rtc::Thread::Current(),
-                            nullptr) {
+                            nullptr),
+        fail_create_channel_(false) {
     SetIceRole(role);
   }
 
   explicit FakeTransportController(rtc::Thread* network_thread)
-      : TransportController(rtc::Thread::Current(), network_thread, nullptr) {}
+      : TransportController(rtc::Thread::Current(), network_thread, nullptr),
+        fail_create_channel_(false) {}
 
   FakeTransportController(rtc::Thread* network_thread, IceRole role)
-      : TransportController(rtc::Thread::Current(), network_thread, nullptr) {
+      : TransportController(rtc::Thread::Current(), network_thread, nullptr),
+        fail_create_channel_(false) {
     SetIceRole(role);
   }
 
-  FakeTransportChannel* GetFakeTransportChannel_n(
-      const std::string& transport_name,
-      int component) {
-    return static_cast<FakeTransportChannel*>(
-        get_channel_for_testing(transport_name, component));
+  FakeTransport* GetTransport_n(const std::string& transport_name) {
+    return static_cast<FakeTransport*>(
+        TransportController::GetTransport_n(transport_name));
   }
 
-  // Simulate the exchange of transport descriptions, and the gathering and
-  // exchange of ICE candidates.
   void Connect(FakeTransportController* dest) {
-    for (const std::string& transport_name : transport_names_for_testing()) {
-      TransportDescription local_desc(
-          std::vector<std::string>(),
-          rtc::CreateRandomString(cricket::ICE_UFRAG_LENGTH),
-          rtc::CreateRandomString(cricket::ICE_PWD_LENGTH),
-          cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_NONE, nullptr);
-      TransportDescription remote_desc(
-          std::vector<std::string>(),
-          rtc::CreateRandomString(cricket::ICE_UFRAG_LENGTH),
-          rtc::CreateRandomString(cricket::ICE_PWD_LENGTH),
-          cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_NONE, nullptr);
-      std::string err;
-      SetLocalTransportDescription(transport_name, local_desc,
-                                   cricket::CA_OFFER, &err);
-      dest->SetRemoteTransportDescription(transport_name, local_desc,
-                                          cricket::CA_OFFER, &err);
-      dest->SetLocalTransportDescription(transport_name, remote_desc,
-                                         cricket::CA_ANSWER, &err);
-      SetRemoteTransportDescription(transport_name, remote_desc,
-                                    cricket::CA_ANSWER, &err);
-    }
-    MaybeStartGathering();
-    dest->MaybeStartGathering();
     network_thread()->Invoke<void>(
         RTC_FROM_HERE,
-        rtc::Bind(&FakeTransportController::SetChannelDestinations_n, this,
-                  dest));
+        rtc::Bind(&FakeTransportController::Connect_n, this, dest));
+  }
+
+  TransportChannel* CreateTransportChannel_n(const std::string& transport_name,
+                                             int component) override {
+    if (fail_create_channel_) {
+      return nullptr;
+    }
+    return TransportController::CreateTransportChannel_n(transport_name,
+                                                         component);
   }
 
   FakeCandidatePair* CreateFakeCandidatePair(
       const rtc::SocketAddress& local_address,
       int16_t local_network_id,
       const rtc::SocketAddress& remote_address,
       int16_t remote_network_id) {
     Candidate local_candidate(0, "udp", local_address, 0u, "", "", "local", 0,
                               "foundation", local_network_id, 0);
     Candidate remote_candidate(0, "udp", remote_address, 0u, "", "", "local", 0,
                                "foundation", remote_network_id, 0);
     return new FakeCandidatePair(local_candidate, remote_candidate);
   }
 
- protected:
-  // The ICE channel is never actually used by TransportController directly,
-  // since (currently) the DTLS channel pretends to be both ICE + DTLS. This
-  // will change when we get rid of TransportChannelImpl.
-  TransportChannelImpl* CreateIceTransportChannel_n(
-      const std::string& transport_name,
-      int component) override {
-    return nullptr;
+  void set_fail_channel_creation(bool fail_channel_creation) {
+    fail_create_channel_ = fail_channel_creation;
   }
 
-  TransportChannelImpl* CreateDtlsTransportChannel_n(
-      const std::string& transport_name,
-      int component,
-      TransportChannelImpl*) override {
-    return new FakeTransportChannel(transport_name, component);
+ protected:
+  Transport* CreateTransport_n(const std::string& transport_name) override {
+#ifdef HAVE_QUIC
+    if (quic()) {
+      return new FakeQuicTransport(transport_name);
+    }
+#endif
+    return new FakeTransport(transport_name);
+  }
+
+  void Connect_n(FakeTransportController* dest) {
+    // Simulate the exchange of candidates.
+    ConnectChannels_n();
+    dest->ConnectChannels_n();
+    for (auto& kv : transports()) {
+      FakeTransport* transport = static_cast<FakeTransport*>(kv.second);
+      transport->SetDestination(dest->GetTransport_n(kv.first));
+    }
+  }
+
+  void ConnectChannels_n() {
+    TransportDescription faketransport_desc(
+        std::vector<std::string>(),
+        rtc::CreateRandomString(cricket::ICE_UFRAG_LENGTH),
+        rtc::CreateRandomString(cricket::ICE_PWD_LENGTH), cricket::ICEMODE_FULL,
+        cricket::CONNECTIONROLE_NONE, nullptr);
+    for (auto& kv : transports()) {
+      FakeTransport* transport = static_cast<FakeTransport*>(kv.second);
+      // Set local transport description for FakeTransport before connecting.
+      // Otherwise, the RTC_CHECK in Transport.ConnectChannel will fail.
+      if (!transport->local_description()) {
+        transport->SetLocalTransportDescription(faketransport_desc,
+                                                cricket::CA_OFFER, nullptr);
+      }
+      transport->MaybeStartGathering();
+    }
   }
 
  private:
-  void SetChannelDestinations_n(FakeTransportController* dest) {
-    for (TransportChannelImpl* tc : channels_for_testing()) {
-      FakeTransportChannel* local = static_cast<FakeTransportChannel*>(tc);
-      FakeTransportChannel* remote = dest->GetFakeTransportChannel_n(
-          local->transport_name(), local->component());
-      if (remote) {
-        bool asymmetric = false;
-        local->SetDestination(remote, asymmetric);
-      }
-    }
-  }
+  bool fail_create_channel_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_FAKETRANSPORTCONTROLLER_H_