Revert of Relanding: Implement RTCConfiguration.iceCandidatePoolSize.

webrtc/p2p/base/p2ptransportchannel.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 243 matching lines @@
   uint32_t weak_ping_interval = ::strtoul(
       webrtc::field_trial::FindFullName("WebRTC-StunInterPacketDelay").c_str(),
       nullptr, 10);
   if (weak_ping_interval) {
     weak_ping_interval_ = static_cast<int>(weak_ping_interval);
   }
 }
 
 P2PTransportChannel::~P2PTransportChannel() {
   ASSERT(worker_thread_ == rtc::Thread::Current());
+
+  for (size_t i = 0; i < allocator_sessions_.size(); ++i)
+    delete allocator_sessions_[i];
 }
 
 // Add the allocator session to our list so that we know which sessions
 // are still active.
-void P2PTransportChannel::AddAllocatorSession(
-    std::unique_ptr<PortAllocatorSession> session) {
+void P2PTransportChannel::AddAllocatorSession(PortAllocatorSession* session) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
 
   session->set_generation(static_cast<uint32_t>(allocator_sessions_.size()));
-  session->SignalPortReady.connect(this, &P2PTransportChannel::OnPortReady);
-  session->SignalCandidatesReady.connect(
-      this, &P2PTransportChannel::OnCandidatesReady);
-  session->SignalCandidatesAllocationDone.connect(
-      this, &P2PTransportChannel::OnCandidatesAllocationDone);
+  allocator_sessions_.push_back(session);
 
   // We now only want to apply new candidates that we receive to the ports
   // created by this new session because these are replacing those of the
   // previous sessions.
   ports_.clear();
 
-  allocator_sessions_.push_back(std::move(session));
+  session->SignalPortReady.connect(this, &P2PTransportChannel::OnPortReady);
+  session->SignalCandidatesReady.connect(
+      this, &P2PTransportChannel::OnCandidatesReady);
+  session->SignalCandidatesAllocationDone.connect(
+      this, &P2PTransportChannel::OnCandidatesAllocationDone);
+  session->StartGettingPorts();
 }
 
 void P2PTransportChannel::AddConnection(Connection* connection) {
   connections_.push_back(connection);
   unpinged_connections_.insert(connection);
   connection->set_remote_ice_mode(remote_ice_mode_);
   connection->set_receiving_timeout(config_.receiving_timeout);
   connection->SignalReadPacket.connect(
       this, &P2PTransportChannel::OnReadPacket);
   connection->SignalReadyToSend.connect(
@@ skipping 167 matching lines @@
 void P2PTransportChannel::MaybeStartGathering() {
   // Start gathering if we never started before, or if an ICE restart occurred.
   if (allocator_sessions_.empty() ||
       IceCredentialsChanged(allocator_sessions_.back()->ice_ufrag(),
                             allocator_sessions_.back()->ice_pwd(), ice_ufrag_,
                             ice_pwd_)) {
     if (gathering_state_ != kIceGatheringGathering) {
       gathering_state_ = kIceGatheringGathering;
       SignalGatheringState(this);
     }
-    // Time for a new allocator.
-    std::unique_ptr<PortAllocatorSession> pooled_session =
-        allocator_->TakePooledSession(transport_name(), component(), ice_ufrag_,
-                                      ice_pwd_);
-    if (pooled_session) {
-      AddAllocatorSession(std::move(pooled_session));
-      PortAllocatorSession* raw_pooled_session =
-          allocator_sessions_.back().get();
-      // Process the pooled session's existing candidates/ports, if they exist.
-      OnCandidatesReady(raw_pooled_session,
-                        raw_pooled_session->ReadyCandidates());
-      for (PortInterface* port : allocator_sessions_.back()->ReadyPorts()) {
-        OnPortReady(raw_pooled_session, port);
-      }
-      if (allocator_sessions_.back()->CandidatesAllocationDone()) {
-        OnCandidatesAllocationDone(raw_pooled_session);
-      }
-    } else {
-      AddAllocatorSession(allocator_->CreateSession(
-          SessionId(), transport_name(), component(), ice_ufrag_, ice_pwd_));
-      allocator_sessions_.back()->StartGettingPorts();
-    }
+    // Time for a new allocator
+    AddAllocatorSession(allocator_->CreateSession(
+        SessionId(), transport_name(), component(), ice_ufrag_, ice_pwd_));
   }
 }
 
 // A new port is available, attempt to make connections for it
 void P2PTransportChannel::OnPortReady(PortAllocatorSession *session,
                                       PortInterface* port) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
 
   // Set in-effect options on the new port
   for (OptionMap::const_iterator it = options_.begin();
@@ skipping 718 matching lines @@
     }
   }
   set_receiving(receiving);
 }
 
 void P2PTransportChannel::MaybeStopPortAllocatorSessions() {
   if (!IsGettingPorts()) {
     return;
   }
 
-  for (const auto& session : allocator_sessions_) {
+  for (PortAllocatorSession* session : allocator_sessions_) {
     if (!session->IsGettingPorts()) {
       continue;
     }
     // If gathering continually, keep the last session running so that it
     // will gather candidates if the networks change.
     if (config_.gather_continually && session == allocator_sessions_.back()) {
       session->ClearGettingPorts();
       break;
     }
     session->StopGettingPorts();
@@ skipping 415 matching lines @@
 
   // During the initial state when nothing has been pinged yet, return the first
   // one in the ordered |connections_|.
   return *(std::find_if(connections_.begin(), connections_.end(),
                         [conn1, conn2](Connection* conn) {
                           return conn == conn1 || conn == conn2;
                         }));
 }
 
 }  // namespace cricket