Signal to remove remote candidates if ports are pruned.

webrtc/p2p/client/basicportallocator_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 61 matching lines @@
 static const int kMinPort = 10000;
 static const int kMaxPort = 10099;
 
 // Based on ICE_UFRAG_LENGTH
 static const char kIceUfrag0[] = "UF00";
 // Based on ICE_PWD_LENGTH
 static const char kIcePwd0[] = "TESTICEPWD00000000000000";
 
 static const char kContentName[] = "test content";
 
-static const int kDefaultAllocationTimeout = 1000;
+static const int kDefaultAllocationTimeout = 3000;
 static const char kTurnUsername[] = "test";
 static const char kTurnPassword[] = "test";
 
 // STUN timeout (with all retries) is 9500ms.
 // Add some margin of error for slow bots.
 // TODO(deadbeef): Use simulated clock instead of just increasing timeouts to
 // fix flaky tests.
 static const int kStunTimeoutMs = 15000;
 
 namespace cricket {
@@ skipping 143 matching lines @@
       const std::string& ice_ufrag,
       const std::string& ice_pwd) {
     std::unique_ptr<PortAllocatorSession> session =
         allocator_->CreateSession(content_name, component, ice_ufrag, ice_pwd);
     session->SignalPortReady.connect(this,
                                      &BasicPortAllocatorTest::OnPortReady);
     session->SignalPortsPruned.connect(this,
                                        &BasicPortAllocatorTest::OnPortsPruned);
     session->SignalCandidatesReady.connect(
         this, &BasicPortAllocatorTest::OnCandidatesReady);
+    session->SignalCandidatesRemoved.connect(
+        this, &BasicPortAllocatorTest::OnCandidatesRemoved);
     session->SignalCandidatesAllocationDone.connect(
         this, &BasicPortAllocatorTest::OnCandidatesAllocationDone);
     return session;
   }
 
   // Return true if the addresses are the same, or the port is 0 in |pattern|
   // (acting as a wildcard) and the IPs are the same.
   // Even with a wildcard port, the port of the address should be nonzero if
   // the IP is nonzero.
   static bool AddressMatch(const SocketAddress& address,
@@ skipping 141 matching lines @@
       EXPECT_PRED5(HasCandidateWithRelatedAddr, candidates_, "relay", "udp",
                    rtc::SocketAddress(relay_candidate_tcp_transport_addr, 0),
                    rtc::SocketAddress(stun_candidate_addr, 0));
       ++total_candidates;
     }
 
     EXPECT_EQ(total_candidates, candidates_.size());
     EXPECT_EQ(total_ports, ports_.size());
   }
 
+  rtc::VirtualSocketServer* virtual_socket_server() { return vss_.get(); }
+
  protected:
   BasicPortAllocator& allocator() { return *allocator_; }
 
   void OnPortReady(PortAllocatorSession* ses, PortInterface* port) {
     LOG(LS_INFO) << "OnPortReady: " << port->ToString();
     ports_.push_back(port);
     // Make sure the new port is added to ReadyPorts.
     auto ready_ports = ses->ReadyPorts();
     EXPECT_NE(ready_ports.end(),
               std::find(ready_ports.begin(), ready_ports.end(), port));
@@ skipping 22 matching lines @@
     }
     // Make sure the new candidates are added to Candidates.
     auto ses_candidates = ses->ReadyCandidates();
     for (const Candidate& candidate : candidates) {
       EXPECT_NE(
           ses_candidates.end(),
           std::find(ses_candidates.begin(), ses_candidates.end(), candidate));
     }
   }
 
