Relanding: Implement RTCConfiguration.iceCandidatePoolSize.

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 46 matching lines @@
 }
 
 }  // namespace
 
 namespace cricket {
 const uint32_t DISABLE_ALL_PHASES =
     PORTALLOCATOR_DISABLE_UDP | PORTALLOCATOR_DISABLE_TCP |
     PORTALLOCATOR_DISABLE_STUN | PORTALLOCATOR_DISABLE_RELAY;
 
 // BasicPortAllocator
-BasicPortAllocator::BasicPortAllocator(
-    rtc::NetworkManager* network_manager,
-    rtc::PacketSocketFactory* socket_factory)
-    : network_manager_(network_manager),
-      socket_factory_(socket_factory),
-      stun_servers_() {
+BasicPortAllocator::BasicPortAllocator(rtc::NetworkManager* network_manager,
+                                       rtc::PacketSocketFactory* socket_factory)
+    : network_manager_(network_manager), socket_factory_(socket_factory) {
   ASSERT(network_manager_ != nullptr);
   ASSERT(socket_factory_ != nullptr);
   Construct();
 }
 
 BasicPortAllocator::BasicPortAllocator(rtc::NetworkManager* network_manager)
-    : network_manager_(network_manager),
-      socket_factory_(nullptr),
-      stun_servers_() {
+    : network_manager_(network_manager), socket_factory_(nullptr) {
   ASSERT(network_manager_ != nullptr);
   Construct();
 }
 
-BasicPortAllocator::BasicPortAllocator(
-    rtc::NetworkManager* network_manager,
-    rtc::PacketSocketFactory* socket_factory,
-    const ServerAddresses& stun_servers)
-    : network_manager_(network_manager),
-      socket_factory_(socket_factory),
-      stun_servers_(stun_servers) {
+BasicPortAllocator::BasicPortAllocator(rtc::NetworkManager* network_manager,
+                                       rtc::PacketSocketFactory* socket_factory,
+                                       const ServerAddresses& stun_servers)
+    : network_manager_(network_manager), socket_factory_(socket_factory) {
   ASSERT(socket_factory_ != NULL);
+  SetConfiguration(stun_servers, std::vector<RelayServerConfig>(), 0);
   Construct();
 }
 
 BasicPortAllocator::BasicPortAllocator(
     rtc::NetworkManager* network_manager,
     const ServerAddresses& stun_servers,
     const rtc::SocketAddress& relay_address_udp,
     const rtc::SocketAddress& relay_address_tcp,
     const rtc::SocketAddress& relay_address_ssl)
-    : network_manager_(network_manager),
-      socket_factory_(NULL),
-      stun_servers_(stun_servers) {
-
+    : network_manager_(network_manager), socket_factory_(NULL) {
+  std::vector<RelayServerConfig> turn_servers;
   RelayServerConfig config(RELAY_GTURN);
   if (!relay_address_udp.IsNil()) {
     config.ports.push_back(ProtocolAddress(relay_address_udp, PROTO_UDP));
   }
   if (!relay_address_tcp.IsNil()) {
     config.ports.push_back(ProtocolAddress(relay_address_tcp, PROTO_TCP));
   }
   if (!relay_address_ssl.IsNil()) {
     config.ports.push_back(ProtocolAddress(relay_address_ssl, PROTO_SSLTCP));
   }
 
   if (!config.ports.empty()) {
-    AddTurnServer(config);
+    turn_servers.push_back(config);
   }
 
+  SetConfiguration(stun_servers, turn_servers, 0);
   Construct();
 }
 
 void BasicPortAllocator::Construct() {
   allow_tcp_listen_ = true;
 }
 
 BasicPortAllocator::~BasicPortAllocator() {
 }
 
 PortAllocatorSession* BasicPortAllocator::CreateSessionInternal(
     const std::string& content_name, int component,
     const std::string& ice_ufrag, const std::string& ice_pwd) {
   return new BasicPortAllocatorSession(
       this, content_name, component, ice_ufrag, ice_pwd);
 }
 
+void BasicPortAllocator::AddTurnServer(const RelayServerConfig& turn_server) {
+  std::vector<RelayServerConfig> new_turn_servers = turn_servers();
+  new_turn_servers.push_back(turn_server);
+  SetConfiguration(stun_servers(), new_turn_servers, candidate_pool_size());
+}
 
 // BasicPortAllocatorSession
 BasicPortAllocatorSession::BasicPortAllocatorSession(
     BasicPortAllocator *allocator,
     const std::string& content_name,
     int component,
     const std::string& ice_ufrag,
     const std::string& ice_pwd)
     : PortAllocatorSession(content_name, component,
                            ice_ufrag, ice_pwd, allocator->flags()),
@@ skipping 51 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();
 }
 
+std::vector<PortInterface*> BasicPortAllocatorSession::ReadyPorts() const {
+  std::vector<PortInterface*> ret;
+  for (const PortData& port : ports_) {
+    if (port.ready() || port.complete()) {
+      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(candidate);
+    }
+  }
+  return candidates;
+}
+
+bool BasicPortAllocatorSession::CandidatesAllocationDone() const {
+  // Done only if all required AllocationSequence objects
+  // are created.
+  if (!allocation_sequences_created_) {
+    return false;
+  }
+
+  // Check that all port allocation sequences are complete (not running).
+  if (std::any_of(sequences_.begin(), sequences_.end(),
+                  [](const AllocationSequence* sequence) {
+                    return sequence->state() == AllocationSequence::kRunning;
+                  })) {
+    return false;
+  }
+
+  // If all allocated ports are in complete state, session must have got all
+  // expected candidates. Session will trigger candidates allocation complete
+  // signal.
+  if (!std::all_of(ports_.begin(), ports_.end(), [](const PortData& port) {
+        return (port.complete() || port.error());
+      })) {
+    return false;
+  }
+
+  return true;
+}
+
 void BasicPortAllocatorSession::OnMessage(rtc::Message *message) {
   switch (message->message_id) {
   case MSG_CONFIG_START:
     ASSERT(rtc::Thread::Current() == network_thread_);
     GetPortConfigurations();
     break;
 
   case MSG_CONFIG_READY:
     ASSERT(rtc::Thread::Current() == network_thread_);
     OnConfigReady(static_cast<PortConfiguration*>(message->pdata));
@@ skipping 14 matching lines @@
     break;
   case MSG_CONFIG_STOP:
     ASSERT(rtc::Thread::Current() == network_thread_);
     OnConfigStop();
     break;
   default:
     ASSERT(false);
   }
 }
 
+void BasicPortAllocatorSession::UpdateIceParametersInternal() {
+  for (PortData& port : ports_) {
+    port.port()->set_content_name(content_name());
+    port.port()->SetIceParameters(component(), ice_ufrag(), ice_pwd());
+  }
+}
+
 void BasicPortAllocatorSession::GetPortConfigurations() {
   PortConfiguration* config = new PortConfiguration(allocator_->stun_servers(),
                                                     username(),
                                                     password());
 
   for (const RelayServerConfig& turn_server : allocator_->turn_servers()) {
     config->AddRelay(turn_server);
   }
   ConfigReady(config);
 }
@@ skipping 13 matching lines @@
 
 void BasicPortAllocatorSession::OnConfigStop() {
   ASSERT(rtc::Thread::Current() == network_thread_);
 
   // If any of the allocated ports have not completed the candidates allocation,
   // mark those as error. Since session doesn't need any new candidates
   // at this stage of the allocation, it's safe to discard any new candidates.
   bool send_signal = false;
   for (std::vector<PortData>::iterator it = ports_.begin();
        it != ports_.end(); ++it) {
-    if (!it->complete()) {
+    if (!it->complete() && !it->error()) {
       // Updating port state to error, which didn't finish allocating candidates
       // yet.
       it->set_error();
       send_signal = true;
     }
   }
 
   // Did we stop any running sequences?
   for (std::vector<AllocationSequence*>::iterator it = sequences_.begin();
        it != sequences_.end() && !send_signal; ++it) {
@@ skipping 141 matching lines @@
 }
 
 void BasicPortAllocatorSession::AddAllocatedPort(Port* port,
                                                  AllocationSequence * seq,
                                                  bool prepare_address) {
   if (!port)
     return;
 
   LOG(LS_INFO) << "Adding allocated port for " << content_name();
   port->set_content_name(content_name());
-  port->set_component(component_);
+  port->set_component(component());
   port->set_generation(generation());
   if (allocator_->proxy().type != rtc::PROXY_NONE)
     port->set_proxy(allocator_->user_agent(), allocator_->proxy());
-  port->set_send_retransmit_count_attribute((allocator_->flags() &
-      PORTALLOCATOR_ENABLE_STUN_RETRANSMIT_ATTRIBUTE) != 0);
+  port->set_send_retransmit_count_attribute(
+      (flags() & PORTALLOCATOR_ENABLE_STUN_RETRANSMIT_ATTRIBUTE) != 0);
 
   // Push down the candidate_filter to individual port.
   uint32_t candidate_filter = allocator_->candidate_filter();
 
   // When adapter enumeration is disabled, disable CF_HOST at port level so
   // local address is not leaked by stunport in the candidate's related address.
   if ((flags() & PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION) &&
       (flags() & PORTALLOCATOR_DISABLE_DEFAULT_LOCAL_CANDIDATE)) {
     candidate_filter &= ~CF_HOST;
   }
@@ skipping 22 matching lines @@
   MaybeSignalCandidatesAllocationDone();
 }
 
 void BasicPortAllocatorSession::OnCandidateReady(
     Port* port, const Candidate& c) {
   ASSERT(rtc::Thread::Current() == network_thread_);
   PortData* data = FindPort(port);
   ASSERT(data != NULL);
   // Discarding any candidate signal if port allocation status is
   // already in completed state.
-  if (data->complete())
+  if (data->complete() || data->error()) {
     return;
+  }
 
   ProtocolType pvalue;
   bool candidate_signalable = CheckCandidateFilter(c);
 
   // When device enumeration is disabled (to prevent non-default IP addresses
   // from leaking), we ping from some local candidates even though we don't
   // signal them. However, if host candidates are also disabled (for example, to
   // prevent even default IP addresses from leaking), we still don't want to
   // ping from them, even if device enumeration is disabled.  Thus, we check for
   // both device enumeration and host candidates being disabled.
@@ skipping 30 matching lines @@
     SignalPortReady(this, port);
   }
 }
 
 void BasicPortAllocatorSession::OnPortComplete(Port* port) {
   ASSERT(rtc::Thread::Current() == network_thread_);
   PortData* data = FindPort(port);
   ASSERT(data != NULL);
 
   // Ignore any late signals.
-  if (data->complete())
+  if (data->complete() || data->error()) {
     return;
+  }
 
   // Moving to COMPLETE state.
   data->set_complete();
   // Send candidate allocation complete signal if this was the last port.
   MaybeSignalCandidatesAllocationDone();
 }
 
 void BasicPortAllocatorSession::OnPortError(Port* port) {
   ASSERT(rtc::Thread::Current() == network_thread_);
   PortData* data = FindPort(port);
   ASSERT(data != NULL);
   // We might have already given up on this port and stopped it.
-  if (data->complete())
+  if (data->complete() || data->error()) {
     return;
+  }
 
   // SignalAddressError is currently sent from StunPort/TurnPort.
   // But this signal itself is generic.
   data->set_error();
   // Send candidate allocation complete signal if this was the last port.
   MaybeSignalCandidatesAllocationDone();
 }
 
 void BasicPortAllocatorSession::OnProtocolEnabled(AllocationSequence* seq,
                                                   ProtocolType proto) {
@@ skipping 15 matching lines @@
         candidates.push_back(potentials[i]);
       }
     }
   }
 
   if (!candidates.empty()) {
     SignalCandidatesReady(this, candidates);
   }
 }
 
-bool BasicPortAllocatorSession::CheckCandidateFilter(const Candidate& c) {
+bool BasicPortAllocatorSession::CheckCandidateFilter(const Candidate& c) const {
   uint32_t filter = allocator_->candidate_filter();
 
   // When binding to any address, before sending packets out, the getsockname
   // returns all 0s, but after sending packets, it'll be the NIC used to
   // send. All 0s is not a valid ICE candidate address and should be filtered
   // out.
   if (c.address().IsAnyIP()) {
     return false;
   }
 
@@ skipping 17 matching lines @@
   return false;
 }
 
 void BasicPortAllocatorSession::OnPortAllocationComplete(
     AllocationSequence* seq) {
   // Send candidate allocation complete signal if all ports are done.
   MaybeSignalCandidatesAllocationDone();
 }
 
 void BasicPortAllocatorSession::MaybeSignalCandidatesAllocationDone() {
-  // Send signal only if all required AllocationSequence objects
-  // are created.
-  if (!allocation_sequences_created_)
-    return;
-
-  // Check that all port allocation sequences are complete.
-  for (std::vector<AllocationSequence*>::iterator it = sequences_.begin();
-       it != sequences_.end(); ++it) {
-    if ((*it)->state() == AllocationSequence::kRunning)
-      return;
+  if (CandidatesAllocationDone()) {
+    if (pooled()) {
+      LOG(LS_INFO) << "All candidates gathered for pooled session.";
+    } else {
+      LOG(LS_INFO) << "All candidates gathered for " << content_name() << ":"
+                   << component() << ":" << generation();
+    }
+    SignalCandidatesAllocationDone(this);
   }
-
-  // If all allocated ports are in complete state, session must have got all
-  // expected candidates. Session will trigger candidates allocation complete
-  // signal.
-  for (std::vector<PortData>::iterator it = ports_.begin();
-       it != ports_.end(); ++it) {
-    if (!it->complete())
-      return;
-  }
-  LOG(LS_INFO) << "All candidates gathered for " << content_name_ << ":"
-               << component_ << ":" << generation();
-  SignalCandidatesAllocationDone(this);
 }
 
 void BasicPortAllocatorSession::OnPortDestroyed(
     PortInterface* port) {
   ASSERT(rtc::Thread::Current() == network_thread_);
   for (std::vector<PortData>::iterator iter = ports_.begin();
        iter != ports_.end(); ++iter) {
     if (port == iter->port()) {
       ports_.erase(iter);
       LOG_J(LS_INFO, port) << "Removed port from allocator ("
@@ skipping 523 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