When doing DisableEquivalentPhases, exclude those AllocationSequences

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 164 matching lines @@
                         bool prepare_address);
   void OnCandidateReady(Port* port, const Candidate& c);
   void OnPortComplete(Port* port);
   void OnPortError(Port* port);
   void OnProtocolEnabled(AllocationSequence* seq, ProtocolType proto);
   void OnPortDestroyed(PortInterface* port);
   void OnShake();
   void MaybeSignalCandidatesAllocationDone();
   void OnPortAllocationComplete(AllocationSequence* seq);
   PortData* FindPort(Port* port);
+  void GetNetworks(std::vector<rtc::Network*>* networks);
 
   bool CheckCandidateFilter(const Candidate& c);
 
   BasicPortAllocator* allocator_;
   rtc::Thread* network_thread_;
   rtc::scoped_ptr<rtc::PacketSocketFactory> owned_socket_factory_;
   rtc::PacketSocketFactory* socket_factory_;
   bool allocation_started_;
   bool network_manager_started_;
   bool running_;  // set when StartGetAllPorts is called
@@ skipping 48 matching lines @@
 // Performs the allocation of ports, in a sequenced (timed) manner, for a given
 // network and IP address.
 class AllocationSequence : public rtc::MessageHandler,
                            public sigslot::has_slots<> {
  public:
   enum State {
     kInit,       // Initial state.
     kRunning,    // Started allocating ports.
     kStopped,    // Stopped from running.
     kCompleted,  // All ports are allocated.
+    kTerminated,  // An AllocationSequence is terminated when the network
+                  // it depends on is removed (disconnected).

[pthatcher1, 2015/09/24 17:11:43]

How is that different than kStopped?

[honghaiz3, 2015/09/24 19:27:00]

Removed the state.

 
     // kInit --> kRunning --> {kCompleted|kStopped}
+    //    |         |                    |
+    //    --------------------------------> kTerminated
   };
   AllocationSequence(BasicPortAllocatorSession* session,
                      rtc::Network* network,
                      PortConfiguration* config,
                      uint32 flags);
   ~AllocationSequence();
   bool Init();
   void Clear();
+  void Terminate();
+  bool IsTerminated() { return state_ == kTerminated; }

[pthatcher1, 2015/09/24 17:11:43]

Is this needed when you can just do state() == kTerminated?

[honghaiz3, 2015/09/24 19:27:00]

Removed the new state. 

 
   State state() const { return state_; }
+  const rtc::Network* network() const { return network_; }
 
   // Disables the phases for a new sequence that this one already covers for an
   // equivalent network setup.
   void DisableEquivalentPhases(rtc::Network* network,
                                PortConfiguration* config,
                                uint32* flags);
 
   // Starts and stops the sequence.  When started, it will continue allocating
   // new ports on its own timed schedule.
   void Start();
@@ skipping 45 matching lines @@
   rtc::scoped_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_