+  void OnCandidatesRemoved(PortAllocatorSession* session,
+                           const std::vector<Candidate>& removed_candidates) {
+    auto new_end = std::remove_if(
+        candidates_.begin(), candidates_.end(),
+        [removed_candidates](Candidate& candidate) {
+          for (const Candidate& removed_candidate : removed_candidates) {
+            if (candidate.MatchesForRemoval(removed_candidate)) {
+              return true;
+            }
+          }
+          return false;
+        });
+    candidates_.erase(new_end, candidates_.end());
+  }
+
   bool HasRelayAddress(const ProtocolAddress& proto_addr) {
     for (size_t i = 0; i < allocator_->turn_servers().size(); ++i) {
       RelayServerConfig server_config = allocator_->turn_servers()[i];
       PortList::const_iterator relay_port;
       for (relay_port = server_config.ports.begin();
            relay_port != server_config.ports.end(); ++relay_port) {
         if (proto_addr.address == relay_port->address &&
             proto_addr.proto == relay_port->proto)
           return true;
       }
@@ skipping 13 matching lines @@
 
     ServerAddresses stun_servers;
     if (!stun_server.IsNil()) {
       stun_servers.insert(stun_server);
     }
     allocator_.reset(new BasicPortAllocator(
         &network_manager_, nat_socket_factory_.get(), stun_servers));
     allocator().set_step_delay(kMinimumStepDelay);
   }
 
+  void TestUdpTurnPortPrunesTcpTurnPort() {
+    turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
+    AddInterface(kClientAddr);
+    allocator_.reset(new BasicPortAllocator(&network_manager_));
+    allocator_->SetConfiguration(allocator_->stun_servers(),
+                                 allocator_->turn_servers(), 0, true);
+    AddTurnServers(kTurnUdpIntAddr, kTurnTcpIntAddr);
+    allocator_->set_step_delay(kMinimumStepDelay);
+    allocator_->set_flags(allocator().flags() |
+                          PORTALLOCATOR_ENABLE_SHARED_SOCKET |
+                          PORTALLOCATOR_DISABLE_TCP);
+
+    EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
+    session_->StartGettingPorts();
+    EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
+    // Only 2 ports (one STUN and one TURN) are actually being used.
+    EXPECT_EQ(2U, session_->ReadyPorts().size());
+    // We have verified that each port, when it is added to |ports_|, it is
+    // found in |ready_ports|, and when it is pruned, it is not found in
+    // |ready_ports|, so we only need to verify the content in one of them.
+    EXPECT_EQ(2U, ports_.size());
+    EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientAddr));
+    EXPECT_EQ(1, CountPorts(ports_, "relay", PROTO_UDP, kClientAddr));
+    EXPECT_EQ(0, CountPorts(ports_, "relay", PROTO_TCP, kClientAddr));
+
+    // Now that we remove candidates when a TURN port is pruned, |candidates_|
+    // should only contains two candidates regardless whether the TCP TURN port
+    // is created before or after the UDP turn port.
+    EXPECT_EQ(2U, candidates_.size());
+    // There will only be 2 candidates in |ready_candidates| because it only
+    // includes the candidates in the ready ports.
+    const std::vector<Candidate>& ready_candidates =
+        session_->ReadyCandidates();
+    EXPECT_EQ(2U, ready_candidates.size());
+    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp", kClientAddr);
+    EXPECT_PRED4(HasCandidate, ready_candidates, "relay", "udp",
+                 rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
+  }
+
+  void TestIPv6TurnPortPrunesIPv4TurnPort() {
+    turn_server_.AddInternalSocket(kTurnUdpIntIPv6Addr, PROTO_UDP);
+    // Add two IP addresses on the same interface.
+    AddInterface(kClientAddr, "net1");
+    AddInterface(kClientIPv6Addr, "net1");
+    allocator_.reset(new BasicPortAllocator(&network_manager_));
+    allocator_->SetConfiguration(allocator_->stun_servers(),
+                                 allocator_->turn_servers(), 0, true);
+    AddTurnServers(kTurnUdpIntIPv6Addr, rtc::SocketAddress());
+    AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
+
+    allocator_->set_step_delay(kMinimumStepDelay);
+    allocator_->set_flags(
+        allocator().flags() | PORTALLOCATOR_ENABLE_SHARED_SOCKET |
+        PORTALLOCATOR_ENABLE_IPV6 | PORTALLOCATOR_DISABLE_TCP);
+
+    EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
+    session_->StartGettingPorts();
+    EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
+    // Three ports (one IPv4 STUN, one IPv6 STUN and one TURN) will be ready.
+    EXPECT_EQ(3U, session_->ReadyPorts().size());
+    EXPECT_EQ(3U, ports_.size());
+    EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientAddr));
+    EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientIPv6Addr));
+    EXPECT_EQ(1, CountPorts(ports_, "relay", PROTO_UDP, kClientIPv6Addr));
+    EXPECT_EQ(0, CountPorts(ports_, "relay", PROTO_UDP, kClientAddr));
+
+    // Now that we remove candidates when a TURN port is pruned, there will be
+    // exactly 3 candidates in both |candidates_| and |ready_candidates|.
+    EXPECT_EQ(3U, candidates_.size());
+    const std::vector<Candidate>& ready_candidates =
+        session_->ReadyCandidates();
+    EXPECT_EQ(3U, ready_candidates.size());
+    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp", kClientAddr);
+    EXPECT_PRED4(HasCandidate, ready_candidates, "relay", "udp",
+                 rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
+  }
+
+  void TestEachInterfaceHasItsOwnTurnPorts() {
+    turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
+    turn_server_.AddInternalSocket(kTurnUdpIntIPv6Addr, PROTO_UDP);
+    turn_server_.AddInternalSocket(kTurnTcpIntIPv6Addr, PROTO_TCP);
+    // Add two interfaces both having IPv4 and IPv6 addresses.
+    AddInterface(kClientAddr, "net1", rtc::ADAPTER_TYPE_WIFI);
+    AddInterface(kClientIPv6Addr, "net1", rtc::ADAPTER_TYPE_WIFI);
+    AddInterface(kClientAddr2, "net2", rtc::ADAPTER_TYPE_CELLULAR);
+    AddInterface(kClientIPv6Addr2, "net2", rtc::ADAPTER_TYPE_CELLULAR);
+    allocator_.reset(new BasicPortAllocator(&network_manager_));
+    allocator_->SetConfiguration(allocator_->stun_servers(),
+                                 allocator_->turn_servers(), 0, true);
+    // Have both UDP/TCP and IPv4/IPv6 TURN ports.
+    AddTurnServers(kTurnUdpIntAddr, kTurnTcpIntAddr);
+    AddTurnServers(kTurnUdpIntIPv6Addr, kTurnTcpIntIPv6Addr);
+
+    allocator_->set_step_delay(kMinimumStepDelay);
+    allocator_->set_flags(allocator().flags() |
+                          PORTALLOCATOR_ENABLE_SHARED_SOCKET |
+                          PORTALLOCATOR_ENABLE_IPV6);
+    EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
+    session_->StartGettingPorts();
+    EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
+    // 10 ports (4 STUN and 1 TURN ports on each interface) will be ready to
+    // use.
+    EXPECT_EQ(10U, session_->ReadyPorts().size());
+    EXPECT_EQ(10U, ports_.size());
+    EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientAddr));
+    EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientAddr2));
+    EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientIPv6Addr));
+    EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientIPv6Addr2));
+    EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_TCP, kClientAddr));
+    EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_TCP, kClientAddr2));
+    EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_TCP, kClientIPv6Addr));
+    EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_TCP, kClientIPv6Addr2));
+    EXPECT_EQ(1, CountPorts(ports_, "relay", PROTO_UDP, kClientIPv6Addr));
+    EXPECT_EQ(1, CountPorts(ports_, "relay", PROTO_UDP, kClientIPv6Addr2));
+
+    // Now that we remove candidates when TURN ports are pruned, there will be
+    // exactly 10 candidates in |candidates_|.
+    EXPECT_EQ(10U, candidates_.size());
+    const std::vector<Candidate>& ready_candidates =
+        session_->ReadyCandidates();
+    EXPECT_EQ(10U, ready_candidates.size());
+    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp", kClientAddr);
+    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp", kClientAddr2);
+    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp",
+                 kClientIPv6Addr);
+    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp",
+                 kClientIPv6Addr2);
+    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "tcp", kClientAddr);
+    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "tcp", kClientAddr2);
+    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "tcp",
+                 kClientIPv6Addr);
+    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "tcp",
+                 kClientIPv6Addr2);
+    EXPECT_PRED4(HasCandidate, ready_candidates, "relay", "udp",
+                 rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
+  }
+
   std::unique_ptr<rtc::PhysicalSocketServer> pss_;
   std::unique_ptr<rtc::VirtualSocketServer> vss_;
   std::unique_ptr<rtc::FirewallSocketServer> fss_;
   rtc::SocketServerScope ss_scope_;
   std::unique_ptr<rtc::NATServer> nat_server_;
   rtc::NATSocketFactory nat_factory_;
   std::unique_ptr<rtc::BasicPacketSocketFactory> nat_socket_factory_;
   std::unique_ptr<TestStunServer> stun_server_;
   TestRelayServer relay_server_;
   TestTurnServer turn_server_;
