Bug 4865: Enable connectivity when the remote peer is on public internet.

webrtc/p2p/client/portallocator_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 92 matching lines @@
     allocator_.reset(new cricket::BasicPortAllocator(
         &network_manager_,
         stun_servers,
         kRelayUdpIntAddr, kRelayTcpIntAddr, kRelaySslTcpIntAddr));
     allocator_->set_step_delay(cricket::kMinimumStepDelay);
   }
 
   void AddInterface(const SocketAddress& addr) {
     network_manager_.AddInterface(addr);
   }
+  void AddInterfaceAsDefault(const SocketAddress& addr) {

[pthatcher1, 2015/08/06 01:06:19]

Would SetDefaultRoute make more sense?

[guoweis_webrtc, 2015/08/06 08:50:07]

I renamed it as AddInterfaceAsDefaultRoute, since it's doing the AddInterface
part.

+    AddInterface(addr);
+    // When a binding comes from the any address, the |addr| will be used as the
+    // srflx address.
+    vss_->set_default_interface(addr.ipaddr());
+  }
   bool SetPortRange(int min_port, int max_port) {
     return allocator_->SetPortRange(min_port, max_port);
   }
+  // No STUN/TURN configuration.
+  void ResetWithNoServers() {
+    allocator_.reset(new cricket::BasicPortAllocator(&network_manager_));
+    allocator_->set_step_delay(cricket::kMinimumStepDelay);
+  }
   void ResetWithNatServer(const rtc::SocketAddress& stun_server) {
     nat_server_.reset(new rtc::NATServer(
         rtc::NAT_OPEN_CONE, vss_.get(), kNatUdpAddr, kNatTcpAddr, vss_.get(),
         rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0)));
 
     ServerAddresses stun_servers;
     if (!stun_server.IsNil()) {
       stun_servers.insert(stun_server);
     }
     allocator_.reset(new cricket::BasicPortAllocator(
@@ skipping 99 matching lines @@
                   (*it)->GetOption(rtc::Socket::OPT_SNDBUF,
                                    &send_buffer_size));
       } else {
         EXPECT_EQ(0, (*it)->GetOption(rtc::Socket::OPT_SNDBUF,
                                       &send_buffer_size));
         ASSERT_EQ(expected, send_buffer_size);
       }
     }
   }
 
