Signal to remove remote candidates if ports are pruned.

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 296 matching lines @@
   // regathers ports and candidates.
   for (AllocationSequence* sequence : sequences_) {
     if (!sequence->network_failed() &&
         std::find(failed_networks.begin(), failed_networks.end(),
                   sequence->network()) != failed_networks.end()) {
       sequence->set_network_failed();
     }
   }
   // Remove ports from being used locally and send signaling to remove
   // the candidates on the remote side.
-  RemovePortsAndCandidates(failed_networks);
+  std::vector<PortData*> ports_to_prune = GetUnprunedPorts(failed_networks);
+  if (!ports_to_prune.empty()) {
+    LOG(LS_INFO) << "Prune " << ports_to_prune.size()
+                 << " ports because their networks failed";
+    PrunePortsAndRemoveCandidates(ports_to_prune);
+  }
 
   if (allocation_started_ && network_manager_started_) {
     DoAllocate();
   }
 }
 
 std::vector<PortInterface*> BasicPortAllocatorSession::ReadyPorts() const {
   std::vector<PortInterface*> ret;
   for (const PortData& data : ports_) {
     if (data.ready()) {
@@ skipping 280 matching lines @@
   for (AllocationSequence* sequence : sequences_) {
     // Mark the sequence as "network failed" if its network is not in
     // |networks|.
     if (!sequence->network_failed() &&
         std::find(networks.begin(), networks.end(), sequence->network()) ==
             networks.end()) {
       sequence->OnNetworkFailed();
       failed_networks.push_back(sequence->network());
     }
   }
-  RemovePortsAndCandidates(failed_networks);
+  std::vector<PortData*> ports_to_prune = GetUnprunedPorts(failed_networks);
+  if (!ports_to_prune.empty()) {
+    LOG(LS_INFO) << "Prune " << ports_to_prune.size()
+                 << " ports because their networks were gone";
+    PrunePortsAndRemoveCandidates(ports_to_prune);
+  }
 
   if (!network_manager_started_) {
     LOG(LS_INFO) << "Network manager is started";
     network_manager_started_ = true;
   }
   if (allocation_started_)
     DoAllocate();
 }
 
 void BasicPortAllocatorSession::DisableEquivalentPhases(
@@ skipping 121 matching lines @@
 bool BasicPortAllocatorSession::PruneTurnPorts(Port* newly_pairable_turn_port) {
   // Note: We determine the same network based only on their network names. So
   // if an IPv4 address and an IPv6 address have the same network name, they
   // are considered the same network here.
   const std::string& network_name = newly_pairable_turn_port->Network()->name();
   Port* best_turn_port = GetBestTurnPortForNetwork(network_name);
   // |port| is already in the list of ports, so the best port cannot be nullptr.
   RTC_CHECK(best_turn_port != nullptr);
 
   bool pruned = false;
-  std::vector<PortInterface*> pruned_ports;
+  std::vector<PortData*> ports_to_prune;
   for (PortData& data : ports_) {
     if (data.port()->Network()->name() == network_name &&
         data.port()->Type() == RELAY_PORT_TYPE && !data.pruned() &&
         ComparePort(data.port(), best_turn_port) < 0) {
-      data.set_pruned();
       pruned = true;
-      data.port()->Prune();
       if (data.port() != newly_pairable_turn_port) {
-        pruned_ports.push_back(data.port());
+        // These ports will be pruned in PrunePortsAndRemoveCandidates.
+        ports_to_prune.push_back(&data);
+      } else {
+        data.Prune();
       }
     }
   }
-  if (!pruned_ports.empty()) {
-    LOG(LS_INFO) << "Pruned " << pruned_ports.size() << " ports";
-    SignalPortsPruned(this, pruned_ports);
+
+  if (!ports_to_prune.empty()) {
+    LOG(LS_INFO) << "Prune " << ports_to_prune.size()
+                 << " low-priority TURN ports";
+    PrunePortsAndRemoveCandidates(ports_to_prune);
   }
   return pruned;
 }
 
 void BasicPortAllocatorSession::PruneAllPorts() {
   for (PortData& data : ports_) {
-    data.port()->Prune();
+    data.Prune();
   }
 }
 
 void BasicPortAllocatorSession::OnPortComplete(Port* port) {
   ASSERT(rtc::Thread::Current() == network_thread_);
   LOG_J(LS_INFO, port) << "Port completed gathering candidates.";
   PortData* data = FindPort(port);
   ASSERT(data != NULL);
 
   // Ignore any late signals.
@@ skipping 142 matching lines @@
     Port* port) {
   for (std::vector<PortData>::iterator it = ports_.begin();
        it != ports_.end(); ++it) {
     if (it->port() == port) {
       return &*it;
     }
   }
   return NULL;
 }
 
-// Removes ports and candidates created on a given list of networks.
-void BasicPortAllocatorSession::RemovePortsAndCandidates(
+std::vector<BasicPortAllocatorSession::PortData*>
+BasicPortAllocatorSession::GetUnprunedPorts(
     const std::vector<rtc::Network*>& networks) {
-  std::vector<PortInterface*> ports_to_remove;
-  std::vector<Candidate> candidates_to_remove;
-  for (PortData& data : ports_) {
-    if (std::find(networks.begin(), networks.end(),
-                  data.sequence()->network()) == networks.end()) {
-      continue;
+  std::vector<PortData*> unpruned_ports;
+  for (PortData& port : ports_) {
+    if (!port.pruned() &&
+        std::find(networks.begin(), networks.end(),
+                  port.sequence()->network()) != networks.end()) {
+      unpruned_ports.push_back(&port);
     }
+  }
+  return unpruned_ports;
+}
+
+void BasicPortAllocatorSession::PrunePortsAndRemoveCandidates(
+    const std::vector<PortData*>& port_data_list) {
+  std::vector<PortInterface*> pruned_ports;
+  std::vector<Candidate> removed_candidates;
+  for (PortData* data : port_data_list) {
     // Prune the port so that it may be destroyed.
-    data.port()->Prune();
-    ports_to_remove.push_back(data.port());
-    if (data.has_pairable_candidate()) {
-      GetCandidatesFromPort(data, &candidates_to_remove);
+    data->Prune();
+    pruned_ports.push_back(data->port());
+    if (data->has_pairable_candidate()) {
+      GetCandidatesFromPort(*data, &removed_candidates);
       // Mark the port as having no pairable candidates so that its candidates
       // won't be removed multiple times.
-      data.set_has_pairable_candidate(false);
+      data->set_has_pairable_candidate(false);
     }
   }
-  if (!ports_to_remove.empty()) {
-    LOG(LS_INFO) << "Removed " << ports_to_remove.size() << " ports";
-    SignalPortsPruned(this, ports_to_remove);
+  if (!pruned_ports.empty()) {
+    SignalPortsPruned(this, pruned_ports);
   }
-  if (!candidates_to_remove.empty()) {
-    SignalCandidatesRemoved(this, candidates_to_remove);
+  if (!removed_candidates.empty()) {
+    LOG(LS_INFO) << "Removed " << removed_candidates.size() << " candidates";
+    SignalCandidatesRemoved(this, removed_candidates);
   }
 }
 
 // AllocationSequence
 
 AllocationSequence::AllocationSequence(BasicPortAllocatorSession* session,
                                        rtc::Network* network,
                                        PortConfiguration* config,
                                        uint32_t flags)
     : session_(session),
@@ skipping 480 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