Adding OrtcFactory, and changing UdpTransport to match current plan.

webrtc/api/ortcfactory_unittest.cc

Index: webrtc/api/ortcfactory_unittest.cc
diff --git a/webrtc/api/ortcfactory_unittest.cc b/webrtc/api/ortcfactory_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..21ad6f8696d86a7e5400affe6c15914a1328ea3f
--- /dev/null
+++ b/webrtc/api/ortcfactory_unittest.cc
@@ -0,0 +1,122 @@
+/*
+ *  Copyright 2017 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 <memory>
+
+#include "webrtc/api/ortcfactoryinterface.h"
+#include "webrtc/base/fakenetwork.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/physicalsocketserver.h"
+#include "webrtc/base/virtualsocketserver.h"
+#include "webrtc/p2p/base/udptransport.h"
+
+namespace {
+
+const int kDefaultTimeout = 10000;  // 10 seconds.
+static const rtc::IPAddress kIPv4LocalHostAddress =
+    rtc::IPAddress(0x7F000001);  // 127.0.0.1
+
+class PacketReceiver : public sigslot::has_slots<> {
+ public:
+  explicit PacketReceiver(rtc::PacketTransportInterface* transport) {
+    transport->SignalReadPacket.connect(this, &PacketReceiver::OnReadPacket);
+  }
+  int packets_read() const { return packets_read_; }
+
+ private:
+  void OnReadPacket(rtc::PacketTransportInterface*,
+                    const char*,
+                    size_t,
+                    const rtc::PacketTime&,
+                    int) {
+    ++packets_read_;
+  }
+
+  int packets_read_ = 0;
+};
+
+}  // namespace
+
+namespace webrtc {
+
+// Used to test that things work end-to-end when using the default
+// implementations of threads/etc. provided by OrtcFactory, with the exception
+// of using a virtual network.
+//
+// By default, the virtual network manager doesn't enumerate any networks, but
+// sockets can still be created in this state.
+class OrtcFactoryTest : public testing::Test {
+ public:
+  OrtcFactoryTest()
+      : virtual_socket_server_(&physical_socket_server_),
+        network_thread_(&virtual_socket_server_),
+        ortc_factory_(OrtcFactoryInterface::Create(&network_thread_,
+                                                   nullptr,
+                                                   &fake_network_manager_,
+                                                   nullptr)) {
+    // Sockets are bound to the ANY address, so this is needed to tell the
+    // virtual network which address to use in this case.
+    virtual_socket_server_.SetDefaultRoute(kIPv4LocalHostAddress);
+    network_thread_.Start();
+  }
+
+ protected:
+  rtc::PhysicalSocketServer physical_socket_server_;
+  rtc::VirtualSocketServer virtual_socket_server_;
+  rtc::Thread network_thread_;
+  rtc::FakeNetworkManager fake_network_manager_;
+  std::unique_ptr<OrtcFactoryInterface> ortc_factory_;
+};
+
+TEST_F(OrtcFactoryTest, EndToEndUdpTransport) {
+  std::unique_ptr<UdpTransportInterface> transport1 =
+      ortc_factory_->CreateUdpTransport(AF_INET);
+  std::unique_ptr<UdpTransportInterface> transport2 =
+      ortc_factory_->CreateUdpTransport(AF_INET);
+  ASSERT_NE(nullptr, transport1);
+  ASSERT_NE(nullptr, transport2);
+  // Sockets are bound to the ANY address, so we need to provide the IP address
+  // explicitly.
+  transport1->SetRemoteAddress(
+      rtc::SocketAddress(virtual_socket_server_.GetDefaultRoute(AF_INET),
+                         transport2->GetLocalAddress().port()));
+  transport2->SetRemoteAddress(
+      rtc::SocketAddress(virtual_socket_server_.GetDefaultRoute(AF_INET),
+                         transport1->GetLocalAddress().port()));
+
+  // TODO(deadbeef): Once there's something (RTP senders/receivers) that can
+  // use UdpTransport end-to-end, use that for this end-to-end test instead of
+  // making assumptions about the implementation.
+  //
+  // For now, this assumes the returned object is a UdpTransportProxy that wraps
+  // a UdpTransport.
+  cricket::UdpTransport* internal_transport1 =
+      static_cast<UdpTransportProxyWithInternal<cricket::UdpTransport>*>(
+          transport1.get())
+          ->internal();
+  cricket::UdpTransport* internal_transport2 =
+      static_cast<UdpTransportProxyWithInternal<cricket::UdpTransport>*>(
+          transport2.get())
+          ->internal();
+  // Need to call internal "SendPacket" method on network thread.
+  network_thread_.Invoke<void>(
+      RTC_FROM_HERE, [internal_transport1, internal_transport2]() {
+        PacketReceiver receiver1(internal_transport1);
+        PacketReceiver receiver2(internal_transport2);
+        internal_transport1->SendPacket("foo", sizeof("foo"),
+                                        rtc::PacketOptions(), 0);
+        internal_transport2->SendPacket("foo", sizeof("foo"),
+                                        rtc::PacketOptions(), 0);
+        EXPECT_EQ_WAIT(1, receiver1.packets_read(), kDefaultTimeout);
+        EXPECT_EQ_WAIT(1, receiver2.packets_read(), kDefaultTimeout);
+      });
+}
+
+}  // namespace webrtc