Start ICE connectivity checks as soon as the first pair is pingable.

webrtc/p2p/base/p2ptransportchannel.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 136 matching lines @@
   connection->SignalReadPacket.connect(
       this, &P2PTransportChannel::OnReadPacket);
   connection->SignalReadyToSend.connect(
       this, &P2PTransportChannel::OnReadyToSend);
   connection->SignalStateChange.connect(
       this, &P2PTransportChannel::OnConnectionStateChange);
   connection->SignalDestroyed.connect(
       this, &P2PTransportChannel::OnConnectionDestroyed);
   connection->SignalNominated.connect(this, &P2PTransportChannel::OnNominated);
   had_connection_ = true;
+  // If this is the first connection and we have remote ICE credentials, we can
+  // start pinging.
+  MaybeStartPinging();
 }
 
 // Determines whether we should switch the selected connection to
 // |new_connection| based the writable/receiving state, the nomination state,
 // and the last data received time. This prevents the controlled side from
 // switching the selected connection too frequently when the controlling side
 // is doing aggressive nominations. The precedence of the connection switching
 // criteria is as follows:
 // i) write/receiving/connected states
 // ii) For controlled side,
@@ skipping 114 matching lines @@
   }
   // We need to update the credentials and generation for any peer reflexive
   // candidates.
   for (Connection* conn : connections_) {
     conn->MaybeSetRemoteIceCredentialsAndGeneration(
         ice_ufrag, ice_pwd,
         static_cast<int>(remote_ice_parameters_.size() - 1));
   }
   // Updating the remote ICE candidate generation could change the sort order.
   RequestSort();
+  // If this is the first time receiving ICE credentials and we already have a
+  // connection (for example, to a prflx candidate), we can start pinging.
+  MaybeStartPinging();
 }
 
 void P2PTransportChannel::SetRemoteIceMode(IceMode mode) {
   remote_ice_mode_ = mode;
 }
 
 void P2PTransportChannel::SetIceConfig(const IceConfig& config) {
   config_.gather_continually = config.gather_continually;
   LOG(LS_INFO) << "Set gather_continually to " << config_.gather_continually;
 
@@ skipping 44 matching lines @@
       LOG(LS_INFO) << "Set presume writable when fully relayed to "
                    << config_.presume_writable_when_fully_relayed;
     }
   }
 }
 
 const IceConfig& P2PTransportChannel::config() const {
   return config_;
 }
 
