Schedule a CreatePermissionRequest after the success of a previous request

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 TestRefreshCreatePermissionRequest() {
+    ASSERT_TRUE(turn_port_ != NULL);
+    turn_port_->PrepareAddress();
+    ASSERT_TRUE_WAIT(turn_ready_, kTimeout);
+    CreateUdpPort();
+    udp_port_->PrepareAddress();
+    ASSERT_TRUE_WAIT(udp_ready_, kTimeout);
+
+    Connection* conn = turn_port_->CreateConnection(udp_port_->Candidates()[0],
+                                                    Port::ORIGIN_MESSAGE);
+    ASSERT_TRUE(conn != NULL);
+    ASSERT_TRUE_WAIT(turn_create_permission_success_, kTimeout);
+    turn_create_permission_success_ = false;
+    // A create-permission-request should be pending.
+    turn_port_->FlushRequests();
+    ASSERT_TRUE_WAIT(turn_create_permission_success_, kTimeout);

[pthatcher1, 2015/11/11 20:22:09]

Unfortunately, this doesn't test *when* the permission refresh will be sent.  Is
there some way we could test that?

[honghaiz3, 2015/11/11 23:51:58]

It is pretty hard to test that. We don't want to wait for 4 minutes in the
tests.
In order to test that, we will need to 
1. create a member variable turn_permission_timeout_ and change it to a smaller
value in the tests and wait until it fires. 
But that's not too much different from FlushRequests here because we are not
testing the actually scheduled time in the implementation. 

+  }
+
   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 310 matching lines @@
 
 // Run TurnConnectionTest with one-time-use nonce feature.
 // Here server will send a 438 STALE_NONCE error message for
 // every TURN transaction.
 TEST_F(TurnPortTest, TestTurnConnectionUsingOTUNonce) {
   turn_server_.set_enable_otu_nonce(true);
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
   TestTurnConnection();
 }
 
+// Test that CreatePermissionRequest will be scheduled after the success
+// of the first create permission request.
+TEST_F(TurnPortTest, TestRefreshCreatePermissionRequest) {
+  CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
+  TestRefreshCreatePermissionRequest();

[pthatcher1, 2015/11/11 20:22:09]

Why did you put this in a separate method?  Why not just put it here?

[honghaiz3, 2015/11/11 23:51:59]

Done.

+}
+
 // Do a TURN allocation, establish a UDP connection, and send some data.
 TEST_F(TurnPortTest, TestTurnSendDataTurnUdpToUdp) {
   // Create ports and prepare addresses.
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
   TestTurnSendData();
   EXPECT_EQ(cricket::UDP_PROTOCOL_NAME,
             turn_port_->Candidates()[0].relay_protocol());
 }
 
 // Do a TURN allocation, establish a TCP connection, and send some data.
@@ skipping 79 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