Do not delete a connection until it has not received anything for 30 seconds.

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 1217 matching lines @@
 /* TODO: Enable these once testrelayserver can accept external SSL.
 TEST_F(PortTest, TestSslTcpToTcpRelay) {
   TestSslTcpToRelay(PROTO_TCP);
 }
 
 TEST_F(PortTest, TestSslTcpToSslTcpRelay) {
   TestSslTcpToRelay(PROTO_SSLTCP);
 }
 */
 
+// Test that a connection will be dead and deleted if
+// i) it was pruned (a.k.a, write-timeout) and has never received anything
+//    for MIN_CONNECTION_LIFETIME milliseconds since it was created, or
+// ii) it was pruned and has not received anything for
+//     DEAD_CONNECTION_RECEIVE_TIMEOUT milliseconds since last receiving.

[pthatcher1, 2015/11/11 21:04:54]

Both of these say it has to be pruned first, but I don't think that's true. 
Even if it's not pruned, if doesn't receive a ping response for 30s, it will be
deleted because it goes to write timeout, right?

[honghaiz3, 2015/11/12 00:27:10]

That condition was related to my original code. 

+TEST_F(PortTest, TestConnectionDead) {
+  UDPPort* port1 = CreateUdpPort(kLocalAddr1);
+  UDPPort* port2 = CreateUdpPort(kLocalAddr2);
+  TestChannel ch1(port1);
+  TestChannel ch2(port2);
+  // Acquire address.
+  ch1.Start();
+  ch2.Start();
+  ASSERT_EQ_WAIT(1, ch1.complete_count(), kTimeout);
+  ASSERT_EQ_WAIT(1, ch2.complete_count(), kTimeout);
+
+  uint32_t before_created = rtc::Time();
+  ch1.CreateConnection(GetCandidate(port2));
+  uint32_t after_created = rtc::Time();
+  Connection* conn = ch1.conn();
+  ASSERT(conn != nullptr);
+  conn->Prune();  // Simulate write-time-out.
+  // If the connection has never received anything, it will be dead after
+  // MIN_CONNECTION_LIFETIME
+  conn->UpdateState(before_created + MIN_CONNECTION_LIFETIME - 1);
+  rtc::Thread::Current()->ProcessMessages(100);
+  EXPECT_TRUE(ch1.conn() != nullptr);
+  conn->UpdateState(after_created + MIN_CONNECTION_LIFETIME + 1);
+  EXPECT_TRUE_WAIT(ch1.conn() == nullptr, kTimeout);
+
+  // Create a connection again and receive a ping.
+  ch1.CreateConnection(GetCandidate(port2));
+  conn = ch1.conn();
+  ASSERT(conn != nullptr);
+  conn->Prune();  // Simulate write-time-out.
+  uint32_t before_last_receiving = rtc::Time();
+  conn->ReceivedPing();
+  uint32_t after_last_receiving = rtc::Time();
+  // The connection will be dead after DEAD_CONNECTION_RECEIVE_TIMEOUT
+  conn->UpdateState(
+      before_last_receiving + DEAD_CONNECTION_RECEIVE_TIMEOUT - 1);
+  rtc::Thread::Current()->ProcessMessages(100);
+  EXPECT_TRUE(ch1.conn() != nullptr);
+  conn->UpdateState(after_last_receiving + DEAD_CONNECTION_RECEIVE_TIMEOUT + 1);
+  EXPECT_TRUE_WAIT(ch1.conn() == nullptr, kTimeout);
+}
+
 // This test case verifies standard ICE features in STUN messages. Currently it
 // verifies Message Integrity attribute in STUN messages and username in STUN
 // binding request will have colon (":") between remote and local username.
 TEST_F(PortTest, TestLocalToLocalStandard) {
   UDPPort* port1 = CreateUdpPort(kLocalAddr1);
   port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
   port1->SetIceTiebreaker(kTiebreaker1);
   UDPPort* port2 = CreateUdpPort(kLocalAddr2);
   port2->SetIceRole(cricket::ICEROLE_CONTROLLED);
   port2->SetIceTiebreaker(kTiebreaker2);
@@ skipping 1195 matching lines @@
   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());
 }