Adding IceConfig option to assume TURN/TURN candidate pairs will work.

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 17 matching lines @@
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/physicalsocketserver.h"
 #include "webrtc/base/socketaddress.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/virtualsocketserver.h"
 
 using rtc::SocketAddress;
 using cricket::Connection;
+using cricket::IceConfig;
 using cricket::Port;
 using cricket::PortInterface;
 using cricket::TurnPort;
 using cricket::UDPPort;
 
 static const SocketAddress kLocalAddr1("11.11.11.11", 0);
 static const SocketAddress kLocalAddr2("22.22.22.22", 0);
 static const SocketAddress kLocalIPv6Addr(
     "2401:fa00:4:1000:be30:5bff:fee5:c3", 0);
 static const SocketAddress kTurnUdpIntAddr("99.99.99.3",
@@ skipping 347 matching lines @@
     EXPECT_TRUE_WAIT(turn_error_, kTimeout);
     ASSERT_EQ(0U, turn_port_->Candidates().size());
   }
 
   void TestTurnConnection() {
     // Create ports and prepare addresses.
     PrepareTurnAndUdpPorts();
 
     // Send ping from UDP to TURN.
     Connection* conn1 = udp_port_->CreateConnection(
-                    turn_port_->Candidates()[0], Port::ORIGIN_MESSAGE);
+        turn_port_->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
     ASSERT_TRUE(conn1 != NULL);
     conn1->Ping(0);
     WAIT(!turn_unknown_address_, kTimeout);
     EXPECT_FALSE(turn_unknown_address_);
     EXPECT_FALSE(conn1->receiving());
     EXPECT_EQ(Connection::STATE_WRITE_INIT, conn1->write_state());
 
     // Send ping from TURN to UDP.
     Connection* conn2 = turn_port_->CreateConnection(
-                    udp_port_->Candidates()[0], Port::ORIGIN_MESSAGE);
+        udp_port_->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
     ASSERT_TRUE(conn2 != NULL);
     ASSERT_TRUE_WAIT(turn_create_permission_success_, kTimeout);
     conn2->Ping(0);
 
     EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, conn2->write_state(), kTimeout);
     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() {
     PrepareTurnAndUdpPorts();
 
     // 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);
+    Connection* conn1 = udp_port_->CreateConnection(
+        turn_port_->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
+    Connection* conn2 = turn_port_->CreateConnection(
+        udp_port_->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
     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_);
 
     // 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);
 
     // Flush all requests in the invoker to destroy the TurnEntry.
     // Now the turn port cannot receive the ping.
     turn_unknown_address_ = false;
     turn_port_->invoker()->Flush(rtc::Thread::Current());
     conn1->Ping(0);
     rtc::Thread::Current()->ProcessMessages(500);
     EXPECT_FALSE(turn_unknown_address_);
 
     // If the connection is created again, it will start to receive pings.
     conn2 = turn_port_->CreateConnection(udp_port_->Candidates()[0],
-                                         Port::ORIGIN_MESSAGE);
+                                         Port::ORIGIN_MESSAGE, IceConfig());
     conn1->Ping(0);
     EXPECT_TRUE_WAIT(conn2->receiving(), kTimeout);
     EXPECT_FALSE(turn_unknown_address_);
   }
 
   void TestTurnSendData() {
     PrepareTurnAndUdpPorts();
 
     // Create connections and send pings.
     Connection* conn1 = turn_port_->CreateConnection(
-        udp_port_->Candidates()[0], Port::ORIGIN_MESSAGE);
+        udp_port_->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
     Connection* conn2 = udp_port_->CreateConnection(
-        turn_port_->Candidates()[0], Port::ORIGIN_MESSAGE);
+        turn_port_->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
     ASSERT_TRUE(conn1 != NULL);
     ASSERT_TRUE(conn2 != NULL);
     conn1->SignalReadPacket.connect(static_cast<TurnPortTest*>(this),
                                     &TurnPortTest::OnTurnReadPacket);
     conn2->SignalReadPacket.connect(static_cast<TurnPortTest*>(this),
                                     &TurnPortTest::OnUdpReadPacket);
     conn1->Ping(0);
     EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, conn1->write_state(), kTimeout);
     conn2->Ping(0);
     EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, conn2->write_state(), kTimeout);
@@ skipping 242 matching lines @@
 
   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);
   PrepareTurnAndUdpPorts();
