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

webrtc/p2p/base/turnport.h

 /*
  *  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.
  */
 
@@ skipping 53 matching lines @@
                           const std::string& password,  // ice password.
                           const ProtocolAddress& server_address,
                           const RelayCredentials& credentials,
                           int server_priority,
                           const std::string& origin) {
     return new TurnPort(thread, factory, network, ip, min_port, max_port,
                         username, password, server_address, credentials,
                         server_priority, origin);
   }
 
-  virtual ~TurnPort();
+  ~TurnPort() override;
 
   const ProtocolAddress& server_address() const { return server_address_; }
   // Returns an empty address if the local address has not been assigned.
   rtc::SocketAddress GetLocalAddress() const;
 
   bool ready() const { return state_ == STATE_READY; }
   bool connected() const {
     return state_ == STATE_READY || state_ == STATE_CONNECTED;
   }
   const RelayCredentials& credentials() const { return credentials_; }
 
-  virtual void PrepareAddress();
-  virtual Connection* CreateConnection(
-      const Candidate& c, PortInterface::CandidateOrigin origin);
-  virtual int SendTo(const void* data, size_t size,
-                     const rtc::SocketAddress& addr,
-                     const rtc::PacketOptions& options,
-                     bool payload);
-  virtual int SetOption(rtc::Socket::Option opt, int value);
-  virtual int GetOption(rtc::Socket::Option opt, int* value);
-  virtual int GetError();
+  void PrepareAddress() override;
+  Connection* CreateConnection(const Candidate& c,
+                               PortInterface::CandidateOrigin origin,
+                               const IceConfig& config) override;
+  int SendTo(const void* data,
+             size_t size,
+             const rtc::SocketAddress& addr,
+             const rtc::PacketOptions& options,
+             bool payload) override;
+  int SetOption(rtc::Socket::Option opt, int value) override;
+  int GetOption(rtc::Socket::Option opt, int* value) override;
+  int GetError() override;
 
-  virtual bool HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
-                                    const char* data, size_t size,
-                                    const rtc::SocketAddress& remote_addr,
-                                    const rtc::PacketTime& packet_time);
-  virtual void OnReadPacket(rtc::AsyncPacketSocket* socket,
-                            const char* data, size_t size,
+  bool HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
+                            const char* data,
+                            size_t size,
                             const rtc::SocketAddress& remote_addr,
-                            const rtc::PacketTime& packet_time);
+                            const rtc::PacketTime& packet_time) override;
+  void OnReadPacket(rtc::AsyncPacketSocket* socket,
+                    const char* data,
+                    size_t size,
+                    const rtc::SocketAddress& remote_addr,
+                    const rtc::PacketTime& packet_time);
 
-  virtual void OnSentPacket(rtc::AsyncPacketSocket* socket,
-                            const rtc::SentPacket& sent_packet);
-  virtual void OnReadyToSend(rtc::AsyncPacketSocket* socket);
-  virtual bool SupportsProtocol(const std::string& protocol) const {
+  void OnSentPacket(rtc::AsyncPacketSocket* socket,
+                    const rtc::SentPacket& sent_packet) override;
+  void OnReadyToSend(rtc::AsyncPacketSocket* socket);
+  bool SupportsProtocol(const std::string& protocol) const override {
     // Turn port only connects to UDP candidates.
     return protocol == UDP_PROTOCOL_NAME;
   }
 
   void OnSocketConnect(rtc::AsyncPacketSocket* socket);
   void OnSocketClose(rtc::AsyncPacketSocket* socket, int error);
 
 
   const std::string& hash() const { return hash_; }
   const std::string& nonce() const { return nonce_; }
@@ skipping 62 matching lines @@
     MSG_ALLOCATE_ERROR = MSG_FIRST_AVAILABLE,
     MSG_ALLOCATE_MISMATCH,
     MSG_TRY_ALTERNATE_SERVER,
     MSG_REFRESH_ERROR
   };
 
   typedef std::list<TurnEntry*> EntryList;
   typedef std::map<rtc::Socket::Option, int> SocketOptionsMap;
   typedef std::set<rtc::SocketAddress> AttemptedServerSet;
 
-  virtual void OnMessage(rtc::Message* pmsg);
-  virtual void HandleConnectionDestroyed(Connection* conn);
+  void OnMessage(rtc::Message* pmsg) override;
+  void HandleConnectionDestroyed(Connection* conn) override;
 
   bool CreateTurnClientSocket();
 
   void set_nonce(const std::string& nonce) { nonce_ = nonce; }
   void set_realm(const std::string& realm) {
     if (realm != realm_) {
       realm_ = realm;
       UpdateHash();
     }
   }
@@ skipping 75 matching lines @@
   friend class TurnEntry;
   friend class TurnAllocateRequest;
   friend class TurnRefreshRequest;
   friend class TurnCreatePermissionRequest;
   friend class TurnChannelBindRequest;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_TURNPORT_H_