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 58 matching lines @@
 
     // kInit --> kRunning --> {kCompleted|kStopped}
   };
   AllocationSequence(BasicPortAllocatorSession* session,
                      rtc::Network* network,
                      PortConfiguration* config,
                      uint32 flags);
   ~AllocationSequence();
   bool Init();
   void Clear();
+  void OnNetworkRemoved();
 
   State state() const { return state_; }
+  const rtc::Network* network() const { return network_; }
+  bool network_removed() const { return network_removed_; }
 
   // 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 29 matching lines @@
 
   void OnReadPacket(rtc::AsyncPacketSocket* socket,
                     const char* data,
                     size_t size,
                     const rtc::SocketAddress& remote_addr,
                     const rtc::PacketTime& packet_time);
 
   void OnPortDestroyed(PortInterface* port);
 
   BasicPortAllocatorSession* session_;
+  bool network_removed_ = false;
   rtc::Network* network_;
   rtc::IPAddress ip_;
   PortConfiguration* config_;
   State state_;
   uint32 flags_;
   ProtocolList protocols_;
   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_