Remove ports that are not used by any channel after timeout

webrtc/p2p/base/port_unittest.cc

 /*
  *  Copyright 2004 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 366 matching lines @@
         relay_server_(main_,
                       kRelayUdpIntAddr,
                       kRelayUdpExtAddr,
                       kRelayTcpIntAddr,
                       kRelayTcpExtAddr,
                       kRelaySslTcpIntAddr,
                       kRelaySslTcpExtAddr),
         username_(rtc::CreateRandomString(ICE_UFRAG_LENGTH)),
         password_(rtc::CreateRandomString(ICE_PWD_LENGTH)),
         role_conflict_(false),
-        destroyed_(false) {
+        ports_destroyed_(0) {
     network_.AddIP(rtc::IPAddress(INADDR_ANY));
   }
 
  protected:
   void TestLocalToLocal() {
     Port* port1 = CreateUdpPort(kLocalAddr1);
     port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
     Port* port2 = CreateUdpPort(kLocalAddr2);
     port2->SetIceRole(cricket::ICEROLE_CONTROLLED);
     TestConnectivity("udp", port1, "udp", port2, true, true, true, true);
@@ skipping 350 matching lines @@
 
   void OnRoleConflict(PortInterface* port) {
     role_conflict_ = true;
   }
   bool role_conflict() const { return role_conflict_; }
 
   void ConnectToSignalDestroyed(PortInterface* port) {
     port->SignalDestroyed.connect(this, &PortTest::OnDestroyed);
   }
 
-  void OnDestroyed(PortInterface* port) {
-    destroyed_ = true;
-  }
-  bool destroyed() const { return destroyed_; }
+  void OnDestroyed(PortInterface* port) { ++ports_destroyed_; }
+  int ports_destroyed() const { return ports_destroyed_; }
 
   rtc::BasicPacketSocketFactory* nat_socket_factory1() {
     return &nat_socket_factory1_;
   }
 
   rtc::VirtualSocketServer* vss() { return ss_.get(); }
 
  private:
   rtc::Thread* main_;
   std::unique_ptr<rtc::PhysicalSocketServer> pss_;
   std::unique_ptr<rtc::VirtualSocketServer> ss_;
   rtc::SocketServerScope ss_scope_;
   rtc::Network network_;
   rtc::BasicPacketSocketFactory socket_factory_;
   std::unique_ptr<rtc::NATServer> nat_server1_;
   std::unique_ptr<rtc::NATServer> nat_server2_;
   rtc::NATSocketFactory nat_factory1_;
   rtc::NATSocketFactory nat_factory2_;
   rtc::BasicPacketSocketFactory nat_socket_factory1_;
   rtc::BasicPacketSocketFactory nat_socket_factory2_;
   std::unique_ptr<TestStunServer> stun_server_;
   TestTurnServer turn_server_;
   TestRelayServer relay_server_;
   std::string username_;
   std::string password_;
   bool role_conflict_;
-  bool destroyed_;
+  int ports_destroyed_;
 };
 
 void PortTest::TestConnectivity(const char* name1, Port* port1,
                                 const char* name2, Port* port2,
                                 bool accept, bool same_addr1,
                                 bool same_addr2, bool possible) {
   LOG(LS_INFO) << "Test: " << name1 << " to " << name2 << ": ";
   port1->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
   port2->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
 
@@ skipping 1761 matching lines @@
   // message right after we send ping.
   ice_full_port->Reset();
   // Send ping. This must have USE_CANDIDATE_ATTR.
   ch1.Ping();
   ASSERT_TRUE_WAIT(ice_full_port->last_stun_msg() != NULL, 1000);
   msg = ice_full_port->last_stun_msg();
   EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) != NULL);
   ch1.Stop();
 }
 
-// This test case verifies that the CONTROLLING port does not time out.
-TEST_F(PortTest, TestControllingNoTimeout) {
+// This test case verifies that both the controlling port and the controlled
+// port will time out after connectivity is lost, if they are not marked as
+// "keep alive until pruned."
+TEST_F(PortTest, TestPortTimeoutIfNotKeptAlive) {
+  rtc::ScopedFakeClock clock;
+  int timeout_delay = 100;
   UDPPort* port1 = CreateUdpPort(kLocalAddr1);
   ConnectToSignalDestroyed(port1);
-  port1->set_timeout_delay(10);  // milliseconds
+  port1->set_timeout_delay(timeout_delay);  // milliseconds
   port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
   port1->SetIceTiebreaker(kTiebreaker1);
 
   UDPPort* port2 = CreateUdpPort(kLocalAddr2);
+  ConnectToSignalDestroyed(port2);
+  port2->set_timeout_delay(timeout_delay);  // milliseconds
   port2->SetIceRole(cricket::ICEROLE_CONTROLLED);
   port2->SetIceTiebreaker(kTiebreaker2);
 
   // Set up channels and ensure both ports will be deleted.
   TestChannel ch1(port1);
   TestChannel ch2(port2);
 
   // Simulate a connection that succeeds, and then is destroyed.
   StartConnectAndStopChannels(&ch1, &ch2);
-
-  // After the connection is destroyed, the port should not be destroyed.
-  rtc::Thread::Current()->ProcessMessages(kTimeout);
-  EXPECT_FALSE(destroyed());
+  // After the connection is destroyed, the port will be destroyed because
+  // none of them is marked as "keep alive until pruned.
+  EXPECT_EQ_SIMULATED_WAIT(2, ports_destroyed(), 110, clock);
 }
 
-// This test case verifies that the CONTROLLED port does time out, but only
-// after connectivity is lost and no connection was created during the timeout
-// period.
-TEST_F(PortTest, TestControlledTimeout) {
+// Test that if after all connection are destroyed, new connections are created
+// and destroyed again, ports won't be destroyed until a timeout period passes
+// after the last set of connections are all destroyed.
+TEST_F(PortTest, TestPortTimeoutAfterNewConnectionCreatedAndDestroyed) {
   rtc::ScopedFakeClock clock;
+  int timeout_delay = 100;
   UDPPort* port1 = CreateUdpPort(kLocalAddr1);
+  ConnectToSignalDestroyed(port1);
+  port1->set_timeout_delay(timeout_delay);  // milliseconds
   port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
   port1->SetIceTiebreaker(kTiebreaker1);
 
   UDPPort* port2 = CreateUdpPort(kLocalAddr2);
   ConnectToSignalDestroyed(port2);
-  port2->set_timeout_delay(100);  // milliseconds
+  port2->set_timeout_delay(timeout_delay);  // milliseconds
+
   port2->SetIceRole(cricket::ICEROLE_CONTROLLED);
   port2->SetIceTiebreaker(kTiebreaker2);
 
-  // The connection must not be destroyed before a connection is attempted.
-  EXPECT_FALSE(destroyed());
-
-  port1->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
-  port2->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
-
   // Set up channels and ensure both ports will be deleted.
   TestChannel ch1(port1);
   TestChannel ch2(port2);
 
   // Simulate a connection that succeeds, and then is destroyed.
   StartConnectAndStopChannels(&ch1, &ch2);
+  SIMULATED_WAIT(ports_destroyed() > 0, 80, clock);
+  EXPECT_EQ(0, ports_destroyed());
 
-  SIMULATED_WAIT(false, 80, clock);
+  // Start the second set of connection and destroy them.
+  ch1.CreateConnection(GetCandidate(ch2.port()));
   ch2.CreateConnection(GetCandidate(ch1.port()));
+  ch1.Stop();
+  ch2.Stop();
 
-  // ch2 creates a connection so it will not be destroyed.
-  SIMULATED_WAIT(destroyed(), 80, clock);
-  EXPECT_FALSE(destroyed());
+  SIMULATED_WAIT(ports_destroyed() > 0, 80, clock);
+  EXPECT_EQ(0, ports_destroyed());
 
-  // Even if ch2 stops now, it won't be destroyed until 100ms after the
-  // connection is destroyed.
-  ch2.Stop();
-  SIMULATED_WAIT(destroyed(), 80, clock);
-  EXPECT_FALSE(destroyed());
-
-  // The controlled port should be destroyed after timeout.
-  EXPECT_TRUE_SIMULATED_WAIT(destroyed(), 30, clock);
+  // The ports on both sides should be destroyed after timeout.
+  EXPECT_TRUE_SIMULATED_WAIT(ports_destroyed() == 2, 30, clock);
 }
 
-// This test case verifies that if the role of a port changes from controlled
-// to controlling after all connections fail, the port will not be destroyed.
-TEST_F(PortTest, TestControlledToControllingNotDestroyed) {
+// This test case verifies that neither the controlling port nor the controlled
+// port will time out after connectivity is lost if they are marked as "keep
+// alive until pruned". They will time out after they are pruned.
+TEST_F(PortTest, TestPortNotTimeoutUntilPruned) {
+  rtc::ScopedFakeClock clock;
+  int timeout_delay = 100;
   UDPPort* port1 = CreateUdpPort(kLocalAddr1);
+  ConnectToSignalDestroyed(port1);
+  port1->set_timeout_delay(timeout_delay);  // milliseconds
   port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
   port1->SetIceTiebreaker(kTiebreaker1);
 
   UDPPort* port2 = CreateUdpPort(kLocalAddr2);
   ConnectToSignalDestroyed(port2);
-  port2->set_timeout_delay(10);  // milliseconds
+  port2->set_timeout_delay(timeout_delay);  // milliseconds
   port2->SetIceRole(cricket::ICEROLE_CONTROLLED);
   port2->SetIceTiebreaker(kTiebreaker2);
-
   // The connection must not be destroyed before a connection is attempted.
-  EXPECT_FALSE(destroyed());
+  EXPECT_EQ(0, ports_destroyed());
 
   port1->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
   port2->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
 
-  // Set up channels and ensure both ports will be deleted.
+  // Set up channels and keep the port alive.
   TestChannel ch1(port1);
   TestChannel ch2(port2);
+  // Simulate a connection that succeeds, and then is destroyed. But ports
+  // are kept alive. Ports won't be destroyed.
+  StartConnectAndStopChannels(&ch1, &ch2);
+  port1->KeepAliveUntilPruned();
+  port2->KeepAliveUntilPruned();
+  SIMULATED_WAIT(ports_destroyed() > 0, 150, clock);
+  EXPECT_EQ(0, ports_destroyed());
 
-  // Simulate a connection that succeeds, and then is destroyed.
-  StartConnectAndStopChannels(&ch1, &ch2);
-  // Switch the role after all connections are destroyed.
-  EXPECT_TRUE_WAIT(ch2.conn() == nullptr, kTimeout);
-  port1->SetIceRole(cricket::ICEROLE_CONTROLLED);
-  port2->SetIceRole(cricket::ICEROLE_CONTROLLING);
-
-  // After the connection is destroyed, the port should not be destroyed.
-  rtc::Thread::Current()->ProcessMessages(kTimeout);
-  EXPECT_FALSE(destroyed());
+  // If they are pruned now, they will be destroyed right away.
+  port1->Prune();
+  port2->Prune();
+  // The ports on both sides should be destroyed after timeout.
+  EXPECT_TRUE_SIMULATED_WAIT(ports_destroyed() == 2, 1, clock);
 }
 
 TEST_F(PortTest, TestSupportsProtocol) {
   std::unique_ptr<Port> udp_port(CreateUdpPort(kLocalAddr1));
   EXPECT_TRUE(udp_port->SupportsProtocol(UDP_PROTOCOL_NAME));
   EXPECT_FALSE(udp_port->SupportsProtocol(TCP_PROTOCOL_NAME));
 
   std::unique_ptr<Port> stun_port(
       CreateStunPort(kLocalAddr1, nat_socket_factory1()));
   EXPECT_TRUE(stun_port->SupportsProtocol(UDP_PROTOCOL_NAME));
@@ skipping 47 matching lines @@
       port->CreateConnection(candidate, Port::ORIGIN_MESSAGE);
   EXPECT_NE(conn1, conn2);
   conn_in_use = port->GetConnection(address);
   EXPECT_EQ(conn2, conn_in_use);
   EXPECT_EQ(2u, conn_in_use->remote_candidate().generation());
 
   // Make sure the new connection was not deleted.
   rtc::Thread::Current()->ProcessMessages(300);
   EXPECT_TRUE(port->GetConnection(address) != nullptr);
 }