Remove the dependency of TransportChannel and TransportChannelImpl.

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/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"
+#include "webrtc/p2p/base/candidatepairinterface.h"
+#include "webrtc/p2p/base/dtlstransportinternal.h"
+#include "webrtc/p2p/base/transportchannel.h"
+#include "webrtc/p2p/base/transportcontroller.h"
+#include "webrtc/p2p/base/transportchannelimpl.h"
 
 #ifdef HAVE_QUIC
 #include "webrtc/p2p/quic/quictransport.h"
 #endif
 
 namespace cricket {
 
 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.
 // TODO(hbos): Move implementation to .cc file, this and other classes in file.
 class FakeTransportChannel : public TransportChannelImpl,

[Taylor Brandstetter, 2017/01/03 23:21:59]

Should this be renamed to FakeIceTransport, and inherit from
IceTransportInternal? Then we could remove some of the code here that's
duplicated in FakeDtlsTransport.

[Zhi Huang, 2017/01/10 18:30:51]

Done.

                              public rtc::MessageHandler {
  public:
   explicit FakeTransportChannel(const std::string& name, int component)
       : TransportChannelImpl(name, component),
         dtls_fingerprint_("", nullptr, 0) {}
   ~FakeTransportChannel() { Reset(); }
 
   uint64_t IceTiebreaker() const { return tiebreaker_; }
   IceMode remote_ice_mode() const { return remote_ice_mode_; }
   const std::string& ice_ufrag() const { return ice_ufrag_; }
@@ skipping 274 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;
 };
 
+class FakeDtlsTransport : public DtlsTransportInternal,
+                          public rtc::MessageHandler {
+ public:
+  FakeDtlsTransport(FakeTransportChannel* ice_transport)
+      : ice_transport_(ice_transport),
+        transport_name_(ice_transport->transport_name()),
+        component_(ice_transport->component()),
+        dtls_fingerprint_("", nullptr, 0) {}
+  ~FakeDtlsTransport() { Reset(); }
+
+  uint64_t IceTiebreaker() const { return ice_transport_->IceTiebreaker(); }
+  IceMode remote_ice_mode() const { return ice_transport_->remote_ice_mode(); }
+  const std::string& ice_ufrag() const { return ice_transport_->ice_ufrag(); }
+  const std::string& ice_pwd() const { return ice_transport_->ice_pwd(); }
+  const std::string& remote_ice_ufrag() const {
+    return ice_transport_->remote_ice_ufrag();
+  }
+  const std::string& remote_ice_pwd() const {
+    return ice_transport_->remote_ice_pwd();
+  }
+
+  DtlsTransportState dtls_state() const override { return dtls_state_; }
+
+  const std::string& transport_name() const override { return transport_name_; }
+
+  int component() const override { return component_; }
+
+  const rtc::SSLFingerprint& dtls_fingerprint() const {
+    return dtls_fingerprint_;
+  }
+
+  // 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; }

[Taylor Brandstetter, 2017/01/03 23:21:59]

I think the async settings only need to go in one place (the fake ICE channel?).

[Zhi Huang, 2017/01/10 18:30:51]

I'll clean up the duplication when merging the two changes.

+
+  IceRole GetIceRole() const { return ice_transport_->GetIceRole(); }
+
+  bool SetRemoteFingerprint(const std::string& alg,
+                            const uint8_t* digest,
+                            size_t digest_len) override {
+    dtls_fingerprint_ = rtc::SSLFingerprint(alg, digest, digest_len);
+    return true;
+  }
+
+  bool SetSslRole(rtc::SSLRole role) override {
+    ssl_role_ = role;
+    return true;
+  }
+
+  bool GetSslRole(rtc::SSLRole* role) const override {
+    *role = ssl_role_;
+    return true;
+  }
+
+  IceGatheringState gathering_state() const {
+    return ice_transport_->gathering_state();
+  }
+
+  void Reset() {
+    if (state_ != STATE_INIT) {
+      state_ = STATE_INIT;
+      if (dest_) {
+        dest_->state_ = STATE_INIT;
+        dest_->dest_ = nullptr;
+        dest_ = nullptr;
+      }
+    }
+  }
+
+  void SetWritable(bool writable) {
+    ice_transport_->SetWritable(writable);
+    SignalWritableState(this);
+  }
+
+  // Simulates the two transport channels connecting to each other.
+  // If |asymmetric| is true this method only affects this FakeDtlsTransport.
+  // If false, it affects |dest| as well.
+  void SetDestination(FakeDtlsTransport* dest, bool asymmetric = false) {
+    if (state_ == STATE_INIT && dest) {
+      // This simulates the delivery of candidates.
+      dest_ = dest;
+      if (local_cert_ && dest_->local_cert_) {
+        do_dtls_ = true;
+        NegotiateSrtpCiphers();
+      }
+      state_ = STATE_CONNECTED;
+      SetWritable(true);
+      if (!asymmetric) {
+        dest->SetDestination(this, true);
+      }
+    } else if (state_ == STATE_CONNECTED && !dest) {
+      // Simulates loss of connectivity, by asymmetrically forgetting dest_.
+      dest_ = nullptr;
+      state_ = STATE_INIT;
+      SetWritable(false);
+    }
+  }
+
+  void SetConnectionCount(size_t connection_count) {
+    ice_transport_->SetConnectionCount(connection_count);
+  }
+
+  void SetCandidatesGatheringComplete() {
+    ice_transport_->SetCandidatesGatheringComplete();
+  }
+
+  void SetReceiving(bool receiving) {
+    ice_transport_->SetReceiving(receiving);
+    SignalReceivingState(this);
+  }
+
+  int receiving_timeout() const { return ice_transport_->receiving_timeout(); }
+  bool gather_continually() const {
+    return ice_transport_->gather_continually();
+  }
+
+  int SendPacket(const char* data,
+                 size_t len,
+                 const rtc::PacketOptions& options,
+                 int flags) override {
+    if (state_ != STATE_CONNECTED) {
+      return -1;
+    }
+
+    if (flags != PF_SRTP_BYPASS && flags != 0) {
+      return -1;
+    }
+

[Taylor Brandstetter, 2017/01/03 23:21:59]

Can this just call ice_transport_->SendPacket, and listen SignalReadPacket on
ice_transport_?

[Zhi Huang, 2017/01/10 18:30:51]

Done.

+    PacketMessageData* packet = new PacketMessageData(data, len);
+    if (async_) {
+      if (async_delay_ms_) {
+        rtc::Thread::Current()->PostDelayed(RTC_FROM_HERE, async_delay_ms_,
+                                            this, 0, packet);
+      } else {
+        rtc::Thread::Current()->Post(RTC_FROM_HERE, this, 0, packet);
+      }
+    } else {
+      rtc::Thread::Current()->Send(RTC_FROM_HERE, this, 0, packet);
+    }
+    rtc::SentPacket sent_packet(options.packet_id, rtc::TimeMillis());
+    SignalSentPacket(this, sent_packet);
+    return static_cast<int>(len);
+  }
+
+  bool GetOption(rtc::Socket::Option opt, int* value) override { return true; }
+
+  const Candidates& remote_candidates() const {
+    return ice_transport_->remote_candidates();
+  }
+
+  void OnMessage(rtc::Message* msg) override {
+    PacketMessageData* data = static_cast<PacketMessageData*>(msg->pdata);
+    dest_->SignalReadPacket(dest_, data->packet.data<char>(),
+                            data->packet.size(), rtc::CreatePacketTime(0), 0);
+    delete data;
+  }
+
+  bool SetLocalCertificate(
+      const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) override {
+    local_cert_ = certificate;
+    return true;
+  }
+
+  void SetRemoteSSLCertificate(rtc::FakeSSLCertificate* cert) {
+    remote_cert_ = cert;
+  }
+
+  bool IsDtlsActive() const override { return do_dtls_; }
+
+  bool SetSrtpCryptoSuites(const std::vector<int>& ciphers) override {
+    srtp_ciphers_ = ciphers;
+    return true;
+  }
+
+  bool GetSrtpCryptoSuite(int* crypto_suite) override {
+    if (chosen_crypto_suite_ != rtc::SRTP_INVALID_CRYPTO_SUITE) {
+      *crypto_suite = chosen_crypto_suite_;
+      return true;
+    }
+    return false;
+  }
+
+  bool GetSslCipherSuite(int* cipher_suite) override { return false; }
+
+  rtc::scoped_refptr<rtc::RTCCertificate> GetLocalCertificate() const override {
+    return local_cert_;
+  }
+
+  std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate()
+      const override {
+    return remote_cert_ ? std::unique_ptr<rtc::SSLCertificate>(
+                              remote_cert_->GetReference())
+                        : nullptr;
+  }
+
+  bool ExportKeyingMaterial(const std::string& label,
+                            const uint8_t* context,
+                            size_t context_len,
+                            bool use_context,
+                            uint8_t* result,
+                            size_t result_len) override {
+    if (chosen_crypto_suite_ != rtc::SRTP_INVALID_CRYPTO_SUITE) {
+      memset(result, 0xff, result_len);
+      return true;
+    }
+
+    return false;
+  }
+
+  void set_ssl_max_protocol_version(rtc::SSLProtocolVersion version) {
+    ssl_max_version_ = version;
+  }
+  rtc::SSLProtocolVersion ssl_max_protocol_version() const {
+    return ssl_max_version_;
+  }
+
+  TransportChannelImpl* ice_transport() override { return ice_transport_; }
+
+  bool writable() const override { return ice_transport_->writable(); }
+
+  bool receiving() const override { return ice_transport_->receiving(); }
+
+  int GetError() override { return ice_transport_->GetError(); }
+
+  int SetOption(rtc::Socket::Option opt, int value) override {
+    return ice_transport_->SetOption(opt, value);
+  }
+
+  bool SetSrtpCiphers(const std::vector<std::string>& ciphers) override {
+    std::vector<int> crypto_suites;
+    for (const auto cipher : ciphers) {
+      crypto_suites.push_back(rtc::SrtpCryptoSuiteFromName(cipher));
+    }
+    return SetSrtpCryptoSuites(crypto_suites);
+  }
+
+ private:
+  void NegotiateSrtpCiphers() {
+    for (std::vector<int>::const_iterator it1 = srtp_ciphers_.begin();
+         it1 != srtp_ciphers_.end(); ++it1) {
+      for (std::vector<int>::const_iterator it2 = dest_->srtp_ciphers_.begin();
+           it2 != dest_->srtp_ciphers_.end(); ++it2) {
+        if (*it1 == *it2) {
+          chosen_crypto_suite_ = *it1;
+          return;
+        }
+      }
+    }
+  }
+
+  enum State { STATE_INIT, STATE_CONNECTED };
+  FakeTransportChannel* ice_transport_;
+  std::string transport_name_;
+  int component_;
+  FakeDtlsTransport* dest_ = nullptr;
+  State state_ = STATE_INIT;
+  bool async_ = false;
+  int async_delay_ms_ = 0;
+  Candidates remote_candidates_;
+  rtc::scoped_refptr<rtc::RTCCertificate> local_cert_;
+  rtc::FakeSSLCertificate* remote_cert_ = nullptr;
+  bool do_dtls_ = false;
+  std::vector<int> srtp_ciphers_;
+  int chosen_crypto_suite_ = rtc::SRTP_INVALID_CRYPTO_SUITE;
+  rtc::SSLProtocolVersion ssl_max_version_ = rtc::SSL_PROTOCOL_DTLS_12;
+  rtc::SSLFingerprint dtls_fingerprint_;
+  rtc::SSLRole ssl_role_ = rtc::SSL_CLIENT;
+
+  DtlsTransportState dtls_state_ = DTLS_TRANSPORT_NEW;
+};
+
 // 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 {
@@ skipping 32 matching lines @@
   }
 
   explicit FakeTransportController(rtc::Thread* network_thread)
       : TransportController(rtc::Thread::Current(), network_thread, nullptr) {}
 
   FakeTransportController(rtc::Thread* network_thread, IceRole role)
       : TransportController(rtc::Thread::Current(), network_thread, nullptr) {
     SetIceRole(role);
   }
 