-// Go into the state of processing candidates, and running in general
-void P2PTransportChannel::Connect() {
-  ASSERT(worker_thread_ == rtc::Thread::Current());
+void P2PTransportChannel::MaybeStartGathering() {
   if (ice_ufrag_.empty() || ice_pwd_.empty()) {
-    ASSERT(false);
-    LOG(LS_ERROR) << "P2PTransportChannel::Connect: The ice_ufrag_ and the "
-                  << "ice_pwd_ are not set.";
     return;
   }
-
-  // Start checking and pinging as the ports come in.
-  thread()->Post(RTC_FROM_HERE, this, MSG_CHECK_AND_PING);
-}
-
-void P2PTransportChannel::MaybeStartGathering() {
   // Start gathering if we never started before, or if an ICE restart occurred.
   if (allocator_sessions_.empty() ||
       IceCredentialsChanged(allocator_sessions_.back()->ice_ufrag(),
                             allocator_sessions_.back()->ice_pwd(), ice_ufrag_,
                             ice_pwd_)) {
     if (gathering_state_ != kIceGatheringGathering) {
       gathering_state_ = kIceGatheringGathering;
       SignalGatheringState(this);
     }
     // Time for a new allocator.
@@ skipping 565 matching lines @@
 }
 
 // Prepare for best candidate sorting.
 void P2PTransportChannel::RequestSort() {
   if (!sort_dirty_) {
     worker_thread_->Post(RTC_FROM_HERE, this, MSG_SORT);
     sort_dirty_ = true;
   }
 }
 
+void P2PTransportChannel::MaybeStartPinging() {
+  if (started_pinging_) {
+    return;
+  }
+
+  int64_t now = rtc::TimeMillis();
+  for (const Connection* c : connections_) {
+    if (IsPingable(c, now)) {

[pthatcher1, 2016/06/28 01:16:32]

Could be slightly more readable with:

if (std::none_of(connections_....IsPingable...)) {
  return;
}

...
started_pinging_ = true;

[Taylor Brandstetter, 2016/06/28 02:01:42]

Done. Though I think:

if (any_of) {
  do_thing();
}

is more readable than:

if (none_of) {
  return;
}
do_thing();"

+      LOG_J(LS_INFO, this) << "Have a pingable connection for the first time; "
+                           << "starting to ping.";
+      thread()->Post(RTC_FROM_HERE, this, MSG_CHECK_AND_PING);
+      started_pinging_ = true;
+      return;
+    }
+  }
+}
+
 // Compare two connections based on their writing, receiving, and connected
 // states.
 int P2PTransportChannel::CompareConnectionStates(const Connection* a,
                                                  const Connection* b) const {
   // First, prefer a connection that's writable or presumed writable over
   // one that's not writable.
   bool a_writable = a->writable() || PresumedWritable(a);
   bool b_writable = b->writable() || PresumedWritable(b);
   if (a_writable && !b_writable) {
     return a_is_better;
@@ skipping 454 matching lines @@
       PingConnection(conn);
       MarkConnectionPinged(conn);
     }
   }
   int delay = std::min(ping_interval, check_receiving_interval_);
   thread()->PostDelayed(RTC_FROM_HERE, delay, this, MSG_CHECK_AND_PING);
 }
 
 // A connection is considered a backup connection if the channel state
 // is completed, the connection is not the selected connection and it is active.
-bool P2PTransportChannel::IsBackupConnection(Connection* conn) const {
+bool P2PTransportChannel::IsBackupConnection(const Connection* conn) const {
   return state_ == STATE_COMPLETED && conn != selected_connection_ &&
          conn->active();
 }
 
 // Is the connection in a state for us to even consider pinging the other side?
 // We consider a connection pingable even if it's not connected because that's
 // how a TCP connection is kicked into reconnecting on the active side.
-bool P2PTransportChannel::IsPingable(Connection* conn, int64_t now) {
+bool P2PTransportChannel::IsPingable(const Connection* conn,
+                                     int64_t now) const {
   const Candidate& remote = conn->remote_candidate();
   // We should never get this far with an empty remote ufrag.
   ASSERT(!remote.username().empty());
   if (remote.username().empty() || remote.password().empty()) {
     // If we don't have an ICE ufrag and pwd, there's no way we can ping.
     return false;
   }
 
   // A failed connection will not be pinged.
   if (conn->state() == Connection::STATE_FAILED) {
@@ skipping 37 matching lines @@
 bool P2PTransportChannel::IsSelectedConnectionPingable(int64_t now) {
   if (!selected_connection_ || !selected_connection_->connected() ||
       !selected_connection_->writable()) {
     return false;
   }
 
   int interval = CalculateActiveWritablePingInterval(selected_connection_, now);
   return selected_connection_->last_ping_sent() + interval <= now;
 }
 
-int P2PTransportChannel::CalculateActiveWritablePingInterval(Connection* conn,
-                                                             int64_t now) {
+int P2PTransportChannel::CalculateActiveWritablePingInterval(
+    const Connection* conn,
+    int64_t now) const {
   // Ping each connection at a higher rate at least
   // MIN_PINGS_AT_WEAK_PING_INTERVAL times.
   if (conn->num_pings_sent() < MIN_PINGS_AT_WEAK_PING_INTERVAL) {
     return weak_ping_interval_;
   }
 
   int stable_interval = config_.stable_writable_connection_ping_interval;
   int stablizing_interval =
       std::min(stable_interval, STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL);
 
@@ skipping 292 matching lines @@
 
   // During the initial state when nothing has been pinged yet, return the first
   // one in the ordered |connections_|.
   return *(std::find_if(connections_.begin(), connections_.end(),
                         [conn1, conn2](Connection* conn) {
                           return conn == conn1 || conn == conn2;
                         }));
 }
 
 }  // namespace cricket