Create //webrtc/api:libjingle_peerconnection_api + refactorings.

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
deleted file mode 100644
index 21ad6f8696d86a7e5400affe6c15914a1328ea3f..0000000000000000000000000000000000000000
--- a/webrtc/api/ortcfactory_unittest.cc
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- *  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