@@ skipping 712 matching lines @@
   ASSERT_EQ(3U, ports_.size());
   EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
   EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp",
                rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
   EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp",
                rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
   EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
   EXPECT_EQ(3U, candidates_.size());
 }
 
-// Test that if prune_turn_ports is set, TCP TurnPort will not
-// be used if UDP TurnPort is used.
-TEST_F(BasicPortAllocatorTest, TestUdpTurnPortPrunesTcpTurnPorts) {
-  turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
-  AddInterface(kClientAddr);
-  allocator_.reset(new BasicPortAllocator(&network_manager_));
-  allocator_->SetConfiguration(allocator_->stun_servers(),
-                               allocator_->turn_servers(), 0, true);
-  AddTurnServers(kTurnUdpIntAddr, kTurnTcpIntAddr);
-  allocator_->set_step_delay(kMinimumStepDelay);
-  allocator_->set_flags(allocator().flags() |
-                        PORTALLOCATOR_ENABLE_SHARED_SOCKET |
-                        PORTALLOCATOR_DISABLE_TCP);
+// Test that if prune_turn_ports is set, TCP TURN port will not be used
+// if UDP TurnPort is used, given that TCP TURN port becomes ready first.
+TEST_F(BasicPortAllocatorTest,
+       TestUdpTurnPortPrunesTcpTurnPortWithTcpPortReadyFirst) {
+  // UDP has longer delay than TCP so that TCP TURN port becomes ready first.
+  virtual_socket_server()->SetDelayOnAddress(kTurnUdpIntAddr, 200);
+  virtual_socket_server()->SetDelayOnAddress(kTurnTcpIntAddr, 100);
 
-  EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
-  session_->StartGettingPorts();
-  EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
-  // Only 2 ports (one STUN and one TURN) are actually being used.
-  EXPECT_EQ(2U, session_->ReadyPorts().size());
-  // We have verified that each port, when it is added to |ports_|, it is found
-  // in |ready_ports|, and when it is pruned, it is not found in |ready_ports|,
-  // so we only need to verify the content in one of them.
-  EXPECT_EQ(2U, ports_.size());
-  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientAddr));
-  EXPECT_EQ(1, CountPorts(ports_, "relay", PROTO_UDP, kClientAddr));
-  EXPECT_EQ(0, CountPorts(ports_, "relay", PROTO_TCP, kClientAddr));
-
-  // We don't remove candidates, so the size of |candidates_| will depend on
-  // when the TCP TURN port becomes ready. If it is ready after the UDP TURN
-  // port becomes ready, its candidates will be used there will be 3 candidates.
-  // Otherwise there will be only 2 candidates.
-  EXPECT_LE(2U, candidates_.size());
-  // There will only be 2 candidates in |ready_candidates| because it only
-  // includes the candidates in the ready ports.
-  const std::vector<Candidate>& ready_candidates = session_->ReadyCandidates();
-  EXPECT_EQ(2U, ready_candidates.size());
-  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp", kClientAddr);
-  EXPECT_PRED4(HasCandidate, ready_candidates, "relay", "udp",
-               rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
+  TestUdpTurnPortPrunesTcpTurnPort();
 }
 
