Make the state transition for a PortAllocatorSession in each derived class

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() { state_ = SessionState::GATHERING; }
+  virtual void StartGettingPorts() = 0;
   // Completely stops the gathering process and will not start new ones.
-  virtual void StopGettingPorts() { state_ = SessionState::STOPPED; }
+  virtual void StopGettingPorts() = 0;
+  // Whether the session is actively getting ports.
+  virtual bool IsGettingPorts() = 0;
+  // ClearGettingPorts and IsCleared are used by continual gathering.
   // 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; }
+  virtual void ClearGettingPorts() = 0;
   // 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; }
+  virtual bool IsCleared() const { return false; }
   // Whether the session has completely stopped.
-  bool IsStopped() { return state_ == SessionState::STOPPED; }
+  virtual bool IsStopped() const { return false; }
   // 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() {}
 
@@ skipping 53 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_