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

webrtc/p2p/base/faketransportcontroller.h

 /*
  *  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 93 matching lines @@
   }
   bool SetSslRole(rtc::SSLRole role) override {
     ssl_role_ = role;
     return true;
   }
   bool GetSslRole(rtc::SSLRole* role) const override {
     *role = ssl_role_;
     return true;
   }
 
-  void Connect() override {
-    if (state_ == STATE_INIT) {
-      state_ = STATE_CONNECTING;
-    }
-  }
-
   void MaybeStartGathering() override {
     if (gathering_state_ == kIceGatheringNew) {
       gathering_state_ = kIceGatheringGathering;
       SignalGatheringState(this);
     }
   }
 
   IceGatheringState gathering_state() const override {
     return gathering_state_;
   }
 
   void Reset() {
     if (state_ != STATE_INIT) {
       state_ = STATE_INIT;
       if (dest_) {
         dest_->state_ = STATE_INIT;
         dest_->dest_ = nullptr;
         dest_ = nullptr;
       }
     }
   }
 
   void SetWritable(bool writable) { set_writable(writable); }
 
   // Simulates the two transport channels connecting to each other.
   // If |asymmetric| is true this method only affects this FakeTransportChannel.
   // If false, it affects |dest| as well.
   void SetDestination(FakeTransportChannel* dest, bool asymmetric = false) {
-    if (state_ == STATE_CONNECTING && dest) {
+    if (state_ == STATE_INIT && dest) {
       // This simulates the delivery of candidates.
       dest_ = dest;
       if (local_cert_ && dest_->local_cert_) {
         do_dtls_ = true;
         NegotiateSrtpCiphers();
       }
       state_ = STATE_CONNECTED;
       set_writable(true);
       if (!asymmetric) {
         dest->SetDestination(this, true);
       }
     } else if (state_ == STATE_CONNECTED && !dest) {
       // Simulates loss of connectivity, by asymmetrically forgetting dest_.
       dest_ = nullptr;
-      state_ = STATE_CONNECTING;
+      state_ = STATE_INIT;
       set_writable(false);
     }
   }
 
   void SetConnectionCount(size_t connection_count) {
     size_t old_connection_count = connection_count_;
     connection_count_ = connection_count;
     if (connection_count)
       had_connection_ = true;
     // In this fake transport channel, |connection_count_| determines the
@@ skipping 133 matching lines @@
       for (std::vector<int>::const_iterator it2 = dest_->srtp_ciphers_.begin();
            it2 != dest_->srtp_ciphers_.end(); ++it2) {
         if (*it1 == *it2) {
           chosen_crypto_suite_ = *it1;
           return;
         }
       }
     }
   }
 
-  enum State { STATE_INIT, STATE_CONNECTING, STATE_CONNECTED };
+  enum State { STATE_INIT, STATE_CONNECTED };
   FakeTransportChannel* dest_ = nullptr;
   State state_ = STATE_INIT;
   bool async_ = false;
   Candidates remote_candidates_;
   rtc::scoped_refptr<rtc::RTCCertificate> local_cert_;
   rtc::FakeSSLCertificate* remote_cert_ = nullptr;
   bool do_dtls_ = false;
   std::vector<int> srtp_ciphers_;
   int chosen_crypto_suite_ = rtc::SRTP_INVALID_CRYPTO_SUITE;
   int receiving_timeout_ = -1;
@@ skipping 243 matching lines @@
         rtc::CreateRandomString(cricket::ICE_PWD_LENGTH), cricket::ICEMODE_FULL,
         cricket::CONNECTIONROLE_NONE, nullptr);
     for (auto& kv : transports()) {
       FakeTransport* transport = static_cast<FakeTransport*>(kv.second);
       // Set local transport description for FakeTransport before connecting.
       // Otherwise, the RTC_CHECK in Transport.ConnectChannel will fail.
       if (!transport->local_description()) {
         transport->SetLocalTransportDescription(faketransport_desc,
                                                 cricket::CA_OFFER, nullptr);
       }
-      transport->ConnectChannels();
       transport->MaybeStartGathering();
     }
   }
 
  private:
   bool fail_create_channel_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_FAKETRANSPORTCONTROLLER_H_