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::GetPortsOnNetworks(
+    const std::vector<rtc::Network*>* networks) {
+  // Mark the networks on existing allocation sequences as inactive so that
+  // ports will always be allocated on the given networks.
+  for (AllocationSequence* sequence : sequences_) {
+    if (!sequence->network_inactive() &&
+        (!networks ||
+         std::find(networks->begin(), networks->end(), sequence->network()) !=
+             networks->end())) {
+      sequence->OnNetworkInactivated();

[pthatcher1, 2016/06/07 18:54:34]

It feels like we are confounding two separate things:

1. The network went away.
2. We want to stop the current sequence and restart it as if the network went
away and came back.

I think instead of calling OnNetworkInactivitated, we should have a method
that's something like Restart().  And the implementation of that could be to do
the same thing as OnNetworkRemoved, but method we call here should be Restart(),
I think.

+    }
+  }
+
+  StartGettingPorts();

[pthatcher1, 2016/06/07 18:54:34]

And the Restart() above would mean we don't need to call StartGettingPorts here,
I think.

+}
+
 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;
 }
 
 std::vector<Candidate> BasicPortAllocatorSession::ReadyCandidates() const {
   std::vector<Candidate> candidates;
   for (const PortData& data : ports_) {
     for (const Candidate& candidate : data.port()->Candidates()) {
       if (!CheckCandidateFilter(candidate)) {
         continue;
       }
       ProtocolType pvalue;
       if (!StringToProto(candidate.protocol().c_str(), &pvalue) ||
           !data.sequence()->ProtocolEnabled(pvalue)) {
         continue;
       }
       candidates.push_back(SanitizeRelatedAddress(candidate));
     }
   }
   return candidates;
 }
 
+std::vector<Candidate> BasicPortAllocatorSession::ReadyCandidates(

[pthatcher1, 2016/06/07 18:54:34]

Is it really so bad if the caller calls ReadyCandidates(), gets them all, and
just filters for one port?  It seems like it would be more simple and would be a
very minor perf difference.

+    PortInterface* port) const {
+  std::vector<Candidate> candidates;
+  for (const Candidate& candidate : port->Candidates()) {
+    if (!CheckCandidateFilter(candidate)) {
+      continue;
+    }
+    candidates.push_back(SanitizeRelatedAddress(candidate));
+  }
+  return candidates;
+}
+
 Candidate BasicPortAllocatorSession::SanitizeRelatedAddress(
     const Candidate& c) const {
   Candidate copy = c;
   // If adapter enumeration is disabled or host candidates are disabled,
   // clear the raddr of STUN candidates to avoid local address leakage.
   bool filter_stun_related_address =
       ((flags() & PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION) &&
        (flags() & PORTALLOCATOR_DISABLE_DEFAULT_LOCAL_CANDIDATE)) ||
       !(candidate_filter_ & CF_HOST);
   // If the candidate filter doesn't allow reflexive addresses, empty TURN raddr
@@ skipping 238 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() &&

[pthatcher1, 2016/06/07 18:54:34]

I liked calling this removed before and I'd like to see if we can leave it so,
and find a different way to restart a sequence without confounding these two
things.

         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