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; }
+    // A terminated state is one of COMPLETE, ERROR or PRUNED state.
+    bool terminated() const { return state_ != STATE_INPROGRESS; }

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

Why not have bool gathering() cosnt { return state_ == STATE_INPROGRESS; } and
use !gathering() at all the call sites?

[honghaiz3, 2016/06/28 23:36:00]

Done. I used the name inprogress to match the variable name. 

 
+    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();
   void OnAllocate();
   void DoAllocate();
   void OnNetworksChanged();
   void OnAllocationSequenceObjectsCreated();
   void DisableEquivalentPhases(rtc::Network* network,
                                PortConfiguration* config,
                                uint32_t* flags);
   void AddAllocatedPort(Port* port, AllocationSequence* seq,
                         bool prepare_address);
   void OnCandidateReady(Port* port, const Candidate& c);
+  void OnPortPairable(PortData* port_data);
+  bool IsPortInUse(const PortData& data) const;
   void OnPortComplete(Port* port);
   void OnPortError(Port* port);
   void OnProtocolEnabled(AllocationSequence* seq, ProtocolType proto);
   void OnPortDestroyed(PortInterface* port);
   void MaybeSignalCandidatesAllocationDone();
   void OnPortAllocationComplete(AllocationSequence* seq);
   PortData* FindPort(Port* port);
   void GetNetworks(std::vector<rtc::Network*>* networks);
 
   bool CheckCandidateFilter(const Candidate& c) const;
@@ skipping 143 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_