Cease all future TURN requests when a TURN refresh request fails.

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 291 matching lines @@
     ASSERT_TRUE(turn_port_ != nullptr);
     turn_port_->PrepareAddress();
     ASSERT_TRUE_WAIT(turn_ready_, kTimeout);
 
     CreateUdpPort();
     udp_port_->PrepareAddress();
     ASSERT_TRUE_WAIT(udp_ready_, kTimeout);
   }
 
   bool CheckConnectionDestroyed() {
-    turn_port_->FlushRequests();
+    turn_port_->FlushRequests(cricket::kAllRequests);
     rtc::Thread::Current()->ProcessMessages(50);
     return connection_destroyed_;
   }
 
   void TestTurnAlternateServer(cricket::ProtocolType protocol_type) {
     std::vector<rtc::SocketAddress> redirect_addresses;
     redirect_addresses.push_back(kTurnAlternateIntAddr);
 
     cricket::TestTurnRedirector redirector(redirect_addresses);
 
@@ skipping 363 matching lines @@
   EXPECT_EQ(first_addr, turn_port_->socket()->GetLocalAddress());
 
   EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
 
   // Verifies that the new port has a different address now.
   EXPECT_NE(first_addr, turn_port_->socket()->GetLocalAddress());
 }
 
 TEST_F(TurnPortTest, TestRefreshRequestGetsErrorResponse) {
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
-  turn_port_->PrepareAddress();
-  EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
+  PrepareTurnAndUdpPorts();
+  turn_port_->CreateConnection(udp_port_->Candidates()[0],
+                               Port::ORIGIN_MESSAGE);
   // Set bad credentials.
   cricket::RelayCredentials bad_credentials("bad_user", "bad_pwd");
   turn_port_->set_credentials(bad_credentials);
   turn_refresh_success_ = false;
   // This sends out the first RefreshRequest with correct credentials.
   // When this succeeds, it will schedule a new RefreshRequest with the bad
   // credential.
-  turn_port_->FlushRequests();
+  turn_port_->FlushRequests(cricket::TURN_REFRESH_REQUEST);
   EXPECT_TRUE_WAIT(turn_refresh_success_, kTimeout);
   // Flush it again, it will receive a bad response.
-  turn_port_->FlushRequests();
+  turn_port_->FlushRequests(cricket::TURN_REFRESH_REQUEST);
   EXPECT_TRUE_WAIT(!turn_refresh_success_, kTimeout);
+  EXPECT_TRUE_WAIT(!turn_port_->connected(), kTimeout);
   EXPECT_TRUE(turn_port_->connections().empty());
-  EXPECT_FALSE(turn_port_->connected());
+  EXPECT_FALSE(turn_port_->HasRequests());
 }
 
 // Test that CreateConnection will return null if port becomes disconnected.
 TEST_F(TurnPortTest, TestCreateConnectionWhenSocketClosed) {
   turn_server_.AddInternalSocket(kTurnTcpIntAddr, cricket::PROTO_TCP);
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
   PrepareTurnAndUdpPorts();
   // Create a connection.
   Connection* conn1 = turn_port_->CreateConnection(udp_port_->Candidates()[0],
                                                    Port::ORIGIN_MESSAGE);
@@ skipping 111 matching lines @@
                                                   Port::ORIGIN_MESSAGE);
   ConnectConnectionDestroyedSignal(conn);
   ASSERT_TRUE(conn != NULL);
   ASSERT_TRUE_WAIT(turn_create_permission_success_, kTimeout);
   turn_create_permission_success_ = false;
   // A create-permission-request should be pending.
   // After the next create-permission-response is received, it will schedule
   // another request with bad_ufrag and bad_pwd.
   cricket::RelayCredentials bad_credentials("bad_user", "bad_pwd");
   turn_port_->set_credentials(bad_credentials);
-  turn_port_->FlushRequests();
+  turn_port_->FlushRequests(cricket::kAllRequests);
   ASSERT_TRUE_WAIT(turn_create_permission_success_, kTimeout);
   // Flush the requests again; the create-permission-request will fail.
-  turn_port_->FlushRequests();
+  turn_port_->FlushRequests(cricket::kAllRequests);
   EXPECT_TRUE_WAIT(!turn_create_permission_success_, kTimeout);
   EXPECT_TRUE_WAIT(connection_destroyed_, kTimeout);
 }
 
 TEST_F(TurnPortTest, TestChannelBindGetErrorResponse) {
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
   PrepareTurnAndUdpPorts();
   Connection* conn1 = turn_port_->CreateConnection(udp_port_->Candidates()[0],
                                                    Port::ORIGIN_MESSAGE);
   ASSERT_TRUE(conn1 != nullptr);
@@ skipping 128 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