Revert of TransportController refactoring.

webrtc/p2p/base/p2ptransportchannel_unittest.cc

 /*
  *  Copyright 2009 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 279 matching lines @@
   }
   cricket::P2PTransportChannel* CreateChannel(
       int endpoint,
       int component,
       const std::string& local_ice_ufrag,
       const std::string& local_ice_pwd,
       const std::string& remote_ice_ufrag,
       const std::string& remote_ice_pwd) {
     cricket::P2PTransportChannel* channel = new cricket::P2PTransportChannel(
         "test content name", component, NULL, GetAllocator(endpoint));
-    channel->SignalCandidateGathered.connect(
-        this, &P2PTransportChannelTestBase::OnCandidate);
+    channel->SignalRequestSignaling.connect(
+        this, &P2PTransportChannelTestBase::OnChannelRequestSignaling);
+    channel->SignalCandidateReady.connect(this,
+        &P2PTransportChannelTestBase::OnCandidate);
     channel->SignalReadPacket.connect(
         this, &P2PTransportChannelTestBase::OnReadPacket);
     channel->SignalRoleConflict.connect(
         this, &P2PTransportChannelTestBase::OnRoleConflict);
     channel->SetIceCredentials(local_ice_ufrag, local_ice_pwd);
     if (clear_remote_candidates_ufrag_pwd_) {
       // This only needs to be set if we're clearing them from the
       // candidates.  Some unit tests rely on this not being set.
       channel->SetRemoteIceCredentials(remote_ice_ufrag, remote_ice_pwd);
     }
     channel->SetIceRole(GetEndpoint(endpoint)->ice_role());
     channel->SetIceTiebreaker(GetEndpoint(endpoint)->GetIceTiebreaker());
     channel->Connect();
-    channel->MaybeStartGathering();
     return channel;
   }
   void DestroyChannels() {
     ep1_.cd1_.ch_.reset();
     ep2_.cd1_.ch_.reset();
     ep1_.cd2_.ch_.reset();
     ep2_.cd2_.ch_.reset();
   }
   cricket::P2PTransportChannel* ep1_ch1() { return ep1_.cd1_.ch_.get(); }
   cricket::P2PTransportChannel* ep1_ch2() { return ep1_.cd2_.ch_.get(); }
@@ skipping 55 matching lines @@
     return GetEndpoint(endpoint)->role_conflict();
   }
   void SetAllocationStepDelay(int endpoint, uint32 delay) {
     return GetEndpoint(endpoint)->SetAllocationStepDelay(delay);
   }
   void SetAllowTcpListen(int endpoint, bool allow_tcp_listen) {
     return GetEndpoint(endpoint)->SetAllowTcpListen(allow_tcp_listen);
   }
 
   bool IsLocalToPrflxOrTheReverse(const Result& expected) {
-    return (
-        (expected.local_type == "local" && expected.remote_type == "prflx") ||
-        (expected.local_type == "prflx" && expected.remote_type == "local"));
+    return ((expected.local_type == "local" &&
+             expected.remote_type == "prflx") ||
+            (expected.local_type == "prflx" &&
+             expected.remote_type == "local"));
   }
 
   // Return true if the approprite parts of the expected Result, based
   // on the local and remote candidate of ep1_ch1, match.  This can be
   // used in an EXPECT_TRUE_WAIT.
   bool CheckCandidate1(const Result& expected) {
     const std::string& local_type = LocalCandidate(ep1_ch1())->type();
     const std::string& local_proto = LocalCandidate(ep1_ch1())->protocol();
     const std::string& remote_type = RemoteCandidate(ep1_ch1())->type();
     const std::string& remote_proto = RemoteCandidate(ep1_ch1())->protocol();
@@ skipping 99 matching lines @@
       LOG(LS_INFO) << "Connect time: " << "TIMEOUT ("
                    << expected.connect_wait << " ms)";
     }
 
     // Allow a few turns of the crank for the best connections to emerge.
     // This may take up to 2 seconds.
     if (ep1_ch1()->best_connection() &&
         ep2_ch1()->best_connection()) {
       int32 converge_start = rtc::Time(), converge_time;
       int converge_wait = 2000;
-      EXPECT_TRUE_WAIT_MARGIN(CheckCandidate1(expected), converge_wait,
-                              converge_wait);
+      EXPECT_TRUE_WAIT_MARGIN(CheckCandidate1(expected),
+                              converge_wait, converge_wait);
       // Also do EXPECT_EQ on each part so that failures are more verbose.
       ExpectCandidate1(expected);
 
       // Verifying remote channel best connection information. This is done
       // only for the RFC 5245 as controlled agent will use USE-CANDIDATE
       // from controlling (ep1) agent. We can easily predict from EP1 result
       // matrix.
 
       // Checking for best connection candidates information at remote.
       EXPECT_TRUE_WAIT(CheckCandidate2(expected), kDefaultTimeout);
@@ skipping 28 matching lines @@
         // local_channel2 <==> remote_channel2
         EXPECT_EQ_WAIT(len, SendData(ep1_ch2(), data, len), 1000);
         EXPECT_TRUE_WAIT(CheckDataOnChannel(ep2_ch2(), data, len), 1000);
         EXPECT_EQ_WAIT(len, SendData(ep2_ch2(), data, len), 1000);
         EXPECT_TRUE_WAIT(CheckDataOnChannel(ep1_ch2(), data, len), 1000);
       }
     }
   }
 
   // This test waits for the transport to become receiving and writable on both
-  // end points. Once they are, the end points set new local ice credentials and
+  // end points. Once they are, the end points set new local ice credentials to
   // restart the ice gathering. Finally it waits for the transport to select a
   // new connection using the newly generated ice candidates.
   // Before calling this function the end points must be configured.
   void TestHandleIceUfragPasswordChanged() {
     ep1_ch1()->SetRemoteIceCredentials(kIceUfrag[1], kIcePwd[1]);
     ep2_ch1()->SetRemoteIceCredentials(kIceUfrag[0], kIcePwd[0]);
     EXPECT_TRUE_WAIT_MARGIN(ep1_ch1()->receiving() && ep1_ch1()->writable() &&
                             ep2_ch1()->receiving() && ep2_ch1()->writable(),
                             1000, 1000);
 
     const cricket::Candidate* old_local_candidate1 = LocalCandidate(ep1_ch1());
     const cricket::Candidate* old_local_candidate2 = LocalCandidate(ep2_ch1());
     const cricket::Candidate* old_remote_candidate1 =
         RemoteCandidate(ep1_ch1());
     const cricket::Candidate* old_remote_candidate2 =
         RemoteCandidate(ep2_ch1());
 
     ep1_ch1()->SetIceCredentials(kIceUfrag[2], kIcePwd[2]);
     ep1_ch1()->SetRemoteIceCredentials(kIceUfrag[3], kIcePwd[3]);
-    ep1_ch1()->MaybeStartGathering();
     ep2_ch1()->SetIceCredentials(kIceUfrag[3], kIcePwd[3]);
     ep2_ch1()->SetRemoteIceCredentials(kIceUfrag[2], kIcePwd[2]);
-    ep2_ch1()->MaybeStartGathering();
 
     EXPECT_TRUE_WAIT_MARGIN(LocalCandidate(ep1_ch1())->generation() !=
                             old_local_candidate1->generation(),
                             1000, 1000);
     EXPECT_TRUE_WAIT_MARGIN(LocalCandidate(ep2_ch1())->generation() !=
                             old_local_candidate2->generation(),
                             1000, 1000);
     EXPECT_TRUE_WAIT_MARGIN(RemoteCandidate(ep1_ch1())->generation() !=
                             old_remote_candidate1->generation(),
                             1000, 1000);
@@ skipping 22 matching lines @@
                      ep2_ch1()->receiving() &&
                      ep2_ch1()->writable(),
                      1000);
 
     EXPECT_TRUE(ep1_ch1()->best_connection() &&
                 ep2_ch1()->best_connection());
 
     TestSendRecv(1);
   }
 
+  void OnChannelRequestSignaling(cricket::TransportChannelImpl* channel) {
+    channel->OnSignalingReady();
+  }
   // We pass the candidates directly to the other side.
   void OnCandidate(cricket::TransportChannelImpl* ch,
                    const cricket::Candidate& c) {
     if (force_relay_ && c.type() != cricket::RELAY_PORT_TYPE)
       return;
 
     if (GetEndpoint(ch)->save_candidates_) {
       GetEndpoint(ch)->saved_candidates_.push_back(new CandidateData(ch, c));
     } else {
       main_->Post(this, MSG_CANDIDATE, new CandidateData(ch, c));
@@ skipping 20 matching lines @@
         rtc::scoped_ptr<CandidateData> data(
             static_cast<CandidateData*>(msg->pdata));
         cricket::P2PTransportChannel* rch = GetRemoteChannel(data->channel);
         cricket::Candidate c = data->candidate;
         if (clear_remote_candidates_ufrag_pwd_) {
           c.set_username("");
           c.set_password("");
         }
         LOG(LS_INFO) << "Candidate(" << data->channel->component() << "->"
                      << rch->component() << "): " << c.ToString();
-        rch->AddRemoteCandidate(c);
+        rch->OnCandidate(c);
         break;
       }
     }
   }
   void OnReadPacket(cricket::TransportChannel* channel, const char* data,
                     size_t len, const rtc::PacketTime& packet_time,
                     int flags) {
     std::list<std::string>& packets = GetPacketList(channel);
     packets.push_front(std::string(data, len));
   }
@@ skipping 114 matching lines @@
                         "local", "tcp", "prflx", "tcp", 3000);
 
 // Test the matrix of all the connectivity types we expect to see in the wild.
 // Just test every combination of the configs in the Config enum.
 class P2PTransportChannelTest : public P2PTransportChannelTestBase {
  protected:
   static const Result* kMatrix[NUM_CONFIGS][NUM_CONFIGS];
   static const Result* kMatrixSharedUfrag[NUM_CONFIGS][NUM_CONFIGS];
   static const Result* kMatrixSharedSocketAsGice[NUM_CONFIGS][NUM_CONFIGS];
   static const Result* kMatrixSharedSocketAsIce[NUM_CONFIGS][NUM_CONFIGS];
-  void ConfigureEndpoints(Config config1,
-                          Config config2,
-                          int allocator_flags1,
-                          int allocator_flags2) {
+  void ConfigureEndpoints(Config config1, Config config2,
+                          int allocator_flags1, int allocator_flags2) {
     ServerAddresses stun_servers;
     stun_servers.insert(kStunAddr);
     GetEndpoint(0)->allocator_.reset(
         new cricket::BasicPortAllocator(&(GetEndpoint(0)->network_manager_),
         stun_servers,
         rtc::SocketAddress(), rtc::SocketAddress(),
         rtc::SocketAddress()));
     GetEndpoint(1)->allocator_.reset(
         new cricket::BasicPortAllocator(&(GetEndpoint(1)->network_manager_),
         stun_servers,
         rtc::SocketAddress(), rtc::SocketAddress(),
         rtc::SocketAddress()));
 
     cricket::RelayServerConfig relay_server(cricket::RELAY_TURN);
     relay_server.credentials = kRelayCredentials;
-    relay_server.ports.push_back(
-        cricket::ProtocolAddress(kTurnUdpIntAddr, cricket::PROTO_UDP, false));
+    relay_server.ports.push_back(cricket::ProtocolAddress(
+        kTurnUdpIntAddr, cricket::PROTO_UDP, false));
     GetEndpoint(0)->allocator_->AddRelay(relay_server);
     GetEndpoint(1)->allocator_->AddRelay(relay_server);
 
     int delay = kMinimumStepDelay;
     ConfigureEndpoint(0, config1);
     SetAllocatorFlags(0, allocator_flags1);
     SetAllocationStepDelay(0, delay);
     ConfigureEndpoint(1, config2);
     SetAllocatorFlags(1, allocator_flags2);
     SetAllocationStepDelay(1, delay);
@@ skipping 183 matching lines @@
 /*SC*/ {PULU, PUSU, PUSU, PURU, PURU, PUSU, PURU, NULL, NULL, LSRS, NULL, LTRT},
 /*!U*/ {PTLT, NULL, NULL, NULL, NULL, NULL, NULL, PTLT, LTPT, LSRS, NULL, LTRT},
 /*!T*/ {LTRT, NULL, NULL, NULL, NULL, NULL, NULL, PTLT, LTRT, LSRS, NULL, LTRT},
 /*HT*/ {LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, NULL, LSRS},
 /*PR*/ {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
 /*PR*/ {LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LSRS, NULL, LTRT},
 };
 
 // The actual tests that exercise all the various configurations.
 // Test names are of the form P2PTransportChannelTest_TestOPENToNAT_FULL_CONE