-  FakeTransportChannel* GetFakeTransportChannel_n(
-      const std::string& transport_name,
-      int component) {
-    return static_cast<FakeTransportChannel*>(
+  FakeDtlsTransport* GetFakeDtlsTransport_n(const std::string& transport_name,
+                                            int component) {
+    return static_cast<FakeDtlsTransport*>(
         get_channel_for_testing(transport_name, component));
   }
 
   // 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),
@@ skipping 30 matching lines @@
     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.

[Taylor Brandstetter, 2017/01/03 23:21:59]

Should update this comment.

   TransportChannelImpl* CreateIceTransportChannel_n(
       const std::string& transport_name,
       int component) override {
-    return nullptr;
+    return new FakeTransportChannel(transport_name, component);
   }
 
-  TransportChannelImpl* CreateDtlsTransportChannel_n(
+  DtlsTransportInternal* CreateDtlsTransportChannel_n(
       const std::string& transport_name,
       int component,
-      TransportChannelImpl*) override {
-    return new FakeTransportChannel(transport_name, component);
+      TransportChannelImpl* ice) override {
+    return new FakeDtlsTransport(static_cast<FakeTransportChannel*>(ice));
   }
 
  private:
   void SetChannelDestinations_n(FakeTransportController* dest) {
-    for (TransportChannelImpl* tc : channels_for_testing()) {
-      FakeTransportChannel* local = static_cast<FakeTransportChannel*>(tc);
-      FakeTransportChannel* remote = dest->GetFakeTransportChannel_n(
+    for (DtlsTransportInternal* tc : channels_for_testing()) {
+      FakeDtlsTransport* local = static_cast<FakeDtlsTransport*>(tc);
+      FakeDtlsTransport* remote = dest->GetFakeDtlsTransport_n(
           local->transport_name(), local->component());
       if (remote) {
         bool asymmetric = false;
         local->SetDestination(remote, asymmetric);
       }
     }
   }
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_FAKETRANSPORTCONTROLLER_H_