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

webrtc/p2p/base/tcpport.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 106 matching lines @@
 
 TCPPort::~TCPPort() {
   delete socket_;
   std::list<Incoming>::iterator it;
   for (it = incoming_.begin(); it != incoming_.end(); ++it)
     delete it->socket;
   incoming_.clear();
 }
 
 Connection* TCPPort::CreateConnection(const Candidate& address,
-                                      CandidateOrigin origin) {
+                                      CandidateOrigin origin,
+                                      const IceConfig& config) {
   if (!SupportsProtocol(address.protocol())) {
     return NULL;
   }
 
   if (address.tcptype() == TCPTYPE_ACTIVE_STR ||
       (address.tcptype().empty() && address.address().port() == 0)) {
     // It's active only candidate, we should not try to create connections
     // for these candidates.
     return NULL;
   }
@@ skipping 13 matching lines @@
   }
 
   if (!IsCompatibleAddress(address.address())) {
     return NULL;
   }
 
   TCPConnection* conn = NULL;
   if (rtc::AsyncPacketSocket* socket =
       GetIncoming(address.address(), true)) {
     socket->SignalReadPacket.disconnect(this);
-    conn = new TCPConnection(this, address, socket);
+    conn = new TCPConnection(this, address, config, socket);
   } else {
-    conn = new TCPConnection(this, address);
+    conn = new TCPConnection(this, address, config);
   }
   AddOrReplaceConnection(conn);
   return conn;
 }
 
 void TCPPort::PrepareAddress() {
   if (socket_) {
     // If socket isn't bound yet the address will be added in
     // OnAddressReady(). Socket may be in the CLOSED state if Listen()
     // failed, we still want to add the socket address.
@@ skipping 124 matching lines @@
 
 void TCPPort::OnAddressReady(rtc::AsyncPacketSocket* socket,
                              const rtc::SocketAddress& address) {
   AddAddress(address, address, rtc::SocketAddress(), TCP_PROTOCOL_NAME, "",
              TCPTYPE_PASSIVE_STR, LOCAL_PORT_TYPE, ICE_TYPE_PREFERENCE_HOST_TCP,
              0, true);
 }
 
 TCPConnection::TCPConnection(TCPPort* port,
                              const Candidate& candidate,
+                             const IceConfig& config,
                              rtc::AsyncPacketSocket* socket)
-    : Connection(port, 0, candidate),
+    : Connection(port, 0, candidate, config),
       socket_(socket),
       error_(0),
       outgoing_(socket == NULL),
       connection_pending_(false),
       pretending_to_be_writable_(false),
       reconnection_timeout_(cricket::CONNECTION_WRITE_CONNECT_TIMEOUT) {
   if (outgoing_) {
     CreateOutgoingTcpSocket();
   } else {
     // Incoming connections should match the network address.
@@ skipping 192 matching lines @@
 void TCPConnection::ConnectSocketSignals(rtc::AsyncPacketSocket* socket) {
   if (outgoing_) {
     socket->SignalConnect.connect(this, &TCPConnection::OnConnect);
   }
   socket->SignalReadPacket.connect(this, &TCPConnection::OnReadPacket);
   socket->SignalReadyToSend.connect(this, &TCPConnection::OnReadyToSend);
   socket->SignalClose.connect(this, &TCPConnection::OnClose);
 }
 
 }  // namespace cricket