Add config to prune TURN ports

webrtc/p2p/client/basicportallocator.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 105 matching lines @@
    public:
     PortData() {}
     PortData(Port* port, AllocationSequence* seq)
         : port_(port), sequence_(seq) {}
 
     Port* port() const { return port_; }
     AllocationSequence* sequence() const { return sequence_; }
     bool has_pairable_candidate() const { return has_pairable_candidate_; }
     bool complete() const { return state_ == STATE_COMPLETE; }
     bool error() const { return state_ == STATE_ERROR; }
+    bool pruned() const { return state_ == STATE_PRUNED; }
+    bool inprogress() const { return state_ == STATE_INPROGRESS; }
+    // Returns true if this port is ready to be used.
+    bool ready() const {
+      return has_pairable_candidate_ && state_ != STATE_ERROR &&
+             state_ != STATE_PRUNED;
+    }
 
+    void set_pruned() { state_ = STATE_PRUNED; }
     void set_has_pairable_candidate(bool has_pairable_candidate) {
       if (has_pairable_candidate) {
         ASSERT(state_ == STATE_INPROGRESS);
       }
       has_pairable_candidate_ = has_pairable_candidate;
     }
     void set_complete() {
       state_ = STATE_COMPLETE;
     }
     void set_error() {
       ASSERT(state_ == STATE_INPROGRESS);
       state_ = STATE_ERROR;
     }
 
    private:
     enum State {
       STATE_INPROGRESS,  // Still gathering candidates.
       STATE_COMPLETE,    // All candidates allocated and ready for process.
-      STATE_ERROR        // Error in gathering candidates.
+      STATE_ERROR,       // Error in gathering candidates.
+      STATE_PRUNED       // Pruned by higher priority ports on the same network
+                         // interface. Only TURN ports may be pruned.
     };
     Port* port_ = nullptr;
     AllocationSequence* sequence_ = nullptr;
     State state_ = STATE_INPROGRESS;
     bool has_pairable_candidate_ = false;
   };
 
   void OnConfigReady(PortConfiguration* config);
   void OnConfigStop();
   void AllocatePorts();
@@ skipping 15 matching lines @@
   void OnPortAllocationComplete(AllocationSequence* seq);
   PortData* FindPort(Port* port);
   void GetNetworks(std::vector<rtc::Network*>* networks);
 
   bool CheckCandidateFilter(const Candidate& c) const;
   bool CandidatePairable(const Candidate& c, const Port* port) const;
   // Clear the related address according to the flags and candidate filter
   // in order to avoid leaking any information.
   Candidate SanitizeRelatedAddress(const Candidate& c) const;
 
+  Port* GetBestTurnPortForNetwork(const std::string& network_name) const;
+  // Returns true if at least one TURN port is pruned.
+  bool PruneTurnPorts(Port* newly_pairable_turn_port);
+
   BasicPortAllocator* allocator_;
   rtc::Thread* network_thread_;
   std::unique_ptr<rtc::PacketSocketFactory> owned_socket_factory_;
   rtc::PacketSocketFactory* socket_factory_;
   bool allocation_started_;
   bool network_manager_started_;
   bool running_;  // set when StartGetAllPorts is called
   bool allocation_sequences_created_;
   std::vector<PortConfiguration*> configs_;
   std::vector<AllocationSequence*> sequences_;
   std::vector<PortData> ports_;
   uint32_t candidate_filter_ = CF_ALL;
+  // Whether to prune low-priority ports, taken from the port allocator.
+  bool prune_turn_ports_;
 
   friend class AllocationSequence;
 };
 
 // Records configuration information useful in creating ports.
 // TODO(deadbeef): Rename "relay" to "turn_server" in this struct.
 struct PortConfiguration : public rtc::MessageData {
   // TODO(jiayl): remove |stun_address| when Chrome is updated.
   rtc::SocketAddress stun_address;
   ServerAddresses stun_servers;
@@ skipping 116 matching lines @@
   std::unique_ptr<rtc::AsyncPacketSocket> udp_socket_;
   // There will be only one udp port per AllocationSequence.
   UDPPort* udp_port_;
   std::vector<TurnPort*> turn_ports_;
   int phase_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_CLIENT_BASICPORTALLOCATOR_H_