-  void CheckDisableAdapterEnumeration() {
+  void CheckDisableAdapterEnumerationNonSharedSocket() {

[juberti1, 2015/08/06 00:35:26]

can we just fix this to use shared socket? non-shared socket is going to
disappear very soon.

[guoweis_webrtc, 2015/08/06 08:50:07]

Done.

     EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
     session_->set_flags(cricket::PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION);
     session_->StartGettingPorts();
     EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
 
     // Only 2 candidates as local UDP/TCP are all 0s and get trimmed out.
     EXPECT_EQ(2U, candidates_.size());
     EXPECT_EQ(2U, ports_.size());  // One stunport and one turnport.
 
     EXPECT_PRED5(CheckCandidate, candidates_[0],
@@ skipping 208 matching lines @@
 }
 
 // Test that we should only get STUN and TURN candidates when adapter
 // enumeration is disabled.
 TEST_F(PortAllocatorTest, TestDisableAdapterEnumeration) {
   AddInterface(kClientAddr);
   // GTURN is not configured here.
   ResetWithNatServer(kStunAddr);
   AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
 
-  CheckDisableAdapterEnumeration();
+  CheckDisableAdapterEnumerationNonSharedSocket();
 }
 
 // Test that even with multiple interfaces, the result should be only 1 Stun
 // candidate since we bind to any address (i.e. all 0s).
 TEST_F(PortAllocatorTest, TestDisableAdapterEnumerationMultipleInterfaces) {
   AddInterface(kPrivateAddr);
   AddInterface(kPrivateAddr2);
   ResetWithNatServer(kStunAddr);
   AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
 
-  CheckDisableAdapterEnumeration();
+  CheckDisableAdapterEnumerationNonSharedSocket();
 }
 
 // Disable for asan, see
 // https://code.google.com/p/webrtc/issues/detail?id=4743 for details.
 #if !defined(ADDRESS_SANITIZER)
 
 // Test that we can get OnCandidatesAllocationDone callback when all the ports
 // are disabled.
 TEST_F(PortAllocatorTest, TestDisableAllPorts) {
   AddInterface(kClientAddr);
@@ skipping 668 matching lines @@
   session_->StartGettingPorts();
   ASSERT_EQ_WAIT(7U, candidates_.size(), kDefaultAllocationTimeout);
   EXPECT_EQ(4U, ports_.size());
 
   auto it = ports_.begin();
   for (; it != ports_.end(); ++it) {
     (reinterpret_cast<cricket::Port*>(*it))->Destroy();
   }
 }
 
+// Test that when adapter enumeration is disabled, STUN is the only candidate

[juberti1, 2015/08/06 00:35:26]

Isn't this already tested by the tests above?

[pthatcher1, 2015/08/06 01:06:19]

I think this one is different because it is shared socket and
PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION. The other is not shared socket.  But
we should probably just delete the non-shared socket test.

[guoweis_webrtc, 2015/08/06 08:50:07]

this one is different because it doesn't have a NAT. It's testing the endpoint
sitting on the public internet.

+// for endpoints not behind a NAT.
+TEST_F(PortAllocatorTest, TestAdapterEnumerationDisabledWithoutNat) {

[juberti1, 2015/08/06 00:35:26]

move this next to other adapter-enum disabled tests?

[guoweis_webrtc, 2015/08/06 08:50:07]

Done.

+  AddInterfaceAsDefault(kClientAddr);
+  allocator_->set_flags(allocator().flags() |
+                        cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG |
+                        cricket::PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION |
+                        cricket::PORTALLOCATOR_DISABLE_RELAY |
+                        cricket::PORTALLOCATOR_DISABLE_TCP |
+                        cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET);
+  EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
+  session_->StartGettingPorts();
+  EXPECT_TRUE_WAIT(1U == ports_.size(), kDefaultAllocationTimeout);
+  ASSERT_EQ_WAIT(1U, candidates_.size(), kDefaultAllocationTimeout);
+  EXPECT_PRED5(CheckCandidate, candidates_[0],
+               cricket::ICE_CANDIDATE_COMPONENT_RTP, "stun", "udp",
+               kClientAddr);
+  EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
+}
+
+// Test that when adapter enumeration is disabled, for endpoints without
+// STUN/TURN specified, no candidate is generated.
+TEST_F(PortAllocatorTest,
+       TestAdapterEnumerationDisabledWithoutNat_NoCandidate) {
+  AddInterfaceAsDefault(kClientAddr);
+  ResetWithNoServers();
+  allocator_->set_flags(allocator().flags() |
+                        cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG |
+                        cricket::PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION |
+                        cricket::PORTALLOCATOR_DISABLE_RELAY |
+                        cricket::PORTALLOCATOR_DISABLE_TCP |
+                        cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET);
+  EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
+  session_->StartGettingPorts();
+  EXPECT_TRUE_WAIT(1U == ports_.size(), kDefaultAllocationTimeout);
+  EXPECT_EQ(candidates_.size(), 0u);
+  EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
+}
+
 class AllocationSequenceForTest : public cricket::AllocationSequence {
  public:
   AllocationSequenceForTest(cricket::BasicPortAllocatorSession* session,
                             rtc::Network* network,
                             cricket::PortConfiguration* config,
                             uint32 flags)
       : cricket::AllocationSequence(session, network, config, flags) {}
   using cricket::AllocationSequence::CreateTurnPort;
 };
 
@@ skipping 10 matching lines @@
   AllocationSequenceForTest alloc_sequence(
       static_cast<cricket::BasicPortAllocatorSession*>(session_.get()),
       &network1, &config, flag);
   // This simply tests it will not crash if udp_socket_ in the
   // AllocationSequence is null, which is chosen in the constructor.
   cricket::RelayServerConfig relay_server(cricket::RELAY_TURN);
   relay_server.ports.push_back(
       cricket::ProtocolAddress(kTurnUdpIntAddr, cricket::PROTO_UDP, false));
   alloc_sequence.CreateTurnPort(relay_server);
 }