Merge SignalPortPruned with SignalPortsRemoved in PortAllocatorSession

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 677 matching lines @@
 
   // Mark that the port has a pairable candidate, either because we have a
   // usable candidate from the port, or simply because the port is bound to the
   // any address and therefore has no host candidate. This will trigger the port
   // to start creating candidate pairs (connections) and issue connectivity
   // checks. If port has already been marked as having a pairable candidate,
   // do nothing here.
   // Note: We should check whether any candidates may become ready after this
   // because there we will check whether the candidate is generated by the ready
   // ports, which may include this port.
-  bool pruned_port = false;
+  bool pruned = false;
   if (CandidatePairable(c, port) && !data->has_pairable_candidate()) {
     data->set_has_pairable_candidate(true);
 
     if (prune_turn_ports_ && port->Type() == RELAY_PORT_TYPE) {
-      pruned_port = PruneTurnPorts(port);
+      pruned = PruneTurnPorts(port);
     }
     // If the current port is not pruned yet, SignalPortReady.
     if (!data->pruned()) {
       LOG_J(LS_INFO, port) << "Port ready.";
       SignalPortReady(this, port);
     }
   }
 
   ProtocolType pvalue;
   bool candidate_protocol_enabled =
       StringToProto(c.protocol().c_str(), &pvalue) &&
       data->sequence()->ProtocolEnabled(pvalue);
 
   if (data->ready() && CheckCandidateFilter(c) && candidate_protocol_enabled) {
     std::vector<Candidate> candidates;
     candidates.push_back(SanitizeRelatedAddress(c));
     SignalCandidatesReady(this, candidates);
   } else if (!candidate_protocol_enabled) {
     LOG(LS_INFO)
         << "Not yet signaling candidate because protocol is not yet enabled.";
   } else {
     LOG(LS_INFO) << "Discarding candidate because it doesn't match filter.";
   }
 
   // If we have pruned any port, maybe need to signal port allocation done.
-  if (pruned_port) {
+  if (pruned) {
     MaybeSignalCandidatesAllocationDone();
   }
 }
 
 Port* BasicPortAllocatorSession::GetBestTurnPortForNetwork(
     const std::string& network_name) const {
   Port* best_turn_port = nullptr;
   for (const PortData& data : ports_) {
     if (data.port()->Network()->name() == network_name &&
         data.port()->Type() == RELAY_PORT_TYPE && data.ready() &&
         (!best_turn_port || ComparePort(data.port(), best_turn_port) > 0)) {
       best_turn_port = data.port();
     }
   }
   return best_turn_port;
 }
 
 bool BasicPortAllocatorSession::PruneTurnPorts(Port* newly_pairable_turn_port) {
-  bool pruned_port = false;
   // 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;
   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_port = true;
+      pruned = true;
       if (data.port() != newly_pairable_turn_port) {
-        SignalPortPruned(this, data.port());
+        pruned_ports.push_back(data.port());
       }
     }
   }
-  return pruned_port;
+  if (!pruned_ports.empty()) {
+    LOG(LS_INFO) << "Pruned " << pruned_ports.size() << " ports";
+    SignalPortsPruned(this, pruned_ports);
+  }
+  return pruned;
 }
 
 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.
   if (!data->inprogress()) {
@@ skipping 160 matching lines @@
     }
     ports_to_remove.push_back(data.port());
     if (data.has_pairable_candidate()) {
       GetCandidatesFromPort(data, &candidates_to_remove);
       // Mark the port as having no pairable candidates so that its candidates
       // won't be removed multiple times.
       data.set_has_pairable_candidate(false);
     }
   }
   if (!ports_to_remove.empty()) {
-    SignalPortsRemoved(this, ports_to_remove);
+    LOG(LS_INFO) << "Removed " << ports_to_remove.size() << " ports";
+    SignalPortsPruned(this, ports_to_remove);
   }
   if (!candidates_to_remove.empty()) {
     SignalCandidatesRemoved(this, candidates_to_remove);
   }
 }
 
 // AllocationSequence
 
 AllocationSequence::AllocationSequence(BasicPortAllocatorSession* session,
                                        rtc::Network* network,
@@ skipping 471 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