TCPConnection can never be deteted if they fail to connect

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 182 matching lines @@
 
  private:
   rtc::scoped_ptr<ByteBuffer> last_stun_buf_;
   rtc::scoped_ptr<IceMessage> last_stun_msg_;
   int type_preference_;
 };
 
 class TestChannel : public sigslot::has_slots<> {
  public:
   // Takes ownership of |p1| (but not |p2|).
-  TestChannel(Port* p1, Port* p2)
-      : ice_mode_(ICEMODE_FULL), src_(p1), dst_(p2), complete_count_(0),
-        conn_(NULL), remote_request_(), nominated_(false) {
-    src_->SignalPortComplete.connect(
-        this, &TestChannel::OnPortComplete);
-    src_->SignalUnknownAddress.connect(this, &TestChannel::OnUnknownAddress);
-    src_->SignalDestroyed.connect(this, &TestChannel::OnSrcPortDestroyed);
+  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() {
-    src_->PrepareAddress();
-  }
-  void CreateConnection() {
-    conn_ = src_->CreateConnection(GetCandidate(dst_), Port::ORIGIN_MESSAGE);
+  void Start() { port_->PrepareAddress(); }
+  void CreateConnection(const Candidate& remote_candidate) {
+    conn_ = port_->CreateConnection(remote_candidate, Port::ORIGIN_MESSAGE);
     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() {
+  void AcceptConnection(const Candidate& remote_candidate) {
     ASSERT_TRUE(remote_request_.get() != NULL);
-    Candidate c = GetCandidate(dst_);
+    Candidate c = remote_candidate;
     c.set_address(remote_address_);
-    conn_ = src_->CreateConnection(c, Port::ORIGIN_MESSAGE);
+    conn_ = port_->CreateConnection(c, Port::ORIGIN_MESSAGE);
     conn_->SignalDestroyed.connect(this, &TestChannel::OnDestroyed);
-    src_->SendBindingResponse(remote_request_.get(), remote_address_);
+    port_->SendBindingResponse(remote_request_.get(), remote_address_);
     remote_request_.reset();
   }
   void Ping() {
     Ping(0);
   }
   void Ping(uint32 now) {
     conn_->Ping(now);
   }
   void Stop() {
     if (conn_) {
@@ skipping 10 matching lines @@
 
   int SendData(const char* data, size_t len) {
     rtc::PacketOptions options;
     return conn_->Send(data, len, options);
   }
 
   void OnUnknownAddress(PortInterface* port, const SocketAddress& addr,
                         ProtocolType proto,
                         IceMessage* msg, const std::string& rf,
                         bool /*port_muxed*/) {
-    ASSERT_EQ(src_.get(), port);
+    ASSERT_EQ(port_.get(), port);
     if (!remote_address_.IsNil()) {
       ASSERT_EQ(remote_address_, addr);
     }
     const cricket::StunUInt32Attribute* priority_attr =
         msg->GetUInt32(STUN_ATTR_PRIORITY);
     const cricket::StunByteStringAttribute* mi_attr =
         msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY);
     const cricket::StunUInt32Attribute* fingerprint_attr =
         msg->GetUInt32(STUN_ATTR_FINGERPRINT);
     EXPECT_TRUE(priority_attr != NULL);
     EXPECT_TRUE(mi_attr != NULL);
     EXPECT_TRUE(fingerprint_attr != NULL);
     remote_address_ = addr;
     remote_request_.reset(CopyStunMessage(msg));
     remote_frag_ = rf;
   }
 
   void OnDestroyed(Connection* conn) {
     ASSERT_EQ(conn_, conn);
     LOG(INFO) << "OnDestroy connection " << conn << " deleted";
     conn_ = NULL;
     // When the connection is destroyed, also clear these fields so future
     // connections are possible.
     remote_request_.reset();
     remote_address_.Clear();
   }
 
   void OnSrcPortDestroyed(PortInterface* port) {
-    Port* destroyed_src = src_.release();
+    Port* destroyed_src = port_.release();
     ASSERT_EQ(destroyed_src, port);
   }
 
-  Port* src_port() { return src_.get(); }
+  Port* port() { return port_.get(); }
 
   bool nominated() const { return nominated_; }
 
   void set_connection_ready_to_send(bool ready) {
     connection_ready_to_send_ = ready;
   }
   bool connection_ready_to_send() const {
     return connection_ready_to_send_;
   }
 
  private:
   // ReadyToSend will only issue after a Connection recovers from EWOULDBLOCK.
   void OnConnectionReadyToSend(Connection* conn) {
     ASSERT_EQ(conn, conn_);
     connection_ready_to_send_ = true;
   }
 
   IceMode ice_mode_;
-  rtc::scoped_ptr<Port> src_;
-  Port* dst_;
+  rtc::scoped_ptr<Port> port_;
 
   int complete_count_;
   Connection* conn_;
   SocketAddress remote_address_;
   rtc::scoped_ptr<StunMessage> remote_request_;
   std::string remote_frag_;
   bool nominated_;
   bool connection_ready_to_send_ = false;
 };
 
@@ skipping 218 matching lines @@
   // This connects the provided channels which have already started.  |ch1|
   // should have its Connection created (either through CreateConnection() or
   // TCP reconnecting mechanism before entering this function.
   void ConnectStartedChannels(TestChannel* ch1, TestChannel* ch2) {
     ASSERT_TRUE(ch1->conn());
     EXPECT_TRUE_WAIT(ch1->conn()->connected(), kTimeout);  // for TCP connect
     ch1->Ping();
     WAIT(!ch2->remote_address().IsNil(), kTimeout);
 
     // Send a ping from dst to src.
-    ch2->AcceptConnection();
+    ch2->AcceptConnection(GetCandidate(ch1->port()));
     ch2->Ping();
     EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch2->conn()->write_state(),
                    kTimeout);
   }
 
   // This connects and disconnects the provided channels in the same sequence as
   // TestConnectivity with all options set to |true|.  It does not delete either
   // channel.
   void StartConnectAndStopChannels(TestChannel* ch1, TestChannel* ch2) {
     // Acquire addresses.
     ch1->Start();
     ch2->Start();
 
-    ch1->CreateConnection();
+    ch1->CreateConnection(GetCandidate(ch2->port()));
     ConnectStartedChannels(ch1, ch2);
 
     // Destroy the connections.
     ch1->Stop();
     ch2->Stop();
   }
 
   // This disconnects both end's Connection and make sure ch2 ready for new
   // connection.
   void DisconnectTcpTestChannels(TestChannel* ch1, TestChannel* ch2) {
-    ASSERT_TRUE(ss_->CloseTcpConnections(
-        static_cast<TCPConnection*>(ch1->conn())->socket()->GetLocalAddress(),
-        static_cast<TCPConnection*>(ch2->conn())->socket()->GetLocalAddress()));
+    TCPConnection* tcp_conn1 = static_cast<TCPConnection*>(ch1->conn());
+    TCPConnection* tcp_conn2 = static_cast<TCPConnection*>(ch2->conn());
+    ASSERT_TRUE(
+        ss_->CloseTcpConnections(tcp_conn1->socket()->GetLocalAddress(),
+                                 tcp_conn2->socket()->GetLocalAddress()));
 
     // Wait for both OnClose are delivered.
     EXPECT_TRUE_WAIT(!ch1->conn()->connected(), kTimeout);
     EXPECT_TRUE_WAIT(!ch2->conn()->connected(), kTimeout);
 
-    // Destroy channel2 connection to get ready for new incoming TCPConnection.
+    // Ensure redundant SignalClose events on TcpConnection won't break tcp
+    // reconnection. Chromium will fire SignalClose for all outstanding IPC
+    // packets during reconnection.
+    tcp_conn1->socket()->SignalClose(tcp_conn1->socket(), 0);
+    tcp_conn2->socket()->SignalClose(tcp_conn2->socket(), 0);
+
+    // Speed up destroying ch2's connection such that the test is ready to
+    // accept a new connection from ch1 before ch1's connection destroys itself.
     ch2->conn()->Destroy();
     EXPECT_TRUE_WAIT(ch2->conn() == NULL, kTimeout);
   }
 
   void TestTcpReconnect(bool ping_after_disconnected,
                         bool send_after_disconnected) {
     Port* port1 = CreateTcpPort(kLocalAddr1);
     port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
     Port* port2 = CreateTcpPort(kLocalAddr2);
     port2->SetIceRole(cricket::ICEROLE_CONTROLLED);
 
     port1->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
     port2->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
 
     // Set up channels and ensure both ports will be deleted.
-    TestChannel ch1(port1, port2);
-    TestChannel ch2(port2, port1);
+    TestChannel ch1(port1);
+    TestChannel ch2(port2);
     EXPECT_EQ(0, ch1.complete_count());
     EXPECT_EQ(0, ch2.complete_count());
 
     ch1.Start();
     ch2.Start();
     ASSERT_EQ_WAIT(1, ch1.complete_count(), kTimeout);
     ASSERT_EQ_WAIT(1, ch2.complete_count(), kTimeout);
 
     // Initial connecting the channel, create connection on channel1.
-    ch1.CreateConnection();
+    ch1.CreateConnection(GetCandidate(port2));
     ConnectStartedChannels(&ch1, &ch2);
 
     // Shorten the timeout period.
     const int kTcpReconnectTimeout = kTimeout;
     static_cast<TCPConnection*>(ch1.conn())
         ->set_reconnection_timeout(kTcpReconnectTimeout);
     static_cast<TCPConnection*>(ch2.conn())
         ->set_reconnection_timeout(kTcpReconnectTimeout);
 
     EXPECT_FALSE(ch1.connection_ready_to_send());
@@ skipping 20 matching lines @@
       // Verify that we could still connect channels.
       ConnectStartedChannels(&ch1, &ch2);
       EXPECT_TRUE_WAIT(ch1.connection_ready_to_send(),
                        kTcpReconnectTimeout);
       // Channel2 is the passive one so a new connection is created during
       // reconnect. This new connection should never have issued EWOULDBLOCK
       // hence the connection_ready_to_send() should be false.
       EXPECT_FALSE(ch2.connection_ready_to_send());
     } else {
       EXPECT_EQ(ch1.conn()->write_state(), Connection::STATE_WRITABLE);
-      EXPECT_TRUE_WAIT(
-          ch1.conn()->write_state() == Connection::STATE_WRITE_TIMEOUT,
-          kTcpReconnectTimeout + kTimeout);
-      EXPECT_FALSE(ch1.connection_ready_to_send());
-      EXPECT_FALSE(ch2.connection_ready_to_send());
+      // Since the reconnection never happens, the connections should have been
+      // destroyed after the timeout.
+      EXPECT_TRUE_WAIT(!ch1.conn(), kTcpReconnectTimeout + kTimeout);
+      EXPECT_TRUE(!ch2.conn());
     }
 
     // Tear down and ensure that goes smoothly.
     ch1.Stop();
     ch2.Stop();
     EXPECT_TRUE_WAIT(ch1.conn() == NULL, kTimeout);
     EXPECT_TRUE_WAIT(ch2.conn() == NULL, kTimeout);
   }
 
   IceMessage* CreateStunMessage(int type) {
@@ skipping 39 matching lines @@
 
   void OnDestroyed(PortInterface* port) {
     destroyed_ = true;
   }
   bool destroyed() const { return destroyed_; }
 
   rtc::BasicPacketSocketFactory* nat_socket_factory1() {
     return &nat_socket_factory1_;
   }
 
+ protected:
+  rtc::VirtualSocketServer* vss() { return ss_.get(); }
+
  private:
   rtc::Thread* main_;
   rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
   rtc::scoped_ptr<rtc::VirtualSocketServer> ss_;
   rtc::SocketServerScope ss_scope_;
   rtc::Network network_;
   rtc::BasicPacketSocketFactory socket_factory_;
   rtc::scoped_ptr<rtc::NATServer> nat_server1_;
   rtc::scoped_ptr<rtc::NATServer> nat_server2_;
   rtc::NATSocketFactory nat_factory1_;
@@ skipping 11 matching lines @@
 
 void PortTest::TestConnectivity(const char* name1, Port* port1,
                                 const char* name2, Port* port2,
                                 bool accept, bool same_addr1,
                                 bool same_addr2, bool possible) {
   LOG(LS_INFO) << "Test: " << name1 << " to " << name2 << ": ";
   port1->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
   port2->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
 
   // Set up channels and ensure both ports will be deleted.
-  TestChannel ch1(port1, port2);
-  TestChannel ch2(port2, port1);
+  TestChannel ch1(port1);
+  TestChannel ch2(port2);
   EXPECT_EQ(0, ch1.complete_count());
   EXPECT_EQ(0, ch2.complete_count());
 
   // Acquire addresses.
   ch1.Start();
   ch2.Start();
   ASSERT_EQ_WAIT(1, ch1.complete_count(), kTimeout);
   ASSERT_EQ_WAIT(1, ch2.complete_count(), kTimeout);
 
   // Send a ping from src to dst. This may or may not make it.
-  ch1.CreateConnection();
+  ch1.CreateConnection(GetCandidate(port2));
   ASSERT_TRUE(ch1.conn() != NULL);
   EXPECT_TRUE_WAIT(ch1.conn()->connected(), kTimeout);  // for TCP connect
   ch1.Ping();
   WAIT(!ch2.remote_address().IsNil(), kTimeout);
 
   if (accept) {
     // We are able to send a ping from src to dst. This is the case when
     // sending to UDP ports and cone NATs.
     EXPECT_TRUE(ch1.remote_address().IsNil());
     EXPECT_EQ(ch2.remote_fragment(), port1->username_fragment());
 
     // Ensure the ping came from the same address used for src.
     // This is the case unless the source NAT was symmetric.
     if (same_addr1) EXPECT_EQ(ch2.remote_address(), GetAddress(port1));
     EXPECT_TRUE(same_addr2);
 
     // Send a ping from dst to src.
-    ch2.AcceptConnection();
+    ch2.AcceptConnection(GetCandidate(port1));
     ASSERT_TRUE(ch2.conn() != NULL);
     ch2.Ping();
     EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch2.conn()->write_state(),
                    kTimeout);
   } else {
     // We can't send a ping from src to dst, so flip it around. This will happen
     // when the destination NAT is addr/port restricted or symmetric.
     EXPECT_TRUE(ch1.remote_address().IsNil());
     EXPECT_TRUE(ch2.remote_address().IsNil());
 
     // Send a ping from dst to src. Again, this may or may not make it.
-    ch2.CreateConnection();
+    ch2.CreateConnection(GetCandidate(port1));
     ASSERT_TRUE(ch2.conn() != NULL);
     ch2.Ping();
     WAIT(ch2.conn()->write_state() == Connection::STATE_WRITABLE, kTimeout);
 
     if (same_addr1 && same_addr2) {
       // The new ping got back to the source.
       EXPECT_EQ(Connection::STATE_READABLE, ch1.conn()->read_state());
       EXPECT_EQ(Connection::STATE_WRITABLE, ch2.conn()->write_state());
 
       // First connection may not be writable if the first ping did not get
@@ skipping 10 matching lines @@
       EXPECT_TRUE(ch2.remote_address().IsNil());
 
       // However, since we have now sent a ping to the source IP, we should be
       // able to get a ping from it. This gives us the real source address.
       ch1.Ping();
       EXPECT_TRUE_WAIT(!ch2.remote_address().IsNil(), kTimeout);
       EXPECT_EQ(Connection::STATE_READ_INIT, ch2.conn()->read_state());
       EXPECT_TRUE(ch1.remote_address().IsNil());
 
       // Pick up the actual address and establish the connection.
-      ch2.AcceptConnection();
+      ch2.AcceptConnection(GetCandidate(port1));
       ASSERT_TRUE(ch2.conn() != NULL);
       ch2.Ping();
       EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch2.conn()->write_state(),
                      kTimeout);
     } else if (!same_addr2 && possible) {
       // The new ping came in, but from an unexpected address. This will happen
       // when the destination NAT is symmetric.
       EXPECT_FALSE(ch1.remote_address().IsNil());
       EXPECT_EQ(Connection::STATE_READ_INIT, ch1.conn()->read_state());
 
       // Update our address and complete the connection.
-      ch1.AcceptConnection();
+      ch1.AcceptConnection(GetCandidate(port2));
       ch1.Ping();
       EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(),
                      kTimeout);
     } else {  // (!possible)
       // There should be s no way for the pings to reach each other. Check it.
       EXPECT_TRUE(ch1.remote_address().IsNil());
       EXPECT_TRUE(ch2.remote_address().IsNil());
       ch1.Ping();
       WAIT(!ch2.remote_address().IsNil(), kTimeout);
       EXPECT_TRUE(ch1.remote_address().IsNil());
@@ skipping 304 matching lines @@
 }
 
 TEST_F(PortTest, TestTcpReconnectOnPing) {
   TestTcpReconnect(true /* ping */, false /* send */);
 }
 
 TEST_F(PortTest, TestTcpReconnectTimeout) {
   TestTcpReconnect(false /* ping */, false /* send */);
 }
 
+// Test when TcpConnection never connects, the OnClose() will be called to
+// destroy the connection.
+TEST_F(PortTest, TestTcpNeverConnect) {
+  Port* port1 = CreateTcpPort(kLocalAddr1);
+  port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
+  port1->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
+
+  // Set up a channel and ensure the port will be deleted.
+  TestChannel ch1(port1);
+  EXPECT_EQ(0, ch1.complete_count());
+
+  ch1.Start();
+  ASSERT_EQ_WAIT(1, ch1.complete_count(), kTimeout);
+
+  rtc::scoped_ptr<rtc::AsyncSocket> server(
+      vss()->CreateAsyncSocket(kLocalAddr2.family(), SOCK_STREAM));
+  // Bind but not listen.
+  EXPECT_EQ(0, server->Bind(kLocalAddr2));
+
+  Candidate c = GetCandidate(port1);
+  c.set_address(server->GetLocalAddress());
+
+  ch1.CreateConnection(c);
+  EXPECT_TRUE(ch1.conn());
+  EXPECT_TRUE_WAIT(!ch1.conn(), kTimeout);  // for TCP connect
+}
+
 /* TODO: Enable these once testrelayserver can accept external TCP.
 TEST_F(PortTest, TestTcpToTcpRelay) {
   TestTcpToRelay(PROTO_TCP);
 }
 
 TEST_F(PortTest, TestTcpToSslTcpRelay) {
   TestTcpToRelay(PROTO_SSLTCP);
 }
 */
 
@@ skipping 971 matching lines @@
 #endif
 }
 
 TEST_F(PortTest, TestWritableState) {
   UDPPort* port1 = CreateUdpPort(kLocalAddr1);
   port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
   UDPPort* port2 = CreateUdpPort(kLocalAddr2);
   port2->SetIceRole(cricket::ICEROLE_CONTROLLED);
 
   // Set up channels.
-  TestChannel ch1(port1, port2);
-  TestChannel ch2(port2, port1);
+  TestChannel ch1(port1);
+  TestChannel ch2(port2);
 
   // Acquire addresses.
   ch1.Start();
   ch2.Start();
   ASSERT_EQ_WAIT(1, ch1.complete_count(), kTimeout);
   ASSERT_EQ_WAIT(1, ch2.complete_count(), kTimeout);
 
   // Send a ping from src to dst.
-  ch1.CreateConnection();
+  ch1.CreateConnection(GetCandidate(port2));
   ASSERT_TRUE(ch1.conn() != NULL);
   EXPECT_EQ(Connection::STATE_WRITE_INIT, ch1.conn()->write_state());
   EXPECT_TRUE_WAIT(ch1.conn()->connected(), kTimeout);  // for TCP connect
   ch1.Ping();
   WAIT(!ch2.remote_address().IsNil(), kTimeout);
 
   // Data should be unsendable until the connection is accepted.
   char data[] = "abcd";
   int data_size = ARRAY_SIZE(data);
   rtc::PacketOptions options;
   EXPECT_EQ(SOCKET_ERROR, ch1.conn()->Send(data, data_size, options));
 
   // Accept the connection to return the binding response, transition to
   // writable, and allow data to be sent.
-  ch2.AcceptConnection();
+  ch2.AcceptConnection(GetCandidate(port1));
   EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(),
                  kTimeout);
   EXPECT_EQ(data_size, ch1.conn()->Send(data, data_size, options));
 
   // Ask the connection to update state as if enough time has passed to lose
   // full writability and 5 pings went unresponded to. We'll accomplish the
   // latter by sending pings but not pumping messages.
   for (uint32 i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) {
     ch1.Ping(i);
   }
@@ skipping 25 matching lines @@
   ch2.Stop();
 }
 
 TEST_F(PortTest, TestTimeoutForNeverWritable) {
   UDPPort* port1 = CreateUdpPort(kLocalAddr1);
   port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
   UDPPort* port2 = CreateUdpPort(kLocalAddr2);
   port2->SetIceRole(cricket::ICEROLE_CONTROLLED);
 
   // Set up channels.
-  TestChannel ch1(port1, port2);
-  TestChannel ch2(port2, port1);
+  TestChannel ch1(port1);
+  TestChannel ch2(port2);
 
   // Acquire addresses.
   ch1.Start();
   ch2.Start();
 
-  ch1.CreateConnection();
+  ch1.CreateConnection(GetCandidate(port2));
   ASSERT_TRUE(ch1.conn() != NULL);
   EXPECT_EQ(Connection::STATE_WRITE_INIT, ch1.conn()->write_state());
 
   // Attempt to go directly to write timeout.
   for (uint32 i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) {
     ch1.Ping(i);
   }
   ch1.conn()->UpdateState(CONNECTION_WRITE_TIMEOUT + 500u);
   EXPECT_EQ(Connection::STATE_WRITE_TIMEOUT, ch1.conn()->write_state());
 }
 
 // This test verifies the connection setup between ICEMODE_FULL
 // and ICEMODE_LITE.
 // In this test |ch1| behaves like FULL mode client and we have created
 // port which responds to the ping message just like LITE client.
 TEST_F(PortTest, TestIceLiteConnectivity) {
   TestPort* ice_full_port = CreateTestPort(
       kLocalAddr1, "lfrag", "lpass",
       cricket::ICEROLE_CONTROLLING, kTiebreaker1);
 
   rtc::scoped_ptr<TestPort> ice_lite_port(CreateTestPort(
       kLocalAddr2, "rfrag", "rpass",
       cricket::ICEROLE_CONTROLLED, kTiebreaker2));
   // Setup TestChannel. This behaves like FULL mode client.
-  TestChannel ch1(ice_full_port, ice_lite_port.get());
+  TestChannel ch1(ice_full_port);
   ch1.SetIceMode(ICEMODE_FULL);
 
   // Start gathering candidates.
   ch1.Start();
   ice_lite_port->PrepareAddress();
 
   ASSERT_EQ_WAIT(1, ch1.complete_count(), kTimeout);
   ASSERT_FALSE(ice_lite_port->Candidates().empty());
 
-  ch1.CreateConnection();
+  ch1.CreateConnection(GetCandidate(ice_lite_port.get()));
   ASSERT_TRUE(ch1.conn() != NULL);
   EXPECT_EQ(Connection::STATE_WRITE_INIT, ch1.conn()->write_state());
 
   // Send ping from full mode client.
   // This ping must not have USE_CANDIDATE_ATTR.
   ch1.Ping();
 
   // Verify stun ping is without USE_CANDIDATE_ATTR. Getting message directly
   // from port.
   ASSERT_TRUE_WAIT(ice_full_port->last_stun_msg() != NULL, 1000);
@@ skipping 36 matching lines @@
   ConnectToSignalDestroyed(port1);
   port1->set_timeout_delay(10);  // milliseconds
   port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
   port1->SetIceTiebreaker(kTiebreaker1);
 
   UDPPort* port2 = CreateUdpPort(kLocalAddr2);
   port2->SetIceRole(cricket::ICEROLE_CONTROLLED);
   port2->SetIceTiebreaker(kTiebreaker2);
 
   // Set up channels and ensure both ports will be deleted.
-  TestChannel ch1(port1, port2);
-  TestChannel ch2(port2, port1);
+  TestChannel ch1(port1);
+  TestChannel ch2(port2);
 
   // Simulate a connection that succeeds, and then is destroyed.
   StartConnectAndStopChannels(&ch1, &ch2);
 
   // After the connection is destroyed, the port should not be destroyed.
   rtc::Thread::Current()->ProcessMessages(kTimeout);
   EXPECT_FALSE(destroyed());
 }
 
 // This test case verifies that the CONTROLLED port does time out, but only
 // after connectivity is lost.
 TEST_F(PortTest, TestControlledTimeout) {
   UDPPort* port1 = CreateUdpPort(kLocalAddr1);
   port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
   port1->SetIceTiebreaker(kTiebreaker1);
 
   UDPPort* port2 = CreateUdpPort(kLocalAddr2);
   ConnectToSignalDestroyed(port2);
   port2->set_timeout_delay(10);  // milliseconds
   port2->SetIceRole(cricket::ICEROLE_CONTROLLED);
   port2->SetIceTiebreaker(kTiebreaker2);
 
   // The connection must not be destroyed before a connection is attempted.
   EXPECT_FALSE(destroyed());
 
   port1->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
   port2->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
 
   // Set up channels and ensure both ports will be deleted.
-  TestChannel ch1(port1, port2);
-  TestChannel ch2(port2, port1);
+  TestChannel ch1(port1);
+  TestChannel ch2(port2);
 
   // Simulate a connection that succeeds, and then is destroyed.
   StartConnectAndStopChannels(&ch1, &ch2);
 
   // The controlled port should be destroyed after 10 milliseconds.
   EXPECT_TRUE_WAIT(destroyed(), kTimeout);
 }