Use continual gathering to restore backup connections

webrtc/p2p/base/portallocator.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 70 matching lines @@
 
 // CF = CANDIDATE FILTER
 enum {
   CF_NONE = 0x0,
   CF_HOST = 0x1,
   CF_REFLEXIVE = 0x2,
   CF_RELAY = 0x4,
   CF_ALL = 0x7,
 };
 
+enum class SessionState {
+  GATHERING,  // Actively allocating ports and gathering candidates.
+  CLEARED,    // Current allocation process has been stopped but may start
+              // new ones.
+  STOPPED     // This session has completely stopped, no new allocation
+              // process will be started.
+};
+
 // TODO(deadbeef): Rename to TurnCredentials (and username to ufrag).
 struct RelayCredentials {
   RelayCredentials() {}
   RelayCredentials(const std::string& username, const std::string& password)
       : username(username), password(password) {}
 
   bool operator==(const RelayCredentials& o) const {
     return username == o.username && password == o.password;
   }
   bool operator!=(const RelayCredentials& o) const { return !(*this == o); }
@@ skipping 51 matching lines @@
   bool pooled() const { return ice_ufrag_.empty(); }
 
   // Setting this filter should affect not only candidates gathered in the
   // future, but candidates already gathered and ports already "ready",
   // which would be returned by ReadyCandidates() and ReadyPorts().
   //
   // Default filter should be CF_ALL.
   virtual void SetCandidateFilter(uint32_t filter) = 0;
 
   // Starts gathering STUN and Relay configurations.
-  virtual void StartGettingPorts() = 0;
-  virtual void StopGettingPorts() = 0;
-  // Only stop the existing gathering process but may start new ones if needed.
-  virtual void ClearGettingPorts() = 0;
-  // Whether the process of getting ports has been stopped.
-  virtual bool IsGettingPorts() = 0;
+  virtual void StartGettingPorts() { state_ = SessionState::GATHERING; }
+  // Completely stops the gathering process and will not start new ones.
+  virtual void StopGettingPorts() { state_ = SessionState::STOPPED; }
+  // Only stops the existing gathering process but may start new ones if needed.
+  virtual void ClearGettingPorts() { state_ = SessionState::CLEARED; }
+  // Whether the session is actively getting ports.
+  bool IsGettingPorts() { return state_ == SessionState::GATHERING; }
+  // Whether it is in the state where the existing gathering process is stopped,
+  // but new ones may be started (basically after calling ClearGettingPorts).
+  bool IsCleared() { return state_ == SessionState::CLEARED; }
+  // Whether the session has completely stopped.
+  bool IsStopped() { return state_ == SessionState::STOPPED; }
+  // Re-gathers candidates on networks that do not have any connections. More
+  // precisely, a network interface may have more than one IP addresses (e.g.,
+  // IPv4 and IPv6 addresses). Each address subnet will be used to create a
+  // network. Only if all networks of an interface have no connection, the
+  // implementation should start re-gathering on all networks of that interface.
+  virtual void RegatherOnFailedNetworks() {}
+  // Re-gathers candidates on all networks.
+  // TODO(honghaiz): Implement this in BasicPortAllocator.
+  virtual void RegatherOnAllNetworks() {}
 
   // Another way of getting the information provided by the signals below.
   //
   // Ports and candidates are not guaranteed to be in the same order as the
   // signals were emitted in.
   virtual std::vector<PortInterface*> ReadyPorts() const = 0;
   virtual std::vector<Candidate> ReadyCandidates() const = 0;
   virtual bool CandidatesAllocationDone() const = 0;
 
   sigslot::signal2<PortAllocatorSession*, PortInterface*> SignalPortReady;
+  // Ports should be signaled to be removed when the networks of the ports
+  // failed (either because the interface is down, or because there is no
+  // connection on the interface).
+  sigslot::signal2<PortAllocatorSession*, const std::vector<PortInterface*>&>
+      SignalPortsRemoved;
   sigslot::signal2<PortAllocatorSession*,
                    const std::vector<Candidate>&> SignalCandidatesReady;
+  // Candidates should be signaled to be removed when the port that generated
+  // the candidates is removed.
+  sigslot::signal2<PortAllocatorSession*, const std::vector<Candidate>&>
+      SignalCandidatesRemoved;
   sigslot::signal1<PortAllocatorSession*> SignalCandidatesAllocationDone;
   // A TURN port is pruned if a higher-priority TURN port becomes ready
   // (pairable). When it is pruned, it will not be used for creating
   // connections and its candidates will not be sent to the remote side
   // if they have not been sent.
   sigslot::signal2<PortAllocatorSession*, PortInterface*> SignalPortPruned;
 
   virtual uint32_t generation() { return generation_; }
   virtual void set_generation(uint32_t generation) { generation_ = generation; }
   sigslot::signal1<PortAllocatorSession*> SignalDestroyed;
@@ skipping 23 matching lines @@
     ice_pwd_ = ice_pwd;
     UpdateIceParametersInternal();
   }
 
   uint32_t flags_;
   uint32_t generation_;
   std::string content_name_;
   int component_;
   std::string ice_ufrag_;
   std::string ice_pwd_;
+  SessionState state_ = SessionState::CLEARED;
 
   // SetIceParameters is an implementation detail which only PortAllocator
   // should be able to call.
   friend class PortAllocator;
 };
 
 // Every method of PortAllocator (including the destructor) must be called on
 // the same thread, except for the constructor which may be called on any
 // thread.
 //
@@ skipping 131 matching lines @@
   // This variable represents the total number of pooled sessions
   // both owned by this class and taken by TakePooledSession.
   int allocated_pooled_session_count_ = 0;
   std::deque<std::unique_ptr<PortAllocatorSession>> pooled_sessions_;
   bool prune_turn_ports_ = false;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_PORTALLOCATOR_H_