Add config to prune TURN ports

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 160 matching lines @@
   // 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;
+  // A TURN port is pruned if there is a higher-priority TURN port becomes

[pthatcher1, 2016/06/28 21:01:41]

if there is a => if a 

[honghaiz3, 2016/06/28 23:35:59]

Done.

+  // 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;
 
  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.
   //
@@ skipping 55 matching lines @@
   // 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);
+                        int candidate_pool_size,
+                        bool prune_turn_ports);
 
   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_; }
 
   // Sets the network types to ignore.
@@ skipping 53 matching lines @@
   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) {
     candidate_filter_ = filter;
   }
 
+  bool prune_turn_ports() const { return prune_turn_ports_; }
+
   // 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;
@@ skipping 10 matching lines @@
 
  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_;
+  bool prune_turn_ports_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_PORTALLOCATOR_H_