-// Tests that if prune_turn_ports is set, IPv4 TurnPort will not
-// be used if IPv6 TurnPort is used.
-TEST_F(BasicPortAllocatorTest, TestIPv6TurnPortPrunesIPv4TurnPorts) {
-  turn_server_.AddInternalSocket(kTurnUdpIntIPv6Addr, PROTO_UDP);
-  // Add two IP addresses on the same interface.
-  AddInterface(kClientAddr, "net1");
-  AddInterface(kClientIPv6Addr, "net1");
-  allocator_.reset(new BasicPortAllocator(&network_manager_));
-  allocator_->SetConfiguration(allocator_->stun_servers(),
-                               allocator_->turn_servers(), 0, true);
-  AddTurnServers(kTurnUdpIntIPv6Addr, rtc::SocketAddress());
+// Test that if prune_turn_ports is set, TCP TURN port will not be used
+// if UDP TurnPort is used, given that UDP TURN port becomes ready first.
+TEST_F(BasicPortAllocatorTest,
+       TestUdpTurnPortPrunesTcpTurnPortsWithUdpPortReadyFirst) {
+  // UDP has shorter delay than TCP so that UDP TURN port becomes ready first.
+  virtual_socket_server()->SetDelayOnAddress(kTurnUdpIntAddr, 100);
+  virtual_socket_server()->SetDelayOnAddress(kTurnTcpIntAddr, 200);
 
-  allocator_->set_step_delay(kMinimumStepDelay);
-  allocator_->set_flags(allocator().flags() |
-                        PORTALLOCATOR_ENABLE_SHARED_SOCKET |
-                        PORTALLOCATOR_ENABLE_IPV6 | PORTALLOCATOR_DISABLE_TCP);
+  TestUdpTurnPortPrunesTcpTurnPort();
+}
 
-  EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
-  session_->StartGettingPorts();
-  EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
-  // Three ports (one IPv4 STUN, one IPv6 STUN and one TURN) will be ready.
-  EXPECT_EQ(3U, session_->ReadyPorts().size());
-  EXPECT_EQ(3U, ports_.size());
-  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientAddr));
-  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientIPv6Addr));
-  EXPECT_EQ(1, CountPorts(ports_, "relay", PROTO_UDP, kClientIPv6Addr));
-  EXPECT_EQ(0, CountPorts(ports_, "relay", PROTO_UDP, kClientAddr));
+// Tests that if prune_turn_ports is set, IPv4 TurnPort will not be used
+// if IPv6 TurnPort is used, given that IPv4 TURN port becomes ready first.
+TEST_F(BasicPortAllocatorTest,
+       TestIPv6TurnPortPrunesIPv4TurnPortWithIPv4PortReadyFirst) {
+  // IPv6 has longer delay than IPv4, so that IPv4 TURN port becomes ready
+  // first.
+  virtual_socket_server()->SetDelayOnAddress(kTurnUdpIntAddr, 100);
+  virtual_socket_server()->SetDelayOnAddress(kTurnUdpIntIPv6Addr, 200);
 
-  // We don't remove candidates, so there may be more than 3 elemenets in
-  // |candidates_|, although |ready_candidates| only includes the candidates
-  // in |ready_ports|.
-  EXPECT_LE(3U, candidates_.size());
-  const std::vector<Candidate>& ready_candidates = session_->ReadyCandidates();
-  EXPECT_EQ(3U, ready_candidates.size());
-  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp", kClientAddr);
-  EXPECT_PRED4(HasCandidate, ready_candidates, "relay", "udp",
-               rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
+  TestIPv6TurnPortPrunesIPv4TurnPort();
+}
+
+// Tests that if prune_turn_ports is set, IPv4 TurnPort will not be used
+// if IPv6 TurnPort is used, given that IPv6 TURN port becomes ready first.
+TEST_F(BasicPortAllocatorTest,
+       TestIPv6TurnPortPrunesIPv4TurnPortWithIPv6PortReadyFirst) {
+  // IPv6 has longer delay than IPv4, so that IPv6 TURN port becomes ready
+  // first.
+  virtual_socket_server()->SetDelayOnAddress(kTurnUdpIntAddr, 200);
+  virtual_socket_server()->SetDelayOnAddress(kTurnUdpIntIPv6Addr, 100);
+
+  TestIPv6TurnPortPrunesIPv4TurnPort();
 }
 
 // Tests that if prune_turn_ports is set, each network interface
-// will has its own set of TurnPorts based on their priorities.
-TEST_F(BasicPortAllocatorTest, TestEachInterfaceHasItsOwnTurnPorts) {
-  turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
-  turn_server_.AddInternalSocket(kTurnUdpIntIPv6Addr, PROTO_UDP);
-  turn_server_.AddInternalSocket(kTurnTcpIntIPv6Addr, PROTO_TCP);
-  // Add two interfaces both having IPv4 and IPv6 addresses.
-  AddInterface(kClientAddr, "net1", rtc::ADAPTER_TYPE_WIFI);
-  AddInterface(kClientIPv6Addr, "net1", rtc::ADAPTER_TYPE_WIFI);
-  AddInterface(kClientAddr2, "net2", rtc::ADAPTER_TYPE_CELLULAR);
-  AddInterface(kClientIPv6Addr2, "net2", rtc::ADAPTER_TYPE_CELLULAR);
-  allocator_.reset(new BasicPortAllocator(&network_manager_));
-  allocator_->SetConfiguration(allocator_->stun_servers(),
-                               allocator_->turn_servers(), 0, true);
-  // Have both UDP/TCP and IPv4/IPv6 TURN ports.
-  AddTurnServers(kTurnUdpIntAddr, kTurnTcpIntAddr);
-  AddTurnServers(kTurnUdpIntIPv6Addr, kTurnTcpIntIPv6Addr);
+// will has its own set of TurnPorts based on their priorities, in the default
+// case where no transit delay is set.
+TEST_F(BasicPortAllocatorTest, TestEachInterfaceHasItsOwnTurnPortsNoDelay) {
+  TestEachInterfaceHasItsOwnTurnPorts();
+}
 
-  allocator_->set_step_delay(kMinimumStepDelay);
-  allocator_->set_flags(allocator().flags() |
-                        PORTALLOCATOR_ENABLE_SHARED_SOCKET |
-                        PORTALLOCATOR_ENABLE_IPV6);
-  EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
-  session_->StartGettingPorts();
-  EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
-  // 10 ports (4 STUN and 1 TURN ports on each interface) will be ready to use.
-  EXPECT_EQ(10U, session_->ReadyPorts().size());
-  EXPECT_EQ(10U, ports_.size());
-  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientAddr));
-  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientAddr2));
-  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientIPv6Addr));
-  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_UDP, kClientIPv6Addr2));
-  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_TCP, kClientAddr));
-  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_TCP, kClientAddr2));
-  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_TCP, kClientIPv6Addr));
-  EXPECT_EQ(1, CountPorts(ports_, "local", PROTO_TCP, kClientIPv6Addr2));
-  EXPECT_EQ(1, CountPorts(ports_, "relay", PROTO_UDP, kClientIPv6Addr));
-  EXPECT_EQ(1, CountPorts(ports_, "relay", PROTO_UDP, kClientIPv6Addr2));
+// Tests that if prune_turn_ports is set, each network interface
+// will has its own set of TurnPorts based on their priorities, given that
+// IPv4/TCP TURN port becomes ready first.
+TEST_F(BasicPortAllocatorTest,
+       TestEachInterfaceHasItsOwnTurnPortsWithTcpIPv4ReadyFirst) {
+  // IPv6/UDP have longer delay than IPv4/TCP, so that IPv4/TCP TURN port
+  // becomes ready last.
+  virtual_socket_server()->SetDelayOnAddress(kTurnTcpIntAddr, 10);
+  virtual_socket_server()->SetDelayOnAddress(kTurnUdpIntAddr, 100);
+  virtual_socket_server()->SetDelayOnAddress(kTurnTcpIntIPv6Addr, 20);
+  virtual_socket_server()->SetDelayOnAddress(kTurnUdpIntIPv6Addr, 300);
 
-  // We don't remove candidates, so there may be more than 10 candidates
-  // in |candidates_|.
-  EXPECT_LE(10U, candidates_.size());
-  const std::vector<Candidate>& ready_candidates = session_->ReadyCandidates();
-  EXPECT_EQ(10U, ready_candidates.size());
-  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp", kClientAddr);
-  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp", kClientAddr2);
-  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp", kClientIPv6Addr);
-  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp",
-               kClientIPv6Addr2);
-  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "tcp", kClientAddr);
-  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "tcp", kClientAddr2);
-  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "tcp", kClientIPv6Addr);
-  EXPECT_PRED4(HasCandidate, ready_candidates, "local", "tcp",
-               kClientIPv6Addr2);
-  EXPECT_PRED4(HasCandidate, ready_candidates, "relay", "udp",
-               rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
+  TestEachInterfaceHasItsOwnTurnPorts();
 }
 
 // Testing DNS resolve for the TURN server, this will test AllocationSequence
 // handling the unresolved address signal from TurnPort.
 TEST_F(BasicPortAllocatorTest, TestSharedSocketWithServerAddressResolve) {
   turn_server_.AddInternalSocket(rtc::SocketAddress("127.0.0.1", 3478),
                                  PROTO_UDP);
   AddInterface(kClientAddr);
   allocator_.reset(new BasicPortAllocator(&network_manager_));
   RelayServerConfig turn_server(RELAY_TURN);
@@ skipping 347 matching lines @@
   for (const Candidate& candidate : candidates) {
     // Expect only relay candidates now that the filter is applied.
     EXPECT_EQ(std::string(RELAY_PORT_TYPE), candidate.type());
     // Expect that the raddr is emptied due to the CF_RELAY filter.
     EXPECT_EQ(candidate.related_address(),
               rtc::EmptySocketAddressWithFamily(candidate.address().family()));
   }
 }
 
 }  // namespace cricket