Revert of Relanding: Implement RTCConfiguration.iceCandidatePoolSize.

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.
  */
 
 #ifndef WEBRTC_P2P_BASE_PORTALLOCATOR_H_
 #define WEBRTC_P2P_BASE_PORTALLOCATOR_H_
 
-#include <deque>
-#include <memory>
 #include <string>
 #include <vector>
 
 #include "webrtc/p2p/base/port.h"
 #include "webrtc/p2p/base/portinterface.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/proxyinfo.h"
 #include "webrtc/base/sigslot.h"
-#include "webrtc/base/thread.h"
 
 namespace cricket {
 
 // PortAllocator is responsible for allocating Port types for a given
 // P2PSocket. It also handles port freeing.
 //
 // Clients can override this class to control port allocation, including
 // what kinds of ports are allocated.
 
 enum {
@@ skipping 43 matching lines @@
   CF_RELAY = 0x4,
   CF_ALL = 0x7,
 };
 
 // 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); }
-
   std::string username;
   std::string password;
 };
 
 typedef std::vector<ProtocolAddress> PortList;
 // TODO(deadbeef): Rename to TurnServerConfig.
 struct RelayServerConfig {
-  RelayServerConfig(RelayType type) : type(type) {}
+  RelayServerConfig(RelayType type) : type(type), priority(0) {}
 
   RelayServerConfig(const std::string& address,
                     int port,
                     const std::string& username,
                     const std::string& password,
                     ProtocolType proto,
                     bool secure)
       : type(RELAY_TURN), credentials(username, password) {
     ports.push_back(
         ProtocolAddress(rtc::SocketAddress(address, port), proto, secure));
   }
 
-  bool operator==(const RelayServerConfig& o) const {
-    return type == o.type && ports == o.ports && credentials == o.credentials &&
-           priority == o.priority;
-  }
-  bool operator!=(const RelayServerConfig& o) const { return !(*this == o); }
-
   RelayType type;
   PortList ports;
   RelayCredentials credentials;
-  int priority = 0;
+  int priority;
 };
 
 class PortAllocatorSession : public sigslot::has_slots<> {
  public:
   // Content name passed in mostly for logging and debugging.
   PortAllocatorSession(const std::string& content_name,
                        int component,
                        const std::string& ice_ufrag,
                        const std::string& ice_pwd,
                        uint32_t flags);
 
   // Subclasses should clean up any ports created.
   virtual ~PortAllocatorSession() {}
 
   uint32_t flags() const { return flags_; }
   void set_flags(uint32_t flags) { flags_ = flags; }
   std::string content_name() const { return content_name_; }
   int component() const { return component_; }
-  const std::string& ice_ufrag() const { return ice_ufrag_; }
-  const std::string& ice_pwd() const { return ice_pwd_; }
-  bool pooled() const { return ice_ufrag_.empty(); }
 
   // 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;
 
-  // 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;
   sigslot::signal2<PortAllocatorSession*,
                    const std::vector<Candidate>&> SignalCandidatesReady;
   sigslot::signal1<PortAllocatorSession*> SignalCandidatesAllocationDone;
 
   virtual uint32_t generation() { return generation_; }
   virtual void set_generation(uint32_t generation) { generation_ = generation; }
   sigslot::signal1<PortAllocatorSession*> SignalDestroyed;
 
+  const std::string& ice_ufrag() const { return ice_ufrag_; }
+  const std::string& ice_pwd() const { return ice_pwd_; }
+
  protected:
-  // This method is called when a pooled session (which doesn't have these
-  // properties initially) is returned by PortAllocator::TakePooledSession,
-  // and the content name, component, and ICE ufrag/pwd are updated.
-  //
-  // A subclass may need to override this method to perform additional actions,
-  // such as applying the updated information to ports and candidates.
-  virtual void UpdateIceParametersInternal() {}
-
   // TODO(deadbeef): Get rid of these when everyone switches to ice_ufrag and
   // ice_pwd.
   const std::string& username() const { return ice_ufrag_; }
   const std::string& password() const { return ice_pwd_; }
 
+  std::string content_name_;
+  int component_;
+
  private:
-  void SetIceParameters(const std::string& content_name,
-                        int component,
-                        const std::string& ice_ufrag,
-                        const std::string& ice_pwd) {
-    content_name_ = content_name;
-    component_ = component;
-    ice_ufrag_ = ice_ufrag;
-    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_;
-
-  // SetIceParameters is an implementation detail which only PortAllocator
-  // should be able to call.
-  friend class PortAllocator;
 };
 
-// Note that this class should only be used on one thread.
-// This includes calling the destructor.
 class PortAllocator : public sigslot::has_slots<> {
  public:
   PortAllocator() :
       flags_(kDefaultPortAllocatorFlags),
       min_port_(0),
       max_port_(0),
       step_delay_(kDefaultStepDelay),
       allow_tcp_listen_(true),
       candidate_filter_(CF_ALL) {
     // This will allow us to have old behavior on non webrtc clients.
   }
   virtual ~PortAllocator() {}
 
-  // Set STUN and TURN servers to be used in future sessions, and set
-  // candidate pool size, as described in JSEP.
-  //
-  // If the servers are changing and the candidate pool size is nonzero,
-  // existing pooled sessions will be destroyed and new ones created.
-  //
-  // If the servers are not changing but the candidate pool size is,
-  // pooled sessions will be either created or destroyed as necessary.
-  void SetConfiguration(const ServerAddresses& stun_servers,
-                        const std::vector<RelayServerConfig>& turn_servers,
-                        int candidate_pool_size);
-
-  const ServerAddresses& stun_servers() const { return stun_servers_; }
-
-  const std::vector<RelayServerConfig>& turn_servers() const {
-    return turn_servers_;
-  }
-
-  int candidate_pool_size() const { return target_pooled_session_count_; }
+  // Set STUN and TURN servers to be used in future sessions.
+  virtual void SetIceServers(
+      const ServerAddresses& stun_servers,
+      const std::vector<RelayServerConfig>& turn_servers) = 0;
 
   // Sets the network types to ignore.
   // Values are defined by the AdapterType enum.
   // For instance, calling this with
   // ADAPTER_TYPE_ETHERNET | ADAPTER_TYPE_LOOPBACK will ignore Ethernet and
   // loopback interfaces.
   virtual void SetNetworkIgnoreMask(int network_ignore_mask) = 0;
 
-  std::unique_ptr<PortAllocatorSession> CreateSession(
+  PortAllocatorSession* CreateSession(
       const std::string& sid,
       const std::string& content_name,
       int component,
       const std::string& ice_ufrag,
       const std::string& ice_pwd);
 
-  // Get an available pooled session and set the transport information on it.
-  //
-  // Caller takes ownership of the returned session.
-  //
-  // If no pooled sessions are available, returns null.
-  std::unique_ptr<PortAllocatorSession> TakePooledSession(
-      const std::string& content_name,
-      int component,
-      const std::string& ice_ufrag,
-      const std::string& ice_pwd);
-
-  // Returns the next session that would be returned by TakePooledSession.
-  const PortAllocatorSession* GetPooledSession() const;
-
   uint32_t flags() const { return flags_; }
   void set_flags(uint32_t flags) { flags_ = flags; }
 
   const std::string& user_agent() const { return agent_; }
   const rtc::ProxyInfo& proxy() const { return proxy_; }
   void set_proxy(const std::string& agent, const rtc::ProxyInfo& proxy) {
     agent_ = agent;
     proxy_ = proxy;
   }
 
@@ skipping 12 matching lines @@
 
   uint32_t step_delay() const { return step_delay_; }
   void set_step_delay(uint32_t delay) { step_delay_ = delay; }
 
   bool allow_tcp_listen() const { return allow_tcp_listen_; }
   void set_allow_tcp_listen(bool allow_tcp_listen) {
     allow_tcp_listen_ = allow_tcp_listen;
   }
 
   uint32_t candidate_filter() { return candidate_filter_; }
-  void set_candidate_filter(uint32_t filter) {
+  bool set_candidate_filter(uint32_t filter) {
     // TODO(mallinath) - Do transition check?
     candidate_filter_ = filter;
+    return true;
   }
 
   // Gets/Sets the Origin value used for WebRTC STUN requests.
   const std::string& origin() const { return origin_; }
   void set_origin(const std::string& origin) { origin_ = origin; }
 
  protected:
   virtual PortAllocatorSession* CreateSessionInternal(
       const std::string& content_name,
       int component,
       const std::string& ice_ufrag,
       const std::string& ice_pwd) = 0;
 
   uint32_t flags_;
   std::string agent_;
   rtc::ProxyInfo proxy_;
   int min_port_;
   int max_port_;
   uint32_t step_delay_;
   bool allow_tcp_listen_;
   uint32_t candidate_filter_;
   std::string origin_;
-
- private:
-  ServerAddresses stun_servers_;
-  std::vector<RelayServerConfig> turn_servers_;
-  // The last size passed into SetConfiguration.
-  int target_pooled_session_count_ = 0;
-  // 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_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_PORTALLOCATOR_H_