-  turn_port_->CreateConnection(udp_port_->Candidates()[0],
-                               Port::ORIGIN_MESSAGE);
+  turn_port_->CreateConnection(udp_port_->Candidates()[0], Port::ORIGIN_MESSAGE,
+                               IceConfig());
   // 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(cricket::TURN_REFRESH_REQUEST);
   EXPECT_TRUE_WAIT(turn_refresh_success_, kTimeout);
   // Flush it again, it will receive a bad response.
   turn_port_->FlushRequests(cricket::TURN_REFRESH_REQUEST);
   EXPECT_TRUE_WAIT(!turn_refresh_success_, kTimeout);
   EXPECT_TRUE_WAIT(!turn_port_->connected(), kTimeout);
   EXPECT_TRUE_WAIT(turn_port_->connections().empty(), kTimeout);
   EXPECT_FALSE(turn_port_->HasRequests());
 }
 
 // Test that TurnPort will not handle any incoming packets once it has been
 // closed.
 TEST_F(TurnPortTest, TestStopProcessingPacketsAfterClosed) {
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
   PrepareTurnAndUdpPorts();
-  Connection* conn1 = turn_port_->CreateConnection(udp_port_->Candidates()[0],
-                                                   Port::ORIGIN_MESSAGE);
-  Connection* conn2 = udp_port_->CreateConnection(turn_port_->Candidates()[0],
-                                                  Port::ORIGIN_MESSAGE);
+  Connection* conn1 = turn_port_->CreateConnection(
+      udp_port_->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
+  Connection* conn2 = udp_port_->CreateConnection(
+      turn_port_->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
   ASSERT_TRUE(conn1 != NULL);
   ASSERT_TRUE(conn2 != NULL);
   // Make sure conn2 is writable.
   conn2->Ping(0);
   EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, conn2->write_state(), kTimeout);
 
   turn_port_->Close();
   rtc::Thread::Current()->ProcessMessages(0);
   turn_unknown_address_ = false;
   conn2->Ping(0);
   rtc::Thread::Current()->ProcessMessages(500);
   // Since the turn port does not handle packets any more, it should not
   // SignalUnknownAddress.
   EXPECT_FALSE(turn_unknown_address_);
 }
 
 // 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);
+  Connection* conn1 = turn_port_->CreateConnection(
+      udp_port_->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
   ASSERT_TRUE(conn1 != NULL);
 
   // Close the socket and create a connection again.
   turn_port_->OnSocketClose(turn_port_->socket(), 1);
   conn1 = turn_port_->CreateConnection(udp_port_->Candidates()[0],
-                                       Port::ORIGIN_MESSAGE);
+                                       Port::ORIGIN_MESSAGE, IceConfig());
   ASSERT_TRUE(conn1 == NULL);
 }
 
 // Test try-alternate-server feature.
 TEST_F(TurnPortTest, TestTurnAlternateServerUDP) {
   TestTurnAlternateServer(cricket::PROTO_UDP);
 }
 
 TEST_F(TurnPortTest, TestTurnAlternateServerTCP) {
   TestTurnAlternateServer(cricket::PROTO_TCP);
@@ skipping 84 matching lines @@
   TestTurnConnection();
 }
 
 // Test that CreatePermissionRequest will be scheduled after the success
 // of the first create permission request and the request will get an
 // ErrorResponse if the ufrag and pwd are incorrect.
 TEST_F(TurnPortTest, TestRefreshCreatePermissionRequest) {
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
   PrepareTurnAndUdpPorts();
 
-  Connection* conn = turn_port_->CreateConnection(udp_port_->Candidates()[0],
-                                                  Port::ORIGIN_MESSAGE);
+  Connection* conn = turn_port_->CreateConnection(
+      udp_port_->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
   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(cricket::kAllRequests);
   ASSERT_TRUE_WAIT(turn_create_permission_success_, kTimeout);
   // Flush the requests again; the create-permission-request will fail.
   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);
+  Connection* conn1 = turn_port_->CreateConnection(
+      udp_port_->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
   ASSERT_TRUE(conn1 != nullptr);
-  Connection* conn2 = udp_port_->CreateConnection(turn_port_->Candidates()[0],
-                                                  Port::ORIGIN_MESSAGE);
+  Connection* conn2 = udp_port_->CreateConnection(
+      turn_port_->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
   ASSERT_TRUE(conn2 != nullptr);
   ConnectConnectionDestroyedSignal(conn1);
   conn1->Ping(0);
   ASSERT_TRUE_WAIT(conn1->writable(), kTimeout);
 
   std::string data = "ABC";
   conn1->Send(data.data(), data.length(), options);
   bool success =
       turn_port_->SetEntryChannelId(udp_port_->Candidates()[0].address(), -1);
   ASSERT_TRUE(success);
@@ skipping 64 matching lines @@
   turn_server_.server()->set_reject_private_addresses(true);
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
   turn_port_->PrepareAddress();
   ASSERT_TRUE_WAIT(turn_ready_, kTimeout);
 
   CreateUdpPort(SocketAddress("10.0.0.10", 0));
   udp_port_->PrepareAddress();
   ASSERT_TRUE_WAIT(udp_ready_, kTimeout);
   // Create a connection.
   TestConnectionWrapper conn(turn_port_->CreateConnection(
-      udp_port_->Candidates()[0], Port::ORIGIN_MESSAGE));
+      udp_port_->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig()));
   ASSERT_TRUE(conn.connection() != nullptr);
 
   // Asynchronously, CreatePermission request should be sent and fail, closing
   // the connection.
   EXPECT_TRUE_WAIT(conn.connection() == nullptr, kTimeout);
   EXPECT_FALSE(turn_create_permission_success_);
 }
 
 // Test that a TURN allocation is released when the port is closed.
 TEST_F(TurnPortTest, TestTurnReleaseAllocation) {
@@ skipping 35 matching lines @@
   turn_port_->PrepareAddress();
   ASSERT_TRUE_WAIT(turn_error_, kResolverTimeout);
   EXPECT_TRUE(turn_port_->Candidates().empty());
   turn_port_.reset();
   rtc::Thread::Current()->Post(RTC_FROM_HERE, this, MSG_TESTFINISH);
   // Waiting for above message to be processed.
   ASSERT_TRUE_WAIT(test_finish_, kTimeout);
   EXPECT_EQ(last_fd_count, GetFDCount());
 }
 #endif