Revert of Replace RelayPort with TurnPort in p2ptransportchannel tests.

webrtc/p2p/base/p2ptransportchannel_unittest.cc

 /*
  *  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 58 matching lines @@
 static const SocketAddress kPrivateAddrs[2] =
     { SocketAddress("192.168.1.11", 0), SocketAddress("192.168.2.22", 0) };
 // For cascaded NATs, the internal addresses of the inner NAT boxes.
 static const SocketAddress kCascadedNatAddrs[2] =
     { SocketAddress("192.168.10.1", 0), SocketAddress("192.168.20.1", 0) };
 // For cascaded NATs, private addresses inside the inner private networks.
 static const SocketAddress kCascadedPrivateAddrs[2] =
     { SocketAddress("192.168.10.11", 0), SocketAddress("192.168.20.22", 0) };
 // The address of the public STUN server.
 static const SocketAddress kStunAddr("99.99.99.1", cricket::STUN_SERVER_PORT);
+// The addresses for the public relay server.
+static const SocketAddress kRelayUdpIntAddr("99.99.99.2", 5000);
+static const SocketAddress kRelayUdpExtAddr("99.99.99.3", 5001);
+static const SocketAddress kRelayTcpIntAddr("99.99.99.2", 5002);
+static const SocketAddress kRelayTcpExtAddr("99.99.99.3", 5003);
+static const SocketAddress kRelaySslTcpIntAddr("99.99.99.2", 5004);
+static const SocketAddress kRelaySslTcpExtAddr("99.99.99.3", 5005);
 // The addresses for the public turn server.
 static const SocketAddress kTurnUdpIntAddr("99.99.99.4",
                                            cricket::STUN_SERVER_PORT);
 static const SocketAddress kTurnTcpIntAddr("99.99.99.4",
                                            cricket::STUN_SERVER_PORT + 1);
 static const SocketAddress kTurnUdpExtAddr("99.99.99.5", 0);
 static const cricket::RelayCredentials kRelayCredentials("test", "test");
 
 // Based on ICE_UFRAG_LENGTH
 const char* kIceUfrag[4] = {"UF00", "UF01", "UF02", "UF03"};
@@ skipping 31 matching lines @@
   cricket::Candidate c;
   c.set_address(rtc::SocketAddress(ip, port));
   c.set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
   c.set_protocol(cricket::UDP_PROTOCOL_NAME);
   c.set_priority(priority);
   c.set_username(ufrag);
   c.set_type(type);
   return c;
 }
 
-cricket::BasicPortAllocator* CreateBasicPortAllocator(
-    rtc::NetworkManager* network_manager,
-    const cricket::ServerAddresses& stun_servers,
-    const rtc::SocketAddress& turn_server_udp,
-    const rtc::SocketAddress& turn_server_tcp) {
-  cricket::RelayServerConfig turn_server(cricket::RELAY_TURN);
-  turn_server.credentials = kRelayCredentials;
-  if (!turn_server_udp.IsNil()) {
-    turn_server.ports.push_back(
-        cricket::ProtocolAddress(turn_server_udp, cricket::PROTO_UDP, false));
-  }
-  if (!turn_server_tcp.IsNil()) {
-    turn_server.ports.push_back(
-        cricket::ProtocolAddress(turn_server_tcp, cricket::PROTO_TCP, false));
-  }
-  std::vector<cricket::RelayServerConfig> turn_servers(1, turn_server);
-
-  cricket::BasicPortAllocator* allocator =
-      new cricket::BasicPortAllocator(network_manager);
-  allocator->SetConfiguration(stun_servers, turn_servers, 0, false);
-  return allocator;
-}
 }  // namespace
 
 namespace cricket {
 
 // This test simulates 2 P2P endpoints that want to establish connectivity
 // with each other over various network topologies and conditions, which can be
 // specified in each individial test.
 // A virtual network (via VirtualSocketServer) along with virtual firewalls and
 // NATs (via Firewall/NATSocketServer) are used to simulate the various network
 // conditions. We can configure the IP addresses of the endpoints,
@@ skipping 12 matching lines @@
  public:
   P2PTransportChannelTestBase()
       : main_(rtc::Thread::Current()),
         pss_(new rtc::PhysicalSocketServer),
         vss_(new rtc::VirtualSocketServer(pss_.get())),
         nss_(new rtc::NATSocketServer(vss_.get())),
         ss_(new rtc::FirewallSocketServer(nss_.get())),
         ss_scope_(ss_.get()),
         stun_server_(TestStunServer::Create(main_, kStunAddr)),
         turn_server_(main_, kTurnUdpIntAddr, kTurnUdpExtAddr),
+        relay_server_(main_,
+                      kRelayUdpIntAddr,
+                      kRelayUdpExtAddr,
+                      kRelayTcpIntAddr,
+                      kRelayTcpExtAddr,
+                      kRelaySslTcpIntAddr,
+                      kRelaySslTcpExtAddr),
         socks_server1_(ss_.get(),
                        kSocksProxyAddrs[0],
                        ss_.get(),
                        kSocksProxyAddrs[0]),
         socks_server2_(ss_.get(),
                        kSocksProxyAddrs[1],
                        ss_.get(),
                        kSocksProxyAddrs[1]),
         force_relay_(false) {
     ep1_.role_ = ICEROLE_CONTROLLING;
     ep2_.role_ = ICEROLE_CONTROLLED;
 
-    turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
     ServerAddresses stun_servers;
     stun_servers.insert(kStunAddr);
-    ep1_.allocator_.reset(
-        CreateBasicPortAllocator(&ep1_.network_manager_, stun_servers,
-                                 kTurnUdpIntAddr, kTurnTcpIntAddr));
-    ep2_.allocator_.reset(
-        CreateBasicPortAllocator(&ep2_.network_manager_, stun_servers,
-                                 kTurnUdpIntAddr, kTurnTcpIntAddr));
+    ep1_.allocator_.reset(new BasicPortAllocator(
+        &ep1_.network_manager_, stun_servers, kRelayUdpIntAddr,
+        kRelayTcpIntAddr, kRelaySslTcpIntAddr));
+    ep2_.allocator_.reset(new BasicPortAllocator(
+        &ep2_.network_manager_, stun_servers, kRelayUdpIntAddr,
+        kRelayTcpIntAddr, kRelaySslTcpIntAddr));
   }
 
  protected:
   enum Config {
     OPEN,                           // Open to the Internet
     NAT_FULL_CONE,                  // NAT, no filtering
     NAT_ADDR_RESTRICTED,            // NAT, must send to an addr to recv
     NAT_PORT_RESTRICTED,            // NAT, must send to an addr+port to recv
     NAT_SYMMETRIC,                  // NAT, endpoint-dependent bindings
     NAT_DOUBLE_CONE,                // Double NAT, both cone
@@ skipping 631 matching lines @@
 
  private:
   rtc::Thread* main_;
   std::unique_ptr<rtc::PhysicalSocketServer> pss_;
   std::unique_ptr<rtc::VirtualSocketServer> vss_;
   std::unique_ptr<rtc::NATSocketServer> nss_;
   std::unique_ptr<rtc::FirewallSocketServer> ss_;
   rtc::SocketServerScope ss_scope_;
   std::unique_ptr<TestStunServer> stun_server_;
   TestTurnServer turn_server_;
+  TestRelayServer relay_server_;
   rtc::SocksProxyServer socks_server1_;
   rtc::SocksProxyServer socks_server2_;
   Endpoint ep1_;
   Endpoint ep2_;
   RemoteIceParameterSource remote_ice_parameter_source_ = FROM_CANDIDATE;
   bool force_relay_;
   int selected_candidate_pair_switches_ = 0;
 
   bool nominated_ = false;
 };
@@ skipping 86 matching lines @@
 
 // Test the matrix of all the connectivity types we expect to see in the wild.
 // Just test every combination of the configs in the Config enum.
 class P2PTransportChannelTest : public P2PTransportChannelTestBase {
  protected:
   static const Result* kMatrix[NUM_CONFIGS][NUM_CONFIGS];
   void ConfigureEndpoints(Config config1,
                           Config config2,
                           int allocator_flags1,
                           int allocator_flags2) {
+    ServerAddresses stun_servers;
+    stun_servers.insert(kStunAddr);
+    GetEndpoint(0)->allocator_.reset(new BasicPortAllocator(
+        &(GetEndpoint(0)->network_manager_), stun_servers, rtc::SocketAddress(),
+        rtc::SocketAddress(), rtc::SocketAddress()));
+    GetEndpoint(1)->allocator_.reset(new BasicPortAllocator(
+        &(GetEndpoint(1)->network_manager_), stun_servers, rtc::SocketAddress(),
+        rtc::SocketAddress(), rtc::SocketAddress()));
+
+    RelayServerConfig turn_server(RELAY_TURN);
+    turn_server.credentials = kRelayCredentials;
+    turn_server.ports.push_back(
+        ProtocolAddress(kTurnUdpIntAddr, PROTO_UDP, false));
+    GetEndpoint(0)->allocator_->AddTurnServer(turn_server);
+    GetEndpoint(1)->allocator_->AddTurnServer(turn_server);
+
     int delay = kMinimumStepDelay;
     ConfigureEndpoint(0, config1);
     SetAllocatorFlags(0, allocator_flags1);
     SetAllocationStepDelay(0, delay);
     ConfigureEndpoint(1, config2);
     SetAllocatorFlags(1, allocator_flags2);
     SetAllocationStepDelay(1, delay);
 
     set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
   }
@@ skipping 2827 matching lines @@
   EXPECT_EQ_SIMULATED_WAIT(nullptr, GetPort(&ch), 1, fake_clock);
   EXPECT_EQ_SIMULATED_WAIT(nullptr, GetPrunedPort(&ch), 1, fake_clock);
 }
 
 class P2PTransportChannelMostLikelyToWorkFirstTest
     : public P2PTransportChannelPingTest {
  public:
   P2PTransportChannelMostLikelyToWorkFirstTest()
       : turn_server_(rtc::Thread::Current(), kTurnUdpIntAddr, kTurnUdpExtAddr) {
     network_manager_.AddInterface(kPublicAddrs[0]);
-    allocator_.reset(
-        CreateBasicPortAllocator(&network_manager_, ServerAddresses(),
-                                 kTurnUdpIntAddr, rtc::SocketAddress()));
+    allocator_.reset(new BasicPortAllocator(
+        &network_manager_, ServerAddresses(), rtc::SocketAddress(),
+        rtc::SocketAddress(), rtc::SocketAddress()));
     allocator_->set_flags(allocator_->flags() | PORTALLOCATOR_DISABLE_STUN |
                           PORTALLOCATOR_DISABLE_TCP);
+    RelayServerConfig config(RELAY_TURN);
+    config.credentials = kRelayCredentials;
+    config.ports.push_back(ProtocolAddress(kTurnUdpIntAddr, PROTO_UDP, false));
+    allocator_->AddTurnServer(config);
     allocator_->set_step_delay(kMinimumStepDelay);
   }
 
   P2PTransportChannel& StartTransportChannel(
       bool prioritize_most_likely_to_work,
       int stable_writable_connection_ping_interval) {
     channel_.reset(new P2PTransportChannel("checks", 1, nullptr, allocator()));
     IceConfig config = channel_->config();
     config.prioritize_most_likely_candidate_pairs =
         prioritize_most_likely_to_work;
@@ skipping 177 matching lines @@
 
   // TCP Relay/Relay is the next.
   VerifyNextPingableConnection(RELAY_PORT_TYPE, RELAY_PORT_TYPE,
                                TCP_PROTOCOL_NAME);
 
   // Finally, Local/Relay will be pinged.
   VerifyNextPingableConnection(LOCAL_PORT_TYPE, RELAY_PORT_TYPE);
 }
 
 }  // namespace cricket {