Use continual gathering to restore backup connections

webrtc/p2p/client/basicportallocator.cc

 /*
  *  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 197 matching lines @@
   network_thread_->Post(this, MSG_CONFIG_STOP);
   ClearGettingPorts();
 }
 
 void BasicPortAllocatorSession::ClearGettingPorts() {
   network_thread_->Clear(this, MSG_ALLOCATE);
   for (uint32_t i = 0; i < sequences_.size(); ++i)
     sequences_[i]->Stop();
 }
 
+void BasicPortAllocatorSession::InactivateNetworksInExistingSequences(

[Taylor Brandstetter, 2016/06/06 18:18:37]

On second thought... If this method is always intended to be used along with
"StartGettingPorts" in order to re-gather ports for specific networks, it would
be better to just call the method "RegatherPortsForNetworks()". That creates a
looser dependency on the implementation of the PortAllocator; developers may
implement their own PortAllocator, where it's not clear what they're supposed to
do when "InactivateNetworks" is called.

Also, document in the header file what a nullptr parameter means.

[honghaiz3, 2016/06/07 16:42:06]

Done, except the name. 
We are not re-gathering "port". What it does is to create ports and re-gathering
candidates. I use the name GetPortsOnNetworks (similar to StartGettingPorts). 

+    std::vector<rtc::Network*>* networks) {
+  for (AllocationSequence* sequence : sequences_) {
+    if (!sequence->network_inactive() &&
+        (!networks ||
+         std::find(networks->begin(), networks->end(), sequence->network()) !=
+             networks->end())) {
+      sequence->OnNetworkInactivated();
+    }
+  }
+}
+
 std::vector<PortInterface*> BasicPortAllocatorSession::ReadyPorts() const {
   std::vector<PortInterface*> ret;
   for (const PortData& port : ports_) {
     if (port.has_pairable_candidate() && !port.error()) {
       ret.push_back(port.port());
     }
   }
   return ret;
 }
 
@@ skipping 266 matching lines @@
     network_thread_->Post(this, MSG_SEQUENCEOBJECTS_CREATED);
   }
 }
 
 void BasicPortAllocatorSession::OnNetworksChanged() {
   std::vector<rtc::Network*> networks;
   GetNetworks(&networks);
   for (AllocationSequence* sequence : sequences_) {
     // Remove the network from the allocation sequence if it is not in
     // |networks|.
-    if (!sequence->network_removed() &&
+    if (!sequence->network_inactive() &&
         std::find(networks.begin(), networks.end(), sequence->network()) ==
             networks.end()) {
-      sequence->OnNetworkRemoved();
+      sequence->OnNetworkInactivated();
     }
   }
 
   network_manager_started_ = true;
   if (allocation_started_)
     DoAllocate();
 }
 
 void BasicPortAllocatorSession::DisableEquivalentPhases(
     rtc::Network* network,
@@ skipping 268 matching lines @@
     // are next available options to setup a communication channel.
   }
   return true;
 }
 
 void AllocationSequence::Clear() {
   udp_port_ = NULL;
   turn_ports_.clear();
 }
 
-void AllocationSequence::OnNetworkRemoved() {
+void AllocationSequence::OnNetworkInactivated() {
   // Stop the allocation sequence if its network is gone.
+  network_inactive_ = true;
   Stop();
-  network_removed_ = true;
 }
 
 AllocationSequence::~AllocationSequence() {
   session_->network_thread()->Clear(this);
 }
 
 void AllocationSequence::DisableEquivalentPhases(rtc::Network* network,
     PortConfiguration* config, uint32_t* flags) {
-  if (network_removed_) {
-    // If the network of this allocation sequence has ever gone away,
+  if (network_inactive_) {
+    // If the network of this allocation sequence has ever become inactive,
     // it won't be equivalent to the new network.
     return;
   }
 
   if (!((network == network_) && (ip_ == network->GetBestIP()))) {
     // Different network setup; nothing is equivalent.
     return;
   }
 
   // Else turn off the stuff that we've already got covered.
@@ skipping 415 matching lines @@
   ServerAddresses servers;
   for (size_t i = 0; i < relays.size(); ++i) {
     if (relays[i].type == turn_type && SupportsProtocol(relays[i], type)) {
       servers.insert(relays[i].ports.front().address);
     }
   }
   return servers;
 }
 
 }  // namespace cricket