-#define P2P_TEST_DECLARATION(x, y, z)                            \
-  TEST_F(P2PTransportChannelTest, z##Test##x##To##y) {           \
-    ConfigureEndpoints(x, y, PORTALLOCATOR_ENABLE_SHARED_SOCKET, \
-                       PORTALLOCATOR_ENABLE_SHARED_SOCKET);      \
-    if (kMatrixSharedSocketAsIce[x][y] != NULL)                  \
-      Test(*kMatrixSharedSocketAsIce[x][y]);                     \
-    else                                                         \
-      LOG(LS_WARNING) << "Not yet implemented";                  \
+#define P2P_TEST_DECLARATION(x, y, z) \
+  TEST_F(P2PTransportChannelTest, z##Test##x##To##y) { \
+    ConfigureEndpoints(x, y, \
+                       PORTALLOCATOR_ENABLE_SHARED_SOCKET, \
+                       PORTALLOCATOR_ENABLE_SHARED_SOCKET);  \
+    if (kMatrixSharedSocketAsIce[x][y] != NULL) \
+      Test(*kMatrixSharedSocketAsIce[x][y]); \
+    else \
+    LOG(LS_WARNING) << "Not yet implemented"; \
   }
 
 #define P2P_TEST(x, y) \
   P2P_TEST_DECLARATION(x, y,)
 
 #define FLAKY_P2P_TEST(x, y) \
   P2P_TEST_DECLARATION(x, y, DISABLED_)
 
 // TODO(holmer): Disabled due to randomly failing on webrtc buildbots.
 // Issue: webrtc/2383
@@ skipping 34 matching lines @@
 P2P_TEST_SET(NAT_SYMMETRIC_THEN_CONE)
 P2P_TEST_SET(BLOCK_UDP)
 P2P_TEST_SET(BLOCK_UDP_AND_INCOMING_TCP)
 P2P_TEST_SET(BLOCK_ALL_BUT_OUTGOING_HTTP)
 P2P_TEST_SET(PROXY_HTTPS)
 P2P_TEST_SET(PROXY_SOCKS)
 
 // Test that we restart candidate allocation when local ufrag&pwd changed.
 // Standard Ice protocol is used.
 TEST_F(P2PTransportChannelTest, HandleUfragPwdChange) {
-  ConfigureEndpoints(OPEN, OPEN, kDefaultPortAllocatorFlags,
+  ConfigureEndpoints(OPEN, OPEN,
+                     kDefaultPortAllocatorFlags,
                      kDefaultPortAllocatorFlags);
   CreateChannels(1);
   TestHandleIceUfragPasswordChanged();
   DestroyChannels();
 }
 
 // Test the operation of GetStats.
 TEST_F(P2PTransportChannelTest, GetStats) {
-  ConfigureEndpoints(OPEN, OPEN, kDefaultPortAllocatorFlags,
+  ConfigureEndpoints(OPEN, OPEN,
+                     kDefaultPortAllocatorFlags,
                      kDefaultPortAllocatorFlags);
   CreateChannels(1);
   EXPECT_TRUE_WAIT_MARGIN(ep1_ch1()->receiving() && ep1_ch1()->writable() &&
                           ep2_ch1()->receiving() && ep2_ch1()->writable(),
                           1000, 1000);
   TestSendRecv(1);
   cricket::ConnectionInfos infos;
   ASSERT_TRUE(ep1_ch1()->GetStats(&infos));
   ASSERT_EQ(1U, infos.size());
   EXPECT_TRUE(infos[0].new_connection);
   EXPECT_TRUE(infos[0].best_connection);
   EXPECT_TRUE(infos[0].receiving);
   EXPECT_TRUE(infos[0].writable);
   EXPECT_FALSE(infos[0].timeout);
   EXPECT_EQ(10U, infos[0].sent_total_packets);
   EXPECT_EQ(0U, infos[0].sent_discarded_packets);
   EXPECT_EQ(10 * 36U, infos[0].sent_total_bytes);
   EXPECT_EQ(10 * 36U, infos[0].recv_total_bytes);
   EXPECT_GT(infos[0].rtt, 0U);
   DestroyChannels();
 }
 
 // Test that we properly create a connection on a STUN ping from unknown address
 // when the signaling is slow.
 TEST_F(P2PTransportChannelTest, PeerReflexiveCandidateBeforeSignaling) {
-  ConfigureEndpoints(OPEN, OPEN, kDefaultPortAllocatorFlags,
+  ConfigureEndpoints(OPEN, OPEN,
+                     kDefaultPortAllocatorFlags,
                      kDefaultPortAllocatorFlags);
   // Emulate no remote credentials coming in.
   set_clear_remote_candidates_ufrag_pwd(false);
   CreateChannels(1);
   // Only have remote credentials come in for ep2, not ep1.
   ep2_ch1()->SetRemoteIceCredentials(kIceUfrag[3], kIcePwd[3]);
 
   // Pause sending ep2's candidates to ep1 until ep1 receives the peer reflexive
   // candidate.
   PauseCandidates(1);
@@ skipping 23 matching lines @@
       "local",
       ep1_ch1()->best_connection()->remote_candidate().type(),
       2000);
   EXPECT_EQ(best_connection, ep1_ch1()->best_connection());
   DestroyChannels();
 }
 
 // Test that we properly create a connection on a STUN ping from unknown address
 // when the signaling is slow and the end points are behind NAT.
 TEST_F(P2PTransportChannelTest, PeerReflexiveCandidateBeforeSignalingWithNAT) {
-  ConfigureEndpoints(OPEN, NAT_SYMMETRIC, kDefaultPortAllocatorFlags,
+  ConfigureEndpoints(OPEN, NAT_SYMMETRIC,
+                     kDefaultPortAllocatorFlags,
                      kDefaultPortAllocatorFlags);
   // Emulate no remote credentials coming in.
   set_clear_remote_candidates_ufrag_pwd(false);
   CreateChannels(1);
   // Only have remote credentials come in for ep2, not ep1.
   ep2_ch1()->SetRemoteIceCredentials(kIceUfrag[3], kIcePwd[3]);
   // Pause sending ep2's candidates to ep1 until ep1 receives the peer reflexive
   // candidate.
   PauseCandidates(1);
 
@@ skipping 21 matching lines @@
   // Wait to verify the connection is not culled.
   WAIT(ep1_ch1()->writable(), 2000);
   EXPECT_EQ(ep2_ch1()->best_connection(), best_connection);
   EXPECT_EQ("prflx", ep1_ch1()->best_connection()->remote_candidate().type());
   DestroyChannels();
 }
 
 // Test that if remote candidates don't have ufrag and pwd, we still work.
 TEST_F(P2PTransportChannelTest, RemoteCandidatesWithoutUfragPwd) {
   set_clear_remote_candidates_ufrag_pwd(true);
-  ConfigureEndpoints(OPEN, OPEN, kDefaultPortAllocatorFlags,
+  ConfigureEndpoints(OPEN, OPEN,
+                     kDefaultPortAllocatorFlags,
                      kDefaultPortAllocatorFlags);
   CreateChannels(1);
   const cricket::Connection* best_connection = NULL;
   // Wait until the callee's connections are created.
   WAIT((best_connection = ep2_ch1()->best_connection()) != NULL, 1000);
   // Wait to see if they get culled; they shouldn't.
   WAIT(ep2_ch1()->best_connection() != best_connection, 1000);
   EXPECT_TRUE(ep2_ch1()->best_connection() == best_connection);
   DestroyChannels();
 }
 
 // Test that a host behind NAT cannot be reached when incoming_only
 // is set to true.
 TEST_F(P2PTransportChannelTest, IncomingOnlyBlocked) {
-  ConfigureEndpoints(NAT_FULL_CONE, OPEN, kDefaultPortAllocatorFlags,
+  ConfigureEndpoints(NAT_FULL_CONE, OPEN,
+                     kDefaultPortAllocatorFlags,
                      kDefaultPortAllocatorFlags);
 
   SetAllocatorFlags(0, kOnlyLocalPorts);
   CreateChannels(1);
   ep1_ch1()->set_incoming_only(true);
 
   // Pump for 1 second and verify that the channels are not connected.
   rtc::Thread::Current()->ProcessMessages(1000);
 
   EXPECT_FALSE(ep1_ch1()->receiving());
   EXPECT_FALSE(ep1_ch1()->writable());
   EXPECT_FALSE(ep2_ch1()->receiving());
   EXPECT_FALSE(ep2_ch1()->writable());
 
   DestroyChannels();
 }
 
 // Test that a peer behind NAT can connect to a peer that has
 // incoming_only flag set.
 TEST_F(P2PTransportChannelTest, IncomingOnlyOpen) {
-  ConfigureEndpoints(OPEN, NAT_FULL_CONE, kDefaultPortAllocatorFlags,
+  ConfigureEndpoints(OPEN, NAT_FULL_CONE,
+                     kDefaultPortAllocatorFlags,
                      kDefaultPortAllocatorFlags);
 
   SetAllocatorFlags(0, kOnlyLocalPorts);
   CreateChannels(1);
   ep1_ch1()->set_incoming_only(true);
 
   EXPECT_TRUE_WAIT_MARGIN(ep1_ch1() != NULL && ep2_ch1() != NULL &&
                           ep1_ch1()->receiving() && ep1_ch1()->writable() &&
                           ep2_ch1()->receiving() && ep2_ch1()->writable(),
                           1000, 1000);
@@ skipping 140 matching lines @@
       ep1_ch1()->best_connection() && ep2_ch1()->best_connection() &&
       LocalCandidate(ep1_ch1())->address().EqualIPs(kIPv6PublicAddrs[0]) &&
       RemoteCandidate(ep1_ch1())->address().EqualIPs(kIPv6PublicAddrs[1]));
 
   TestSendRecv(1);
   DestroyChannels();
 }
 
 // Testing forceful TURN connections.
 TEST_F(P2PTransportChannelTest, TestForceTurn) {
-  ConfigureEndpoints(
-      NAT_PORT_RESTRICTED, NAT_SYMMETRIC,
-      kDefaultPortAllocatorFlags | cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET,
-      kDefaultPortAllocatorFlags | cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET);
+  ConfigureEndpoints(NAT_PORT_RESTRICTED, NAT_SYMMETRIC,
+                     kDefaultPortAllocatorFlags |
+                         cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET,
+                     kDefaultPortAllocatorFlags |
+                         cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET);
   set_force_relay(true);
 
   SetAllocationStepDelay(0, kMinimumStepDelay);
   SetAllocationStepDelay(1, kMinimumStepDelay);
 
   CreateChannels(1);
 
   EXPECT_TRUE_WAIT(ep1_ch1()->receiving() && ep1_ch1()->writable() &&
                        ep2_ch1()->receiving() && ep2_ch1()->writable(),
                    2000);
@@ skipping 34 matching lines @@
       nat->AddTranslator(kPrivateAddrs[endpoint], kCascadedNatAddrs[endpoint],
           static_cast<rtc::NATType>(config - NAT_FULL_CONE))->AddClient(
               kCascadedPrivateAddrs[endpoint]);
     }
   }
 };
 
 TEST_F(P2PTransportChannelSameNatTest, TestConesBehindSameCone) {
   ConfigureEndpoints(NAT_FULL_CONE, NAT_FULL_CONE, NAT_FULL_CONE);
   Test(P2PTransportChannelTestBase::Result(
-      "prflx", "udp", "stun", "udp", "stun", "udp", "prflx", "udp", 1000));
+      "prflx", "udp", "stun", "udp",
+      "stun", "udp", "prflx", "udp", 1000));
 }
 
 // Test what happens when we have multiple available pathways.
 // In the future we will try different RTTs and configs for the different
 // interfaces, so that we can simulate a user with Ethernet and VPN networks.
 class P2PTransportChannelMultihomedTest : public P2PTransportChannelTestBase {
 };
 
 // Test that we can establish connectivity when both peers are multihomed.
 TEST_F(P2PTransportChannelMultihomedTest, DISABLED_TestBasic) {
@@ skipping 65 matching lines @@
   EXPECT_TRUE_WAIT(ep1_ch1()->receiving() && ep1_ch1()->writable() &&
                    ep2_ch1()->receiving() && ep2_ch1()->writable(),
                    1000);
   EXPECT_TRUE(
       ep1_ch1()->best_connection() && ep2_ch1()->best_connection() &&
       LocalCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[0]) &&
       RemoteCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[1]));
 
 
   // Remove the public interface, add the alternate interface, and allocate
-  // a new generation of candidates for the new interface (via
-  // MaybeStartGathering()).
+  // a new generation of candidates for the new interface (via Connect()).
   LOG(LS_INFO) << "Draining...";
   AddAddress(1, kAlternateAddrs[1]);
   RemoveAddress(1, kPublicAddrs[1]);
-  ep2_ch1()->MaybeStartGathering();
+  ep2_ch1()->Connect();
 
   // We should switch over to use the alternate address after
   // an exchange of pings.
   EXPECT_TRUE_WAIT(
       ep1_ch1()->best_connection() && ep2_ch1()->best_connection() &&
       LocalCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[0]) &&
       RemoteCandidate(ep1_ch1())->address().EqualIPs(kAlternateAddrs[1]),
       3000);
 
   DestroyChannels();
 }
 
 */
 
 // A collection of tests which tests a single P2PTransportChannel by sending
 // pings.
 class P2PTransportChannelPingTest : public testing::Test,
                                     public sigslot::has_slots<> {
  public:
   P2PTransportChannelPingTest()
       : pss_(new rtc::PhysicalSocketServer),
         vss_(new rtc::VirtualSocketServer(pss_.get())),
         ss_scope_(vss_.get()) {}
 
  protected:
   void PrepareChannel(cricket::P2PTransportChannel* ch) {
+    ch->SignalRequestSignaling.connect(
+        this, &P2PTransportChannelPingTest::OnChannelRequestSignaling);
     ch->SetIceRole(cricket::ICEROLE_CONTROLLING);
     ch->SetIceCredentials(kIceUfrag[0], kIcePwd[0]);
     ch->SetRemoteIceCredentials(kIceUfrag[1], kIcePwd[1]);
   }
 
+  void OnChannelRequestSignaling(cricket::TransportChannelImpl* channel) {
+    channel->OnSignalingReady();
+  }
+
   cricket::Candidate CreateCandidate(const std::string& ip,
                                      int port,
                                      int priority) {
     cricket::Candidate c;
     c.set_address(rtc::SocketAddress(ip, port));
     c.set_component(1);
     c.set_protocol(cricket::UDP_PROTOCOL_NAME);
     c.set_priority(priority);
     return c;
   }
@@ skipping 26 matching lines @@
   rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
   rtc::scoped_ptr<rtc::VirtualSocketServer> vss_;
   rtc::SocketServerScope ss_scope_;
 };
 
 TEST_F(P2PTransportChannelPingTest, TestTriggeredChecks) {
   cricket::FakePortAllocator pa(rtc::Thread::Current(), nullptr);
   cricket::P2PTransportChannel ch("trigger checks", 1, nullptr, &pa);
   PrepareChannel(&ch);
   ch.Connect();
-  ch.MaybeStartGathering();
-  ch.AddRemoteCandidate(CreateCandidate("1.1.1.1", 1, 1));
-  ch.AddRemoteCandidate(CreateCandidate("2.2.2.2", 2, 2));
+  ch.OnCandidate(CreateCandidate("1.1.1.1", 1, 1));
+  ch.OnCandidate(CreateCandidate("2.2.2.2", 2, 2));
 
   cricket::Connection* conn1 = WaitForConnectionTo(&ch, "1.1.1.1", 1);
   cricket::Connection* conn2 = WaitForConnectionTo(&ch, "2.2.2.2", 2);
   ASSERT_TRUE(conn1 != nullptr);
   ASSERT_TRUE(conn2 != nullptr);
 
   // Before a triggered check, the first connection to ping is the
   // highest priority one.
   EXPECT_EQ(conn2, ch.FindNextPingableConnection());
 
   // Receiving a ping causes a triggered check which should make conn1
   // be pinged first instead of conn2, even though conn2 has a higher
   // priority.
   conn1->ReceivedPing();
   EXPECT_EQ(conn1, ch.FindNextPingableConnection());
 }
 
 TEST_F(P2PTransportChannelPingTest, TestNoTriggeredChecksWhenWritable) {
   cricket::FakePortAllocator pa(rtc::Thread::Current(), nullptr);
   cricket::P2PTransportChannel ch("trigger checks", 1, nullptr, &pa);
   PrepareChannel(&ch);
   ch.Connect();
-  ch.MaybeStartGathering();
-  ch.AddRemoteCandidate(CreateCandidate("1.1.1.1", 1, 1));
-  ch.AddRemoteCandidate(CreateCandidate("2.2.2.2", 2, 2));
+  ch.OnCandidate(CreateCandidate("1.1.1.1", 1, 1));
+  ch.OnCandidate(CreateCandidate("2.2.2.2", 2, 2));
 
   cricket::Connection* conn1 = WaitForConnectionTo(&ch, "1.1.1.1", 1);
   cricket::Connection* conn2 = WaitForConnectionTo(&ch, "2.2.2.2", 2);
   ASSERT_TRUE(conn1 != nullptr);
   ASSERT_TRUE(conn2 != nullptr);
 
   EXPECT_EQ(conn2, ch.FindNextPingableConnection());
   conn1->ReceivedPingResponse();
   ASSERT_TRUE(conn1->writable());
   conn1->ReceivedPing();
 
   // Ping received, but the connection is already writable, so no
   // "triggered check" and conn2 is pinged before conn1 because it has
   // a higher priority.
   EXPECT_EQ(conn2, ch.FindNextPingableConnection());
 }
 
 TEST_F(P2PTransportChannelPingTest, ConnectionResurrection) {
   cricket::FakePortAllocator pa(rtc::Thread::Current(), nullptr);
   cricket::P2PTransportChannel ch("connection resurrection", 1, nullptr, &pa);
   PrepareChannel(&ch);
   ch.Connect();
-  ch.MaybeStartGathering();
 
   // Create conn1 and keep track of original candidate priority.
-  ch.AddRemoteCandidate(CreateCandidate("1.1.1.1", 1, 1));
+  ch.OnCandidate(CreateCandidate("1.1.1.1", 1, 1));
   cricket::Connection* conn1 = WaitForConnectionTo(&ch, "1.1.1.1", 1);
   ASSERT_TRUE(conn1 != nullptr);
   uint32 remote_priority = conn1->remote_candidate().priority();
 
   // Create a higher priority candidate and make the connection
   // receiving/writable. This will prune conn1.
-  ch.AddRemoteCandidate(CreateCandidate("2.2.2.2", 2, 2));
+  ch.OnCandidate(CreateCandidate("2.2.2.2", 2, 2));
   cricket::Connection* conn2 = WaitForConnectionTo(&ch, "2.2.2.2", 2);
   ASSERT_TRUE(conn2 != nullptr);
   conn2->ReceivedPing();
   conn2->ReceivedPingResponse();
 
   // Wait for conn1 to be destroyed.
   EXPECT_TRUE_WAIT(GetConnectionTo(&ch, "1.1.1.1", 1) == nullptr, 3000);
   cricket::Port* port = GetPort(&ch);
 
   // Create a minimal STUN message with prflx priority.
@@ skipping 26 matching lines @@
   cricket::P2PTransportChannel ch("receiving state change", 1, nullptr, &pa);
   PrepareChannel(&ch);
   // Default receiving timeout and checking receiving delay should not be too
   // small.
   EXPECT_LE(1000, ch.receiving_timeout());
   EXPECT_LE(200, ch.check_receiving_delay());
   ch.SetReceivingTimeout(500);
   EXPECT_EQ(500, ch.receiving_timeout());
   EXPECT_EQ(50, ch.check_receiving_delay());
   ch.Connect();
-  ch.MaybeStartGathering();
-  ch.AddRemoteCandidate(CreateCandidate("1.1.1.1", 1, 1));
+  ch.OnCandidate(CreateCandidate("1.1.1.1", 1, 1));
   cricket::Connection* conn1 = WaitForConnectionTo(&ch, "1.1.1.1", 1);
   ASSERT_TRUE(conn1 != nullptr);
 
   conn1->ReceivedPing();
   conn1->OnReadPacket("ABC", 3, rtc::CreatePacketTime(0));
   EXPECT_TRUE_WAIT(ch.best_connection() != nullptr, 1000)
   EXPECT_TRUE_WAIT(ch.receiving(), 1000);
   EXPECT_TRUE_WAIT(!ch.receiving(), 1000);
 }
 
 // The controlled side will select a connection as the "best connection" based
 // on priority until the controlling side nominates a connection, at which
 // point the controlled side will select that connection as the
 // "best connection".
 TEST_F(P2PTransportChannelPingTest, TestSelectConnectionBeforeNomination) {
   cricket::FakePortAllocator pa(rtc::Thread::Current(), nullptr);
   cricket::P2PTransportChannel ch("receiving state change", 1, nullptr, &pa);
   PrepareChannel(&ch);
   ch.SetIceRole(cricket::ICEROLE_CONTROLLED);
   ch.Connect();
-  ch.MaybeStartGathering();
-  ch.AddRemoteCandidate(CreateCandidate("1.1.1.1", 1, 1));
+  ch.OnCandidate(CreateCandidate("1.1.1.1", 1, 1));
   cricket::Connection* conn1 = WaitForConnectionTo(&ch, "1.1.1.1", 1);
   ASSERT_TRUE(conn1 != nullptr);
   EXPECT_EQ(conn1, ch.best_connection());
 
   // When a higher priority candidate comes in, the new connection is chosen
   // as the best connection.
-  ch.AddRemoteCandidate(CreateCandidate("2.2.2.2", 2, 10));
+  ch.OnCandidate(CreateCandidate("2.2.2.2", 2, 10));
   cricket::Connection* conn2 = WaitForConnectionTo(&ch, "2.2.2.2", 2);
   ASSERT_TRUE(conn1 != nullptr);
   EXPECT_EQ(conn2, ch.best_connection());
 
   // If a stun request with use-candidate attribute arrives, the receiving
   // connection will be set as the best connection, even though
   // its priority is lower.
-  ch.AddRemoteCandidate(CreateCandidate("3.3.3.3", 3, 1));
+  ch.OnCandidate(CreateCandidate("3.3.3.3", 3, 1));
   cricket::Connection* conn3 = WaitForConnectionTo(&ch, "3.3.3.3", 3);
   ASSERT_TRUE(conn3 != nullptr);
   // Because it has a lower priority, the best connection is still conn2.
   EXPECT_EQ(conn2, ch.best_connection());
   conn3->ReceivedPingResponse();  // Become writable.
   // But if it is nominated via use_candidate, it is chosen as the best
   // connection.
   conn3->set_nominated(true);
   conn3->SignalNominated(conn3);
   EXPECT_EQ(conn3, ch.best_connection());
 
   // Even if another higher priority candidate arrives,
   // it will not be set as the best connection because the best connection
   // is nominated by the controlling side.
-  ch.AddRemoteCandidate(CreateCandidate("4.4.4.4", 4, 100));
+  ch.OnCandidate(CreateCandidate("4.4.4.4", 4, 100));
   cricket::Connection* conn4 = WaitForConnectionTo(&ch, "4.4.4.4", 4);
   ASSERT_TRUE(conn4 != nullptr);
   EXPECT_EQ(conn3, ch.best_connection());
   // But if it is nominated via use_candidate and writable, it will be set as
   // the best connection.
   conn4->set_nominated(true);
   conn4->SignalNominated(conn4);
   // Not switched yet because conn4 is not writable.
   EXPECT_EQ(conn3, ch.best_connection());
   // The best connection switches after conn4 becomes writable.
   conn4->ReceivedPingResponse();
   EXPECT_EQ(conn4, ch.best_connection());
 }
 
 // The controlled side will select a connection as the "best connection" based
 // on requests from an unknown address before the controlling side nominates
 // a connection, and will nominate a connection from an unknown address if the
 // request contains the use_candidate attribute.
 TEST_F(P2PTransportChannelPingTest, TestSelectConnectionFromUnknownAddress) {
   cricket::FakePortAllocator pa(rtc::Thread::Current(), nullptr);
   cricket::P2PTransportChannel ch("receiving state change", 1, nullptr, &pa);
   PrepareChannel(&ch);
   ch.SetIceRole(cricket::ICEROLE_CONTROLLED);
   ch.Connect();
-  ch.MaybeStartGathering();
   // A minimal STUN message with prflx priority.
   cricket::IceMessage request;
   request.SetType(cricket::STUN_BINDING_REQUEST);
   request.AddAttribute(new cricket::StunByteStringAttribute(
       cricket::STUN_ATTR_USERNAME, kIceUfrag[1]));
   uint32 prflx_priority = cricket::ICE_TYPE_PREFERENCE_PRFLX << 24;
   request.AddAttribute(new cricket::StunUInt32Attribute(
       cricket::STUN_ATTR_PRIORITY, prflx_priority));
   cricket::Port* port = GetPort(&ch);
   port->SignalUnknownAddress(port, rtc::SocketAddress("1.1.1.1", 1),
                              cricket::PROTO_UDP, &request, kIceUfrag[1], false);
   cricket::Connection* conn1 = WaitForConnectionTo(&ch, "1.1.1.1", 1);
   ASSERT_TRUE(conn1 != nullptr);
   EXPECT_EQ(conn1, ch.best_connection());
   conn1->ReceivedPingResponse();
   EXPECT_EQ(conn1, ch.best_connection());
 
   // Another connection is nominated via use_candidate.
-  ch.AddRemoteCandidate(CreateCandidate("2.2.2.2", 2, 1));
+  ch.OnCandidate(CreateCandidate("2.2.2.2", 2, 1));
   cricket::Connection* conn2 = WaitForConnectionTo(&ch, "2.2.2.2", 2);
   ASSERT_TRUE(conn2 != nullptr);
   // Because it has a lower priority, the best connection is still conn1.
   EXPECT_EQ(conn1, ch.best_connection());
   // When it is nominated via use_candidate and writable, it is chosen as the
   // best connection.
   conn2->ReceivedPingResponse();  // Become writable.
   conn2->set_nominated(true);
   conn2->SignalNominated(conn2);
   EXPECT_EQ(conn2, ch.best_connection());
@@ skipping 25 matching lines @@
 // The controlled side will select a connection as the "best connection"
 // based on media received until the controlling side nominates a connection,
 // at which point the controlled side will select that connection as
 // the "best connection".
 TEST_F(P2PTransportChannelPingTest, TestSelectConnectionBasedOnMediaReceived) {
   cricket::FakePortAllocator pa(rtc::Thread::Current(), nullptr);
   cricket::P2PTransportChannel ch("receiving state change", 1, nullptr, &pa);
   PrepareChannel(&ch);
   ch.SetIceRole(cricket::ICEROLE_CONTROLLED);
   ch.Connect();
-  ch.MaybeStartGathering();
-  ch.AddRemoteCandidate(CreateCandidate("1.1.1.1", 1, 10));
+  ch.OnCandidate(CreateCandidate("1.1.1.1", 1, 10));
   cricket::Connection* conn1 = WaitForConnectionTo(&ch, "1.1.1.1", 1);
   ASSERT_TRUE(conn1 != nullptr);
   EXPECT_EQ(conn1, ch.best_connection());
 
   // If a data packet is received on conn2, the best connection should
   // switch to conn2 because the controlled side must mirror the media path
   // chosen by the controlling side.
-  ch.AddRemoteCandidate(CreateCandidate("2.2.2.2", 2, 1));
+  ch.OnCandidate(CreateCandidate("2.2.2.2", 2, 1));
   cricket::Connection* conn2 = WaitForConnectionTo(&ch, "2.2.2.2", 2);
   ASSERT_TRUE(conn2 != nullptr);
   conn2->ReceivedPing();  // Start receiving.
   // Do not switch because it is not writable.
   conn2->OnReadPacket("ABC", 3, rtc::CreatePacketTime(0));
   EXPECT_EQ(conn1, ch.best_connection());
 
   conn2->ReceivedPingResponse();  // Become writable.
   // Switch because it is writable.
   conn2->OnReadPacket("DEF", 3, rtc::CreatePacketTime(0));
@@ skipping 19 matching lines @@
   conn3->ReceivedPingResponse();           // Become writable.
   EXPECT_EQ(conn3, ch.best_connection());
 
   // Now another data packet will not switch the best connection because the
   // best connection was nominated by the controlling side.
   conn2->ReceivedPing();
   conn2->ReceivedPingResponse();
   conn2->OnReadPacket("XYZ", 3, rtc::CreatePacketTime(0));
   EXPECT_EQ(conn3, ch.best_connection());
 }