Do not delete the turn port entry right away when the respective connection is deleted.

webrtc/p2p/base/turnport_unittest.cc

 /*
  *  Copyright 2012 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.
  */
 #if defined(WEBRTC_POSIX)
@@ skipping 367 matching lines @@
     EXPECT_TRUE(conn1->receiving());
     EXPECT_TRUE(conn2->receiving());
     EXPECT_EQ(Connection::STATE_WRITE_INIT, conn1->write_state());
 
     // Send another ping from UDP to TURN.
     conn1->Ping(0);
     EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, conn1->write_state(), kTimeout);
     EXPECT_TRUE(conn2->receiving());
   }
 
+  void TestDestroyTurnConnection() {
+    turn_port_->PrepareAddress();
+    ASSERT_TRUE_WAIT(turn_ready_, kTimeout);
+    // Create a remote UDP port
+    CreateUdpPort();
+    udp_port_->PrepareAddress();
+    ASSERT_TRUE_WAIT(udp_ready_, kTimeout);
+
+    // Create connections on both ends.
+    Connection* conn1 = udp_port_->CreateConnection(turn_port_->Candidates()[0],
+                                                    Port::ORIGIN_MESSAGE);
+    Connection* conn2 = turn_port_->CreateConnection(udp_port_->Candidates()[0],
+                                                     Port::ORIGIN_MESSAGE);
+    ASSERT_TRUE(conn2 != NULL);
+    ASSERT_TRUE_WAIT(turn_create_permission_success_, kTimeout);
+    // Make sure turn connection can receive.
+    conn1->Ping(0);
+    EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, conn1->write_state(), kTimeout);
+    EXPECT_FALSE(turn_unknown_address_);
+
+    // Now destroy the connection on the turn port. The TurnEntry is still
+    // there. So the turn port gets ping from unknown address if it is pinged.
+    conn2->Destroy();
+    conn1->Ping(0);
+    EXPECT_TRUE_WAIT(turn_unknown_address_, kTimeout);
+
+    // If the connection is created again, it will start to receive pings.
+    turn_unknown_address_ = false;
+    conn2 = turn_port_->CreateConnection(udp_port_->Candidates()[0],
+                                         Port::ORIGIN_MESSAGE);
+    conn1->Ping(0);
+    EXPECT_TRUE_WAIT(conn2->receiving(), kTimeout);
+    EXPECT_FALSE(turn_unknown_address_);
+    // Check that the message posted by the invoker is deleted.
+    rtc::MessageList removed;
+    rtc::Thread::Current()->Clear(turn_port_->invoker(), rtc::MQID_ANY,
+                                  &removed);
+    EXPECT_TRUE(removed.empty());
+
+    // Now destroy conn2 and Flush the invoker. The turn port will not be able
+    // to receive the ping message.
+    turn_unknown_address_ = false;
+    conn1->set_receiving_timeout(400);
+    conn2->Destroy();
+    // Send the destroy message to the message queue.
+    rtc::Thread::Current()->ProcessMessages(0);
+    turn_port_->invoker()->Flush(rtc::Thread::Current());
+    // Ensure it is not receiving.
+    rtc::Thread::Current()->ProcessMessages(500);

[pthatcher1, 2015/11/11 01:08:41]

This could end up being flaky.  Could we use EXPECT_TRUE_WAIT here instead so it
waits long enough?  Same with the ProcessMessages(100) below.

[honghaiz3, 2015/11/11 23:02:55]

Done. Cann't use the EXPECT_TRUE_WAIT because we are not waiting for changes. 

+    conn1->UpdateState(rtc::Time());
+    conn1->Ping(0);
+    rtc::Thread::Current()->ProcessMessages(100);
+    EXPECT_FALSE(conn1->receiving());
+    EXPECT_FALSE(turn_unknown_address_);
+  }
+
   void TestTurnSendData() {
     turn_port_->PrepareAddress();
     EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
     CreateUdpPort();
     udp_port_->PrepareAddress();
     EXPECT_TRUE_WAIT(udp_ready_, kTimeout);
     // Create connections and send pings.
     Connection* conn1 = turn_port_->CreateConnection(
         udp_port_->Candidates()[0], Port::ORIGIN_MESSAGE);
     Connection* conn2 = udp_port_->CreateConnection(
@@ skipping 289 matching lines @@
   TestTurnConnection();
 }
 
 // Test that we can establish a TCP connection with TURN server.
 TEST_F(TurnPortTest, TestTurnTcpConnection) {
   turn_server_.AddInternalSocket(kTurnTcpIntAddr, cricket::PROTO_TCP);
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
   TestTurnConnection();
 }
 
+// Test that if a connection on a TURN port is destroyed, the TURN port can
+// still receive ping on that connection as if it is from an unknown address.
+// If the connection is created again, it will be used to receive ping.
+TEST_F(TurnPortTest, TestDestoryTurnConnection) {
+  CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
+  TestDestroyTurnConnection();
+}
+
+// Similar to above, except that this test will use the shared socket.
+TEST_F(TurnPortTest, TestDestoryTurnConnectionUsingSharedSocket) {
+  CreateSharedTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
+  TestDestroyTurnConnection();
+}
+
 // Test that we fail to create a connection when we want to use TLS over TCP.
 // This test should be removed once we have TLS support.
 TEST_F(TurnPortTest, TestTurnTlsTcpConnectionFails) {
   cricket::ProtocolAddress secure_addr(kTurnTcpProtoAddr.address,
                                        kTurnTcpProtoAddr.proto,
                                        true);
   CreateTurnPort(kTurnUsername, kTurnPassword, secure_addr);
   turn_port_->PrepareAddress();
   EXPECT_TRUE_WAIT(turn_error_, kTimeout);
   ASSERT_EQ(0U, turn_port_->Candidates().size());
@@ skipping 100 matching lines @@
   turn_port_->PrepareAddress();
   ASSERT_TRUE_WAIT(turn_error_, kTimeout);
   EXPECT_TRUE(turn_port_->Candidates().empty());
   turn_port_.reset();
   rtc::Thread::Current()->Post(this, MSG_TESTFINISH);
   // Waiting for above message to be processed.
   ASSERT_TRUE_WAIT(test_finish_, kTimeout);
   EXPECT_EQ(last_fd_count, GetFDCount());
 }
 #endif