Modified PeerConnection and WebRtcSession for end-to-end QuicDataChannel usage.

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.
  */
 
@@ skipping 11 matching lines @@
 #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
@@ skipping 404 matching lines @@
   // 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;
   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,
+                    FakeTransportChannel* fake_ice_transport_channel)
+      : QuicTransport(transport_name, nullptr, nullptr),
+        fake_ice_transport_channel_(fake_ice_transport_channel) {}
+
+ protected:
+  QuicTransportChannel* CreateTransportChannel(int component) override {
+    LOG(INFO) << "creating quic transport channel:"
+              << fake_ice_transport_channel_;
+    return new QuicTransportChannel(fake_ice_transport_channel_);
+  }
+
+ private:
+  FakeTransportChannel* 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 {
@@ skipping 30 matching lines @@
   explicit FakeTransportController(rtc::Thread* worker_thread)
       : TransportController(rtc::Thread::Current(), worker_thread, nullptr),
         fail_create_channel_(false) {}
 
   FakeTransportController(rtc::Thread* worker_thread, IceRole role)
       : TransportController(rtc::Thread::Current(), worker_thread, nullptr),
         fail_create_channel_(false) {
     SetIceRole(role);
   }
 
+  FakeTransportController(const std::string& transport_name)
+      : TransportController(rtc::Thread::Current(),
+                            rtc::Thread::Current(),
+                            nullptr),
+        fail_create_channel_(false),
+        fake_ice_transport_channel_(
+            new FakeTransportChannel(transport_name, 1)) {}
+
   FakeTransport* GetTransport_n(const std::string& transport_name) {
     return static_cast<FakeTransport*>(
         TransportController::GetTransport_n(transport_name));
   }
 
   void Connect(FakeTransportController* dest) {
     network_thread()->Invoke<void>(
         RTC_FROM_HERE,
         rtc::Bind(&FakeTransportController::Connect_n, this, dest));
   }
@@ skipping 16 matching lines @@
                               "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);
   }
 
   void set_fail_channel_creation(bool fail_channel_creation) {
     fail_create_channel_ = fail_channel_creation;
   }
 
+  FakeTransportChannel* fake_ice_transport_channel() {
+    return fake_ice_transport_channel_;
+  }
+
  protected:
   Transport* CreateTransport_n(const std::string& transport_name) override {
+#ifdef HAVE_QUIC
+    if (quic()) {
+      LOG(INFO) << "creating quic transport.";
+      return new FakeQuicTransport(transport_name, fake_ice_transport_channel_);
+    }
+#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));
@@ skipping 13 matching lines @@
       if (!transport->local_description()) {
         transport->SetLocalTransportDescription(faketransport_desc,
                                                 cricket::CA_OFFER, nullptr);
       }
       transport->MaybeStartGathering();
     }
   }
 
  private:
   bool fail_create_channel_;
+  FakeTransportChannel* fake_ice_transport_channel_;

[Taylor Brandstetter, 2016/08/01 18:05:03]

I don't think having the FakeTransportController own a single fake ICE transport
channel will work as we add more tests. If you create two QuicTransportChannels,
it will be double-freed. And if you create zero, it will leak.

How about this: In FakeQuicTransport::CreateTransportChannel, you create a new
FakeTransportChannel each time. Then you access it by calling an
"ice_transport_channel()" method on the QuicTransportChannel, and casting it to
a FakeTransportChannel in the test (since the test knows that's what it will
be).

I think it's appropriate for the QuicTransportChannel to have a method exposing
its ICE transport channel, since that's already something exposed in the API:
https://www.w3.org/TR/webrtc/#dom-rtcdtlstransport-transport

Or another alternative: FakeQuicTransport creates a FakeQuicTransportChannel,
which is a subclass of QuicTransportChannel that has a
"fake_ice_transport_channel()" method. So something like this:

class FakeQuicTransportChannel : QuicTransportChannel {
 public:
  FakeQuicTransportChannel(FakeTransportChannel* ch) :
      QuicTransportChannel(ch),
      fake_transport_channel_(ch) {
  }

  FakeTransportChannel* fake_transport_channel() {
    return fake_transport_channel_;
  }

 private:
  FakeTransportChannel* fake_transport_channel_;
};

Then in FakeQuicTransport::CreateTransportChannel you'd do:

  return new FakeQuicTransportChannel(new FakeTransportChannel(name(),
component()));

[Zhi Huang, 2016/08/01 23:56:22]

This is a good point!
I like the idea to expose the ice_tranport_channel.

 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_FAKETRANSPORTCONTROLLER_H_