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

webrtc/p2p/base/port_unittest.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 124 matching lines @@
     int code = 0;
     if (last_stun_msg_) {
       const StunErrorCodeAttribute* error_attr = last_stun_msg_->GetErrorCode();
       if (error_attr) {
         code = error_attr->code();
       }
     }
     return code;
   }
 
-  virtual void PrepareAddress() {
+  void PrepareAddress() override {
     rtc::SocketAddress addr(ip(), min_port());
     AddAddress(addr, addr, rtc::SocketAddress(), "udp", "", "", Type(),
                ICE_TYPE_PREFERENCE_HOST, 0, true);
   }
 
-  virtual bool SupportsProtocol(const std::string& protocol) const {
+  bool SupportsProtocol(const std::string& protocol) const override {
     return true;
   }
 
   // Exposed for testing candidate building.
   void AddCandidateAddress(const rtc::SocketAddress& addr) {
     AddAddress(addr, addr, rtc::SocketAddress(), "udp", "", "", Type(),
                type_preference_, 0, false);
   }
   void AddCandidateAddress(const rtc::SocketAddress& addr,
                            const rtc::SocketAddress& base_address,
                            const std::string& type,
                            int type_preference,
                            bool final) {
     AddAddress(addr, base_address, rtc::SocketAddress(), "udp", "", "", type,
                type_preference, 0, final);
   }
 
-  virtual Connection* CreateConnection(const Candidate& remote_candidate,
-                                       CandidateOrigin origin) {
-    Connection* conn = new ProxyConnection(this, 0, remote_candidate);
+  Connection* CreateConnection(const Candidate& remote_candidate,
+                               CandidateOrigin origin,
+                               const IceConfig& config) override {
+    Connection* conn = new ProxyConnection(this, 0, remote_candidate, config);
     AddOrReplaceConnection(conn);
     // Set use-candidate attribute flag as this will add USE-CANDIDATE attribute
     // in STUN binding requests.
     conn->set_use_candidate_attr(true);
     return conn;
   }
-  virtual int SendTo(
-      const void* data, size_t size, const rtc::SocketAddress& addr,
-      const rtc::PacketOptions& options, bool payload) {
+  int SendTo(const void* data,
+             size_t size,
+             const rtc::SocketAddress& addr,
+             const rtc::PacketOptions& options,
+             bool payload) override {
     if (!payload) {
       IceMessage* msg = new IceMessage;
       Buffer* buf = new Buffer(static_cast<const char*>(data), size);
       ByteBufferReader read_buf(*buf);
       if (!msg->Read(&read_buf)) {
         delete msg;
         delete buf;
         return -1;
       }
       last_stun_buf_.reset(buf);
       last_stun_msg_.reset(msg);
     }
     return static_cast<int>(size);
   }
-  virtual int SetOption(rtc::Socket::Option opt, int value) {
-    return 0;
-  }
-  virtual int GetOption(rtc::Socket::Option opt, int* value) {
-    return -1;
-  }
-  virtual int GetError() {
-    return 0;
-  }
+  int SetOption(rtc::Socket::Option opt, int value) override { return 0; }
+  int GetOption(rtc::Socket::Option opt, int* value) override { return -1; }
+  int GetError() override { return 0; }
   void Reset() {
     last_stun_buf_.reset();
     last_stun_msg_.reset();
   }
   void set_type_preference(int type_preference) {
     type_preference_ = type_preference;
   }
 
  private:
   void OnSentPacket(rtc::AsyncPacketSocket* socket,
-                    const rtc::SentPacket& sent_packet) {
+                    const rtc::SentPacket& sent_packet) override {
     PortInterface::SignalSentPacket(sent_packet);
   }
   std::unique_ptr<Buffer> last_stun_buf_;
   std::unique_ptr<IceMessage> last_stun_msg_;
   int type_preference_ = 0;
 };
 
 class TestChannel : public sigslot::has_slots<> {
  public:
   // Takes ownership of |p1| (but not |p2|).
   TestChannel(Port* p1)
       : ice_mode_(ICEMODE_FULL),
         port_(p1),
         complete_count_(0),
         conn_(NULL),
         remote_request_(),
         nominated_(false) {
     port_->SignalPortComplete.connect(this, &TestChannel::OnPortComplete);
     port_->SignalUnknownAddress.connect(this, &TestChannel::OnUnknownAddress);
     port_->SignalDestroyed.connect(this, &TestChannel::OnSrcPortDestroyed);
   }
 
   int complete_count() { return complete_count_; }
   Connection* conn() { return conn_; }
   const SocketAddress& remote_address() { return remote_address_; }
   const std::string remote_fragment() { return remote_frag_; }
 
   void Start() { port_->PrepareAddress(); }
   void CreateConnection(const Candidate& remote_candidate) {
-    conn_ = port_->CreateConnection(remote_candidate, Port::ORIGIN_MESSAGE);
+    conn_ = port_->CreateConnection(remote_candidate, Port::ORIGIN_MESSAGE,
+                                    IceConfig());
     IceMode remote_ice_mode =
         (ice_mode_ == ICEMODE_FULL) ? ICEMODE_LITE : ICEMODE_FULL;
     conn_->set_remote_ice_mode(remote_ice_mode);
     conn_->set_use_candidate_attr(remote_ice_mode == ICEMODE_FULL);
     conn_->SignalStateChange.connect(
         this, &TestChannel::OnConnectionStateChange);
     conn_->SignalDestroyed.connect(this, &TestChannel::OnDestroyed);
     conn_->SignalReadyToSend.connect(this,
                                      &TestChannel::OnConnectionReadyToSend);
     connection_ready_to_send_ = false;
   }
   void OnConnectionStateChange(Connection* conn) {
     if (conn->write_state() == Connection::STATE_WRITABLE) {
       conn->set_use_candidate_attr(true);
       nominated_ = true;
     }
   }
   void AcceptConnection(const Candidate& remote_candidate) {
     ASSERT_TRUE(remote_request_.get() != NULL);
     Candidate c = remote_candidate;
     c.set_address(remote_address_);
-    conn_ = port_->CreateConnection(c, Port::ORIGIN_MESSAGE);
+    conn_ = port_->CreateConnection(c, Port::ORIGIN_MESSAGE, IceConfig());
     conn_->SignalDestroyed.connect(this, &TestChannel::OnDestroyed);
     port_->SendBindingResponse(remote_request_.get(), remote_address_);
     remote_request_.reset();
   }
   void Ping() {
     Ping(0);
   }
   void Ping(int64_t now) { conn_->Ping(now); }
   void Stop() {
     if (conn_) {
@@ skipping 697 matching lines @@
  private:
   AsyncPacketSocket* next_udp_socket_;
   AsyncPacketSocket* next_server_tcp_socket_;
   AsyncPacketSocket* next_client_tcp_socket_;
 };
 
 class FakeAsyncPacketSocket : public AsyncPacketSocket {
  public:
   // Returns current local address. Address may be set to NULL if the
   // socket is not bound yet (GetState() returns STATE_BINDING).
-  virtual SocketAddress GetLocalAddress() const {
-    return SocketAddress();
-  }
+  SocketAddress GetLocalAddress() const override { return SocketAddress(); }
 
   // Returns remote address. Returns zeroes if this is not a client TCP socket.
-  virtual SocketAddress GetRemoteAddress() const {
-    return SocketAddress();
-  }
+  SocketAddress GetRemoteAddress() const override { return SocketAddress(); }
 
   // Send a packet.
-  virtual int Send(const void *pv, size_t cb,
-                   const rtc::PacketOptions& options) {
+  int Send(const void* pv,
+           size_t cb,
+           const rtc::PacketOptions& options) override {
     return static_cast<int>(cb);
   }
-  virtual int SendTo(const void *pv, size_t cb, const SocketAddress& addr,
-                     const rtc::PacketOptions& options) {
+  int SendTo(const void* pv,
+             size_t cb,
+             const SocketAddress& addr,
+             const rtc::PacketOptions& options) override {
     return static_cast<int>(cb);
   }
-  virtual int Close() {
-    return 0;
-  }
+  int Close() override { return 0; }
 
-  virtual State GetState() const { return state_; }
-  virtual int GetOption(Socket::Option opt, int* value) { return 0; }
-  virtual int SetOption(Socket::Option opt, int value) { return 0; }
-  virtual int GetError() const { return 0; }
-  virtual void SetError(int error) { }
+  State GetState() const override { return state_; }
+  int GetOption(Socket::Option opt, int* value) override { return 0; }
+  int SetOption(Socket::Option opt, int value) override { return 0; }
+  int GetError() const override { return 0; }
+  void SetError(int error) override {}
 
   void set_state(State state) { state_ = state; }
 
  private:
   State state_;
 };
 
 // Local -> XXXX
 TEST_F(PortTest, TestLocalToLocal) {
   TestLocalToLocal();
@@ skipping 303 matching lines @@
 // should remain equal to the request generated by the port and role of port
 // must be in controlling.
 TEST_F(PortTest, TestLoopbackCal) {
   std::unique_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   lport->SetIceTiebreaker(kTiebreaker1);
   lport->PrepareAddress();
   ASSERT_FALSE(lport->Candidates().empty());
   Connection* conn = lport->CreateConnection(lport->Candidates()[0],
-                                             Port::ORIGIN_MESSAGE);
+                                             Port::ORIGIN_MESSAGE, IceConfig());
   conn->Ping(0);
 
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   IceMessage* msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   conn->OnReadPacket(lport->last_stun_buf()->data<char>(),
                      lport->last_stun_buf()->size(),
                      rtc::PacketTime());
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type());
 
   // If the tiebreaker value is different from port, we expect a error
   // response.
   lport->Reset();
   lport->AddCandidateAddress(kLocalAddr2);
   // Creating a different connection as |conn| is receiving.
-  Connection* conn1 = lport->CreateConnection(lport->Candidates()[1],
-                                              Port::ORIGIN_MESSAGE);
+  Connection* conn1 = lport->CreateConnection(
+      lport->Candidates()[1], Port::ORIGIN_MESSAGE, IceConfig());
   conn1->Ping(0);
 
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   std::unique_ptr<IceMessage> modified_req(
       CreateStunMessage(STUN_BINDING_REQUEST));
   const StunByteStringAttribute* username_attr = msg->GetByteString(
       STUN_ATTR_USERNAME);
   modified_req->AddAttribute(new StunByteStringAttribute(
@@ skipping 26 matching lines @@
   lport->SetIceTiebreaker(kTiebreaker1);
   std::unique_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   rport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   rport->SetIceTiebreaker(kTiebreaker2);
 
   lport->PrepareAddress();
   rport->PrepareAddress();
   ASSERT_FALSE(lport->Candidates().empty());
   ASSERT_FALSE(rport->Candidates().empty());
-  Connection* lconn = lport->CreateConnection(rport->Candidates()[0],
-                                              Port::ORIGIN_MESSAGE);
-  Connection* rconn = rport->CreateConnection(lport->Candidates()[0],
-                                              Port::ORIGIN_MESSAGE);
+  Connection* lconn = lport->CreateConnection(
+      rport->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
+  Connection* rconn = rport->CreateConnection(
+      lport->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
   rconn->Ping(0);
 
   ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, 1000);
   IceMessage* msg = rport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   // Send rport binding request to lport.
   lconn->OnReadPacket(rport->last_stun_buf()->data<char>(),
                       rport->last_stun_buf()->size(),
                       rtc::PacketTime());
 
@@ skipping 65 matching lines @@
     socket->SignalAddressReady(socket, addresses[i]);
     ports[i]->PrepareAddress();
   }
 
   // IPv4 Port, connects to IPv6 candidate and then to IPv4 candidate.
   if (type == SOCK_STREAM) {
     FakeAsyncPacketSocket* clientsocket = new FakeAsyncPacketSocket();
     factory.set_next_client_tcp_socket(clientsocket);
   }
   Connection* c = ports[0]->CreateConnection(GetCandidate(ports[2].get()),
-                                             Port::ORIGIN_MESSAGE);
+                                             Port::ORIGIN_MESSAGE, IceConfig());
   EXPECT_TRUE(NULL == c);
   EXPECT_EQ(0U, ports[0]->connections().size());
   c = ports[0]->CreateConnection(GetCandidate(ports[1].get()),
-                                 Port::ORIGIN_MESSAGE);
+                                 Port::ORIGIN_MESSAGE, IceConfig());
   EXPECT_FALSE(NULL == c);
   EXPECT_EQ(1U, ports[0]->connections().size());
 
   // IPv6 Port, connects to IPv4 candidate and to IPv6 candidate.
   if (type == SOCK_STREAM) {
     FakeAsyncPacketSocket* clientsocket = new FakeAsyncPacketSocket();
     factory.set_next_client_tcp_socket(clientsocket);
   }
   c = ports[2]->CreateConnection(GetCandidate(ports[0].get()),
-                                 Port::ORIGIN_MESSAGE);
+                                 Port::ORIGIN_MESSAGE, IceConfig());
   EXPECT_TRUE(NULL == c);
   EXPECT_EQ(0U, ports[2]->connections().size());
   c = ports[2]->CreateConnection(GetCandidate(ports[3].get()),
-                                 Port::ORIGIN_MESSAGE);
+                                 Port::ORIGIN_MESSAGE, IceConfig());
   EXPECT_FALSE(NULL == c);
   EXPECT_EQ(1U, ports[2]->connections().size());
 }
 
 TEST_F(PortTest, TestSkipCrossFamilyTcp) {
   TestCrossFamilyPorts(SOCK_STREAM);
 }
 
 TEST_F(PortTest, TestSkipCrossFamilyUdp) {
   TestCrossFamilyPorts(SOCK_DGRAM);
 }
 
 void PortTest::ExpectPortsCanConnect(bool can_connect, Port* p1, Port* p2) {
-  Connection* c = p1->CreateConnection(GetCandidate(p2),
-                                       Port::ORIGIN_MESSAGE);
+  Connection* c =
+      p1->CreateConnection(GetCandidate(p2), Port::ORIGIN_MESSAGE, IceConfig());
   if (can_connect) {
     EXPECT_FALSE(NULL == c);
     EXPECT_EQ(1U, p1->connections().size());
   } else {
     EXPECT_TRUE(NULL == c);
     EXPECT_EQ(0U, p1->connections().size());
   }
 }
 
 TEST_F(PortTest, TestUdpV6CrossTypePorts) {
@@ skipping 72 matching lines @@
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   lport->SetIceTiebreaker(kTiebreaker1);
   rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
   rport->SetIceTiebreaker(kTiebreaker2);
 
   // Send a fake ping from lport to rport.
   lport->PrepareAddress();
   rport->PrepareAddress();
   ASSERT_FALSE(rport->Candidates().empty());
   Connection* lconn = lport->CreateConnection(
-      rport->Candidates()[0], Port::ORIGIN_MESSAGE);
+      rport->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
   Connection* rconn = rport->CreateConnection(
-      lport->Candidates()[0], Port::ORIGIN_MESSAGE);
+      lport->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
   lconn->Ping(0);
 
   // Check that it's a proper BINDING-REQUEST.
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   IceMessage* msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   EXPECT_FALSE(msg->IsLegacy());
   const StunByteStringAttribute* username_attr =
       msg->GetByteString(STUN_ATTR_USERNAME);
   ASSERT_TRUE(username_attr != NULL);
@@ skipping 142 matching lines @@
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   lport->SetIceTiebreaker(kTiebreaker1);
   rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
   rport->SetIceTiebreaker(kTiebreaker2);
 
   // Send a fake ping from lport to rport.
   lport->PrepareAddress();
   rport->PrepareAddress();
   ASSERT_FALSE(rport->Candidates().empty());
   Connection* lconn = lport->CreateConnection(
-      rport->Candidates()[0], Port::ORIGIN_MESSAGE);
+      rport->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
   lconn->Ping(0);
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   IceMessage* msg = lport->last_stun_msg();
   const StunUInt64Attribute* ice_controlling_attr =
       msg->GetUInt64(STUN_ATTR_ICE_CONTROLLING);
   ASSERT_TRUE(ice_controlling_attr != NULL);
   const StunByteStringAttribute* use_candidate_attr = msg->GetByteString(
       STUN_ATTR_USE_CANDIDATE);
   ASSERT_TRUE(use_candidate_attr != NULL);
 }
@@ skipping 21 matching lines @@
   }
 
   // Change the network type to wifi.
   SetNetworkType(rtc::ADAPTER_TYPE_WIFI);
   EXPECT_EQ(rtc::kNetworkCostLow, lport->network_cost());
   for (const cricket::Candidate& candidate : lport->Candidates()) {
     EXPECT_EQ(rtc::kNetworkCostLow, candidate.network_cost());
   }
 
   // Add a connection and then change the network type.
-  Connection* lconn =
-      lport->CreateConnection(rport->Candidates()[0], Port::ORIGIN_MESSAGE);
+  Connection* lconn = lport->CreateConnection(
+      rport->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
   // Change the network type to cellular.
   SetNetworkType(rtc::ADAPTER_TYPE_CELLULAR);
   EXPECT_EQ(rtc::kNetworkCostHigh, lport->network_cost());
   for (const cricket::Candidate& candidate : lport->Candidates()) {
     EXPECT_EQ(rtc::kNetworkCostHigh, candidate.network_cost());
   }
 
   SetNetworkType(rtc::ADAPTER_TYPE_WIFI);
-  Connection* rconn =
-      rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
+  Connection* rconn = rport->CreateConnection(
+      lport->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
   SetNetworkType(rtc::ADAPTER_TYPE_CELLULAR);
   lconn->Ping(0);
   // The rconn's remote candidate cost is rtc::kNetworkCostLow, but the ping
   // contains an attribute of network cost of rtc::kNetworkCostHigh. Once the
   // message is handled in rconn, The rconn's remote candidate will have cost
   // rtc::kNetworkCostHigh;
   EXPECT_EQ(rtc::kNetworkCostLow, rconn->remote_candidate().network_cost());
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   IceMessage* msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
@@ skipping 13 matching lines @@
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   lport->SetIceTiebreaker(kTiebreaker1);
   rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
   rport->SetIceTiebreaker(kTiebreaker2);
 
   uint16_t lnetwork_id = 9;
   lport->Network()->set_id(lnetwork_id);
   // Send a fake ping from lport to rport.
   lport->PrepareAddress();
   rport->PrepareAddress();
-  Connection* lconn =
-      lport->CreateConnection(rport->Candidates()[0], Port::ORIGIN_MESSAGE);
+  Connection* lconn = lport->CreateConnection(
+      rport->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
   lconn->Ping(0);
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   IceMessage* msg = lport->last_stun_msg();
   const StunUInt32Attribute* network_info_attr =
       msg->GetUInt32(STUN_ATTR_NETWORK_INFO);
   ASSERT_TRUE(network_info_attr != NULL);
   uint32_t network_info = network_info_attr->value();
   EXPECT_EQ(lnetwork_id, network_info >> 16);
   // Default network has unknown type and cost kNetworkCostUnknown.
   EXPECT_EQ(rtc::kNetworkCostUnknown, network_info & 0xFFFF);
 
   // Set the network type to be cellular so its cost will be kNetworkCostHigh.
   // Send a fake ping from rport to lport.
   SetNetworkType(rtc::ADAPTER_TYPE_CELLULAR);
   uint16_t rnetwork_id = 8;
   rport->Network()->set_id(rnetwork_id);
-  Connection* rconn =
-      rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
+  Connection* rconn = rport->CreateConnection(
+      lport->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
   rconn->Ping(0);
   ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, 1000);
   msg = rport->last_stun_msg();
   network_info_attr = msg->GetUInt32(STUN_ATTR_NETWORK_INFO);
   ASSERT_TRUE(network_info_attr != NULL);
   network_info = network_info_attr->value();
   EXPECT_EQ(rnetwork_id, network_info >> 16);
   EXPECT_EQ(rtc::kNetworkCostHigh, network_info & 0xFFFF);
 }
 
@@ skipping 247 matching lines @@
   std::unique_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
   rport->SetIceTiebreaker(kTiebreaker2);
 
   lport->PrepareAddress();
   rport->PrepareAddress();
   ASSERT_FALSE(lport->Candidates().empty());
   ASSERT_FALSE(rport->Candidates().empty());
 
-  Connection* lconn = lport->CreateConnection(rport->Candidates()[0],
-                                              Port::ORIGIN_MESSAGE);
-  Connection* rconn = rport->CreateConnection(lport->Candidates()[0],
-                                              Port::ORIGIN_MESSAGE);
+  Connection* lconn = lport->CreateConnection(
+      rport->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
+  Connection* rconn = rport->CreateConnection(
+      lport->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
   rconn->Ping(0);
 
   ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, 1000);
   IceMessage* msg = rport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   // Send rport binding request to lport.
   lconn->OnReadPacket(rport->last_stun_buf()->data<char>(),
                       rport->last_stun_buf()->size(),
                       rtc::PacketTime());
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
@@ skipping 207 matching lines @@
   rport->AddCandidateAddress(SocketAddress("10.1.1.100", 1234));
 
   EXPECT_EQ(0x7E001E85U, lport->Candidates()[0].priority());
   EXPECT_EQ(0x2001EE9U, rport->Candidates()[0].priority());
 
   // RFC 5245
   // pair priority = 2^32*MIN(G,D) + 2*MAX(G,D) + (G>D?1:0)
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
   Connection* lconn = lport->CreateConnection(
-      rport->Candidates()[0], Port::ORIGIN_MESSAGE);
+      rport->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
 #if defined(WEBRTC_WIN)
   EXPECT_EQ(0x2001EE9FC003D0BU, lconn->priority());
 #else
   EXPECT_EQ(0x2001EE9FC003D0BLLU, lconn->priority());
 #endif
 
   lport->SetIceRole(cricket::ICEROLE_CONTROLLED);
   rport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   Connection* rconn = rport->CreateConnection(
-      lport->Candidates()[0], Port::ORIGIN_MESSAGE);
+      lport->Candidates()[0], Port::ORIGIN_MESSAGE, IceConfig());
 #if defined(WEBRTC_WIN)
   EXPECT_EQ(0x2001EE9FC003D0AU, rconn->priority());
 #else
   EXPECT_EQ(0x2001EE9FC003D0ALLU, rconn->priority());
 #endif
 }
 
 TEST_F(PortTest, TestWritableState) {
   UDPPort* port1 = CreateUdpPort(kLocalAddr1);
   port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
@@ skipping 125 matching lines @@
   // Verify stun ping is without USE_CANDIDATE_ATTR. Getting message directly
   // from port.
   ASSERT_TRUE_WAIT(ice_full_port->last_stun_msg() != NULL, 1000);
   IceMessage* msg = ice_full_port->last_stun_msg();
   EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) == NULL);
 
   // Respond with a BINDING-RESPONSE from litemode client.
   // NOTE: Ideally we should't create connection at this stage from lite
   // port, as it should be done only after receiving ping with USE_CANDIDATE.
   // But we need a connection to send a response message.
-  ice_lite_port->CreateConnection(
-      ice_full_port->Candidates()[0], cricket::Port::ORIGIN_MESSAGE);
+  ice_lite_port->CreateConnection(ice_full_port->Candidates()[0],
+                                  cricket::Port::ORIGIN_MESSAGE, IceConfig());
   std::unique_ptr<IceMessage> request(CopyStunMessage(msg));
   ice_lite_port->SendBindingResponse(
       request.get(), ice_full_port->Candidates()[0].address());
 
   // Feeding the respone message from litemode to the full mode connection.
   ch1.conn()->OnReadPacket(ice_lite_port->last_stun_buf()->data<char>(),
                            ice_lite_port->last_stun_buf()->size(),
                            rtc::PacketTime());
   // Verifying full mode connection becomes writable from the response.
   EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(),
@@ skipping 139 matching lines @@
 }
 
 TEST_F(PortTest, TestAddConnectionWithSameAddress) {
   std::unique_ptr<TestPort> port(
       CreateTestPort(kLocalAddr1, "ufrag1", "password1"));
   port->PrepareAddress();
   EXPECT_EQ(1u, port->Candidates().size());
   rtc::SocketAddress address("1.1.1.1", 5000);
   cricket::Candidate candidate(1, "udp", address, 0, "", "", "relay", 0, "");
   cricket::Connection* conn1 =
-      port->CreateConnection(candidate, Port::ORIGIN_MESSAGE);
+      port->CreateConnection(candidate, Port::ORIGIN_MESSAGE, IceConfig());
   cricket::Connection* conn_in_use = port->GetConnection(address);
   EXPECT_EQ(conn1, conn_in_use);
   EXPECT_EQ(0u, conn_in_use->remote_candidate().generation());
 
   // Creating with a candidate with the same address again will get us a
   // different connection with the new candidate.
   candidate.set_generation(2);
   cricket::Connection* conn2 =
-      port->CreateConnection(candidate, Port::ORIGIN_MESSAGE);
+      port->CreateConnection(candidate, Port::ORIGIN_MESSAGE, IceConfig());
   EXPECT_NE(conn1, conn2);
   conn_in_use = port->GetConnection(address);
   EXPECT_EQ(conn2, conn_in_use);
   EXPECT_EQ(2u, conn_in_use->remote_candidate().generation());
 
   // Make sure the new connection was not deleted.
   rtc::Thread::Current()->ProcessMessages(300);
   EXPECT_TRUE(port->GetConnection(address) != nullptr);
 }