Revert of Relanding: Implement RTCConfiguration.iceCandidatePoolSize.

webrtc/p2p/base/fakeportallocator.h

Index: webrtc/p2p/base/fakeportallocator.h
diff --git a/webrtc/p2p/base/fakeportallocator.h b/webrtc/p2p/base/fakeportallocator.h
deleted file mode 100644
index b125dfd80e90b3bc23b91a5a8b12850665ffc049..0000000000000000000000000000000000000000
--- a/webrtc/p2p/base/fakeportallocator.h
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
- *  Copyright 2010 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.
- */
-
-#ifndef WEBRTC_P2P_BASE_FAKEPORTALLOCATOR_H_
-#define WEBRTC_P2P_BASE_FAKEPORTALLOCATOR_H_
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "webrtc/p2p/base/basicpacketsocketfactory.h"
-#include "webrtc/p2p/base/portallocator.h"
-#include "webrtc/p2p/base/udpport.h"
-#include "webrtc/base/scoped_ptr.h"
-
-namespace rtc {
-class SocketFactory;
-class Thread;
-}
-
-namespace cricket {
-
-class TestUDPPort : public UDPPort {
- public:
-  static TestUDPPort* Create(rtc::Thread* thread,
-                             rtc::PacketSocketFactory* factory,
-                             rtc::Network* network,
-                             const rtc::IPAddress& ip,
-                             uint16_t min_port,
-                             uint16_t max_port,
-                             const std::string& username,
-                             const std::string& password,
-                             const std::string& origin,
-                             bool emit_localhost_for_anyaddress) {
-    TestUDPPort* port = new TestUDPPort(thread, factory, network, ip, min_port,
-                                        max_port, username, password, origin,
-                                        emit_localhost_for_anyaddress);
-    if (!port->Init()) {
-      delete port;
-      port = nullptr;
-    }
-    return port;
-  }
-  void SendBindingResponse(StunMessage* request,
-                           const rtc::SocketAddress& addr) override {
-    UDPPort::SendBindingResponse(request, addr);
-    sent_binding_response_ = true;
-  }
-  bool sent_binding_response() { return sent_binding_response_; }
-  void set_sent_binding_response(bool response) {
-    sent_binding_response_ = response;
-  }
-
- protected:
-  TestUDPPort(rtc::Thread* thread,
-              rtc::PacketSocketFactory* factory,
-              rtc::Network* network,
-              const rtc::IPAddress& ip,
-              uint16_t min_port,
-              uint16_t max_port,
-              const std::string& username,
-              const std::string& password,
-              const std::string& origin,
-              bool emit_localhost_for_anyaddress)
-      : UDPPort(thread,
-                factory,
-                network,
-                ip,
-                min_port,
-                max_port,
-                username,
-                password,
-                origin,
-                emit_localhost_for_anyaddress) {}
-
-  bool sent_binding_response_ = false;
-};
-
-class FakePortAllocatorSession : public PortAllocatorSession {
- public:
-  FakePortAllocatorSession(PortAllocator* allocator,
-                           rtc::Thread* worker_thread,
-                           rtc::PacketSocketFactory* factory,
-                           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()),
-        worker_thread_(worker_thread),
-        factory_(factory),
-        network_("network", "unittest", rtc::IPAddress(INADDR_LOOPBACK), 8),
-        port_(),
-        running_(false),
-        port_config_count_(0),
-        stun_servers_(allocator->stun_servers()),
-        turn_servers_(allocator->turn_servers()),
-        candidate_filter_(allocator->candidate_filter()) {
-    network_.AddIP(rtc::IPAddress(INADDR_LOOPBACK));
-  }
-
-  void StartGettingPorts() override {
-    if (!port_) {
-      port_.reset(TestUDPPort::Create(worker_thread_, factory_, &network_,
-                                      network_.GetBestIP(), 0, 0, username(),
-                                      password(), std::string(), false));
-      AddPort(port_.get());
-    }
-    ++port_config_count_;
-    running_ = true;
-  }
-
-  void StopGettingPorts() override { running_ = false; }
-  bool IsGettingPorts() override { return running_; }
-  void ClearGettingPorts() override {}
-  std::vector<PortInterface*> ReadyPorts() const override {
-    return ready_ports_;
-  }
-  std::vector<Candidate> ReadyCandidates() const override {
-    return candidates_;
-  }
-  bool CandidatesAllocationDone() const override { return allocation_done_; }
-
-  int port_config_count() { return port_config_count_; }
-
-  const ServerAddresses& stun_servers() const { return stun_servers_; }
-
-  const std::vector<RelayServerConfig>& turn_servers() const {
-    return turn_servers_;
-  }
-
-  uint32_t candidate_filter() const { return candidate_filter_; }
-
-  void AddPort(cricket::Port* port) {
-    port->set_component(component());
-    port->set_generation(generation());
-    port->SignalPortComplete.connect(this,
-                                     &FakePortAllocatorSession::OnPortComplete);
-    port->PrepareAddress();
-    ready_ports_.push_back(port);
-    SignalPortReady(this, port);
-  }
-  void OnPortComplete(cricket::Port* port) {
-    const std::vector<Candidate>& candidates = port->Candidates();
-    candidates_.insert(candidates_.end(), candidates.begin(), candidates.end());
-    SignalCandidatesReady(this, candidates);
-
-    allocation_done_ = true;
-    SignalCandidatesAllocationDone(this);
-  }
-
-  int transport_info_update_count() const {
-    return transport_info_update_count_;
-  }
-
- protected:
-  void UpdateIceParametersInternal() override {
-    // Since this class is a fake and this method only is overridden for tests,
-    // we don't need to actually update the transport info.
-    ++transport_info_update_count_;
-  }
-
- private:
-  rtc::Thread* worker_thread_;
-  rtc::PacketSocketFactory* factory_;
-  rtc::Network network_;
-  std::unique_ptr<cricket::Port> port_;
-  bool running_;
-  int port_config_count_;
-  std::vector<Candidate> candidates_;
-  std::vector<PortInterface*> ready_ports_;
-  bool allocation_done_ = false;
-  ServerAddresses stun_servers_;
-  std::vector<RelayServerConfig> turn_servers_;
-  uint32_t candidate_filter_;
-  int transport_info_update_count_ = 0;
-};
-
-class FakePortAllocator : public cricket::PortAllocator {
- public:
-  FakePortAllocator(rtc::Thread* worker_thread,
-                    rtc::PacketSocketFactory* factory)
-      : worker_thread_(worker_thread), factory_(factory) {
-    if (factory_ == NULL) {
-      owned_factory_.reset(new rtc::BasicPacketSocketFactory(worker_thread_));
-      factory_ = owned_factory_.get();
-    }
-  }
-
-  void SetNetworkIgnoreMask(int network_ignore_mask) override {}
-
-  cricket::PortAllocatorSession* CreateSessionInternal(
-      const std::string& content_name,
-      int component,
-      const std::string& ice_ufrag,
-      const std::string& ice_pwd) override {
-    return new FakePortAllocatorSession(this, worker_thread_, factory_,
-                                        content_name, component, ice_ufrag,
-                                        ice_pwd);
-  }
-
- private:
-  rtc::Thread* worker_thread_;
-  rtc::PacketSocketFactory* factory_;
-  std::unique_ptr<rtc::BasicPacketSocketFactory> owned_factory_;
-};
-
-}  // namespace cricket
-
-#endif  // WEBRTC_P2P_BASE_FAKEPORTALLOCATOR_H_