Use continual gathering to restore backup connections

webrtc/p2p/base/p2ptransportchannel.h

 /*
  *  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 22 matching lines @@
 #include "webrtc/p2p/base/portallocator.h"
 #include "webrtc/p2p/base/portinterface.h"
 #include "webrtc/p2p/base/transportchannelimpl.h"
 #include "webrtc/base/asyncpacketsocket.h"
 #include "webrtc/base/sigslot.h"
 
 namespace cricket {
 
 extern const int WEAK_PING_INTERVAL;
 static const int MIN_PINGS_AT_WEAK_PING_INTERVAL = 3;
+// When the selected connection is suddenly deleted and no other connection
+// is available, we will try to recover the ICE connectivity via continual
+// gathering on the local client. If no writable connection is established
+// after this amount of time, will declare the transport channel to be
+// unwritable.
+static const int MAX_RECOVERING_TIME = 5000;  // 5 seconds.

[pthatcher1, 2016/06/07 18:54:33]

I think this needs a more clear name.  This isn't a time limit on recovering,
it's a time limit on how long we hide the fact that we're not connected from the
application.  So perhaps something like
CONTINUAL_GATHERING_DISCONNECTED_STATE_DELAY.

 
 struct IceParameters {
   std::string ufrag;
   std::string pwd;
   IceParameters(const std::string& ice_ufrag, const std::string& ice_pwd)
       : ufrag(ice_ufrag), pwd(ice_pwd) {}
 
   bool operator==(const IceParameters& other) {
     return ufrag == other.ufrag && pwd == other.pwd;
   }
@@ skipping 137 matching lines @@
 
   // Public for unit tests.
   PortAllocatorSession* allocator_session() {
     return allocator_sessions_.back().get();
   }
 
   // Public for unit tests.
   const std::vector<RemoteCandidate>& remote_candidates() const {
     return remote_candidates_;
   }
+  // For testing.
+  // TODO(honghaiz): Remove this method and use the fake clock for the test.
+  void set_check_restore_backup_connection_interval(int interval);

[pthatcher1, 2016/06/07 18:54:34]

Can we just use the fake clock now?  This looks kind of ugly.

 
  private:
   rtc::Thread* thread() { return worker_thread_; }
   bool IsGettingPorts() { return allocator_session()->IsGettingPorts(); }
+  // Start regathering on the given list of networks. If |networks| is nullptr,
+  // start regathering on all active networks.
+  void StartRegathering(std::vector<rtc::Network*>* networks);

[pthatcher1, 2016/06/07 18:54:34]

It think it would be more clear to have two methods:

RegatherAllNetworks()
RegatherNetworks(const std::vector<rtc::Network*>& networks)

 
   // A transport channel is weak if the current best connection is either
   // not receiving or not writable, or if there is no best connection at all.
   bool weak() const;
   void UpdateConnectionStates();
   void RequestSort();
   void SortConnections();
   void SwitchBestConnectionTo(Connection* conn);
   void UpdateState();
   void HandleAllTimedOut();
@@ skipping 36 matching lines @@
                     const rtc::PacketTime& packet_time);
   void OnSentPacket(const rtc::SentPacket& sent_packet);
   void OnReadyToSend(Connection* connection);
   void OnConnectionDestroyed(Connection *connection);
 
   void OnNominated(Connection* conn);
 
   void OnMessage(rtc::Message* pmsg) override;
   void OnSort();
   void OnCheckAndPing();
+  void OnCheckAndRestoreBackupConnection();
 
   void PruneConnections();
   Connection* best_nominated_connection() const;
   bool IsBackupConnection(Connection* conn) const;
 
   Connection* FindConnectionToPing(int64_t now);
   Connection* FindOldestConnectionNeedingTriggeredCheck(int64_t now);
   // Between |conn1| and |conn2|, this function returns the one which should
   // be pinged first.
   Connection* SelectMostPingableConnection(Connection* conn1,
@@ skipping 15 matching lines @@
   const IceParameters* FindRemoteIceFromUfrag(const std::string& ufrag,
                                               uint32_t* generation);
   // Returns the index of the latest remote ICE parameters, or 0 if no remote
   // ICE parameters have been received.
   uint32_t remote_ice_generation() {
     return remote_ice_parameters_.empty()
                ? 0
                : static_cast<uint32_t>(remote_ice_parameters_.size() - 1);
   }
 
+  bool IsRecoveringConnectivity() const {
+    return recovering_start_time_ > 0 &&
+           rtc::TimeMillis() - recovering_start_time_ <= MAX_RECOVERING_TIME;
+  }

[pthatcher1, 2016/06/07 18:54:34]

***

+
   PortAllocator* allocator_;
   rtc::Thread* worker_thread_;
   bool incoming_only_;
   int error_;
   std::vector<std::unique_ptr<PortAllocatorSession>> allocator_sessions_;
   std::vector<PortInterface *> ports_;
 
   // |connections_| is a sorted list with the first one always be the
   // |best_connection_| when it's not nullptr. The combination of
   // |pinged_connections_| and |unpinged_connections_| has the same
@@ skipping 15 matching lines @@
   OptionMap options_;
   std::string ice_ufrag_;
   std::string ice_pwd_;
   std::vector<IceParameters> remote_ice_parameters_;
   IceMode remote_ice_mode_;
   IceRole ice_role_;
   uint64_t tiebreaker_;
   IceGatheringState gathering_state_;
 
   int check_receiving_interval_;
+  int check_restore_backup_connection_interval_;
   int64_t last_ping_sent_ms_ = 0;
   int weak_ping_interval_ = WEAK_PING_INTERVAL;
   TransportChannelState state_ = TransportChannelState::STATE_INIT;
   IceConfig config_;
   int last_sent_packet_id_ = -1;  // -1 indicates no packet was sent before.
+  int64_t recovering_start_time_ = 0;
+  std::vector<Candidate> candidates_removed_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(P2PTransportChannel);
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_P2PTRANSPORTCHANNEL_H_