Make ClientSocketPoolManager into an interface.

This allows for using a MockClientSocketPoolManager. The default implementation has been moved into ClientSocketPoolManagerImpl. This allows HttpNetworkSessionPeer to replace the whole ClientSocketPoolManager rather than individual socket pools, which is necessary because socket pools will become more integrated in the future.

BUG=none
TEST=none


Review URL: http://codereview.chromium.org/8572041

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@110510 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 796 insertions, 556 deletions

diff --git a/net/socket/client_socket_pool_manager.cc b/net/socket/client_socket_pool_manager.cc
index b47c3e5..219747d 100644
--- a/net/socket/client_socket_pool_manager.cc
+++ b/net/socket/client_socket_pool_manager.cc
@@ -1,10 +1,6 @@
 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
-//
-// ClientSocketPoolManager manages access to all ClientSocketPools.  It's a
-// simple container for all of them.  Most importantly, it handles the lifetime
-// and destruction order properly.
 
 #include "net/socket/client_socket_pool_manager.h"
 
@@ -12,15 +8,12 @@
 
 #include "base/logging.h"
 #include "base/stringprintf.h"
-#include "base/values.h"
-#include "net/base/ssl_config_service.h"
+#include "net/base/load_flags.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_proxy_client_socket_pool.h"
 #include "net/http/http_request_info.h"
-#include "net/proxy/proxy_service.h"
-#include "net/socket/client_socket_factory.h"
+#include "net/proxy/proxy_info.h"
 #include "net/socket/client_socket_handle.h"
-#include "net/socket/client_socket_pool_histograms.h"
 #include "net/socket/socks_client_socket_pool.h"
 #include "net/socket/ssl_client_socket_pool.h"
 #include "net/socket/transport_client_socket_pool.h"
@@ -42,20 +35,6 @@ int g_max_sockets_per_group = 6;
 // http://crbug.com/44501 for details about proxy server connection limits.
 int g_max_sockets_per_proxy_server = kDefaultMaxSocketsPerProxyServer;
 
-// Appends information about all |socket_pools| to the end of |list|.
-template <class MapType>
-static void AddSocketPoolsToList(ListValue* list,
-                                 const MapType& socket_pools,
-                                 const std::string& type,
-                                 bool include_nested_pools) {
-  for (typename MapType::const_iterator it = socket_pools.begin();
-       it != socket_pools.end(); it++) {
-    list->Append(it->second->GetInfoAsValue(it->first.ToString(),
-                                            type,
-                                            include_nested_pools));
-  }
-}
-
 // The meat of the implementation for the InitSocketHandleForHttpRequest,
 // InitSocketHandleForRawConnect and PreconnectSocketsForHttpRequest methods.
 int InitSocketPoolHelper(const GURL& request_url,
@@ -182,7 +161,7 @@ int InitSocketPoolHelper(const GURL& request_url,
                             want_spdy_over_npn);
     SSLClientSocketPool* ssl_pool = NULL;
     if (proxy_info.is_direct())
-      ssl_pool = session->ssl_socket_pool();
+      ssl_pool = session->GetSSLSocketPool();
     else
       ssl_pool = session->GetSocketPoolForSSLWithProxy(*proxy_host_port);
 
@@ -228,7 +207,7 @@ int InitSocketPoolHelper(const GURL& request_url,
 
   DCHECK(proxy_info.is_direct());
 
-  TransportClientSocketPool* pool = session->transport_socket_pool();
+  TransportClientSocketPool* pool = session->GetTransportSocketPool();
   if (num_preconnect_streams) {
     RequestSocketsForPool(pool, connection_group, tcp_params,
                           num_preconnect_streams, net_log);
@@ -242,299 +221,12 @@ int InitSocketPoolHelper(const GURL& request_url,
 
 }  // namespace
 
-ClientSocketPoolManager::ClientSocketPoolManager(
-    NetLog* net_log,
-    ClientSocketFactory* socket_factory,
-    HostResolver* host_resolver,
-    CertVerifier* cert_verifier,
-    OriginBoundCertService* origin_bound_cert_service,
-    DnsRRResolver* dnsrr_resolver,
-    DnsCertProvenanceChecker* dns_cert_checker,
-    SSLHostInfoFactory* ssl_host_info_factory,
-    ProxyService* proxy_service,
-    SSLConfigService* ssl_config_service)
-    : net_log_(net_log),
-      socket_factory_(socket_factory),
-      host_resolver_(host_resolver),
-      cert_verifier_(cert_verifier),
-      origin_bound_cert_service_(origin_bound_cert_service),
-      dnsrr_resolver_(dnsrr_resolver),
-      dns_cert_checker_(dns_cert_checker),
-      ssl_host_info_factory_(ssl_host_info_factory),
-      proxy_service_(proxy_service),
-      ssl_config_service_(ssl_config_service),
-      transport_pool_histograms_("TCP"),
-      transport_socket_pool_(new TransportClientSocketPool(
-          g_max_sockets_per_pool, g_max_sockets_per_group,
-          &transport_pool_histograms_,
-          host_resolver,
-          socket_factory_,
-          net_log)),
-      ssl_pool_histograms_("SSL2"),
-      ssl_socket_pool_(new SSLClientSocketPool(
-          g_max_sockets_per_pool, g_max_sockets_per_group,
-          &ssl_pool_histograms_,
-          host_resolver,
-          cert_verifier,
-          origin_bound_cert_service,
-          dnsrr_resolver,
-          dns_cert_checker,
-          ssl_host_info_factory,
-          socket_factory,
-          transport_socket_pool_.get(),
-          NULL /* no socks proxy */,
-          NULL /* no http proxy */,
-          ssl_config_service,
-          net_log)),
-      transport_for_socks_pool_histograms_("TCPforSOCKS"),
-      socks_pool_histograms_("SOCK"),
-      transport_for_http_proxy_pool_histograms_("TCPforHTTPProxy"),
-      transport_for_https_proxy_pool_histograms_("TCPforHTTPSProxy"),
-      ssl_for_https_proxy_pool_histograms_("SSLforHTTPSProxy"),
-      http_proxy_pool_histograms_("HTTPProxy"),
-      ssl_socket_pool_for_proxies_histograms_("SSLForProxies") {
-  CertDatabase::AddObserver(this);
-}
-
-ClientSocketPoolManager::~ClientSocketPoolManager() {
-  CertDatabase::RemoveObserver(this);
-}
-
-void ClientSocketPoolManager::FlushSocketPools() {
-  // Flush the highest level pools first, since higher level pools may release
-  // stuff to the lower level pools.
-
-  for (SSLSocketPoolMap::const_iterator it =
-       ssl_socket_pools_for_proxies_.begin();
-       it != ssl_socket_pools_for_proxies_.end();
-       ++it)
-    it->second->Flush();
-
-  for (HTTPProxySocketPoolMap::const_iterator it =
-       http_proxy_socket_pools_.begin();
-       it != http_proxy_socket_pools_.end();
-       ++it)
-    it->second->Flush();
-
-  for (SSLSocketPoolMap::const_iterator it =
-       ssl_socket_pools_for_https_proxies_.begin();
-       it != ssl_socket_pools_for_https_proxies_.end();
-       ++it)
-    it->second->Flush();
-
-  for (TransportSocketPoolMap::const_iterator it =
-       transport_socket_pools_for_https_proxies_.begin();
-       it != transport_socket_pools_for_https_proxies_.end();
-       ++it)
-    it->second->Flush();
-
-  for (TransportSocketPoolMap::const_iterator it =
-       transport_socket_pools_for_http_proxies_.begin();
-       it != transport_socket_pools_for_http_proxies_.end();
-       ++it)
-    it->second->Flush();
-
-  for (SOCKSSocketPoolMap::const_iterator it =
-       socks_socket_pools_.begin();
-       it != socks_socket_pools_.end();
-       ++it)
-    it->second->Flush();
-
-  for (TransportSocketPoolMap::const_iterator it =
-       transport_socket_pools_for_socks_proxies_.begin();
-       it != transport_socket_pools_for_socks_proxies_.end();
-       ++it)
-    it->second->Flush();
-
-  ssl_socket_pool_->Flush();
-  transport_socket_pool_->Flush();
-}
-
-void ClientSocketPoolManager::CloseIdleSockets() {
-  // Close sockets in the highest level pools first, since higher level pools'
-  // sockets may release stuff to the lower level pools.
-  for (SSLSocketPoolMap::const_iterator it =
-       ssl_socket_pools_for_proxies_.begin();
-       it != ssl_socket_pools_for_proxies_.end();
-       ++it)
-    it->second->CloseIdleSockets();
-
-  for (HTTPProxySocketPoolMap::const_iterator it =
-       http_proxy_socket_pools_.begin();
-       it != http_proxy_socket_pools_.end();
-       ++it)
-    it->second->CloseIdleSockets();
-
-  for (SSLSocketPoolMap::const_iterator it =
-       ssl_socket_pools_for_https_proxies_.begin();
-       it != ssl_socket_pools_for_https_proxies_.end();
-       ++it)
-    it->second->CloseIdleSockets();
-
-  for (TransportSocketPoolMap::const_iterator it =
-       transport_socket_pools_for_https_proxies_.begin();
-       it != transport_socket_pools_for_https_proxies_.end();
-       ++it)
-    it->second->CloseIdleSockets();
-
-  for (TransportSocketPoolMap::const_iterator it =
-       transport_socket_pools_for_http_proxies_.begin();
-       it != transport_socket_pools_for_http_proxies_.end();
-       ++it)
-    it->second->CloseIdleSockets();
-
-  for (SOCKSSocketPoolMap::const_iterator it =
-       socks_socket_pools_.begin();
-       it != socks_socket_pools_.end();
-       ++it)
-    it->second->CloseIdleSockets();
-
-  for (TransportSocketPoolMap::const_iterator it =
-       transport_socket_pools_for_socks_proxies_.begin();
-       it != transport_socket_pools_for_socks_proxies_.end();
-       ++it)
-    it->second->CloseIdleSockets();
-
-  ssl_socket_pool_->CloseIdleSockets();
-  transport_socket_pool_->CloseIdleSockets();
-}
-
-SOCKSClientSocketPool* ClientSocketPoolManager::GetSocketPoolForSOCKSProxy(
-    const HostPortPair& socks_proxy) {
-  SOCKSSocketPoolMap::const_iterator it = socks_socket_pools_.find(socks_proxy);
-  if (it != socks_socket_pools_.end()) {
-    DCHECK(ContainsKey(transport_socket_pools_for_socks_proxies_, socks_proxy));
-    return it->second;
-  }
-
-  DCHECK(!ContainsKey(transport_socket_pools_for_socks_proxies_, socks_proxy));
-
-  std::pair<TransportSocketPoolMap::iterator, bool> tcp_ret =
-      transport_socket_pools_for_socks_proxies_.insert(
-          std::make_pair(
-              socks_proxy,
-              new TransportClientSocketPool(
-                  g_max_sockets_per_proxy_server, g_max_sockets_per_group,
-                  &transport_for_socks_pool_histograms_,
-                  host_resolver_,
-                  socket_factory_,
-                  net_log_)));
-  DCHECK(tcp_ret.second);
-
-  std::pair<SOCKSSocketPoolMap::iterator, bool> ret =
-      socks_socket_pools_.insert(
-          std::make_pair(socks_proxy, new SOCKSClientSocketPool(
-              g_max_sockets_per_proxy_server, g_max_sockets_per_group,
-              &socks_pool_histograms_,
-              host_resolver_,
-              tcp_ret.first->second,
-              net_log_)));
-
-  return ret.first->second;
-}
-
-HttpProxyClientSocketPool* ClientSocketPoolManager::GetSocketPoolForHTTPProxy(
-    const HostPortPair& http_proxy) {
-  HTTPProxySocketPoolMap::const_iterator it =
-      http_proxy_socket_pools_.find(http_proxy);
-  if (it != http_proxy_socket_pools_.end()) {
-    DCHECK(ContainsKey(transport_socket_pools_for_http_proxies_, http_proxy));
-    DCHECK(ContainsKey(transport_socket_pools_for_https_proxies_, http_proxy));
-    DCHECK(ContainsKey(ssl_socket_pools_for_https_proxies_, http_proxy));
-    return it->second;
-  }
-
-  DCHECK(!ContainsKey(transport_socket_pools_for_http_proxies_, http_proxy));
-  DCHECK(!ContainsKey(transport_socket_pools_for_https_proxies_, http_proxy));
-  DCHECK(!ContainsKey(ssl_socket_pools_for_https_proxies_, http_proxy));
-
-  std::pair<TransportSocketPoolMap::iterator, bool> tcp_http_ret =
-      transport_socket_pools_for_http_proxies_.insert(
-          std::make_pair(
-              http_proxy,
-              new TransportClientSocketPool(
-                  g_max_sockets_per_proxy_server, g_max_sockets_per_group,
-                  &transport_for_http_proxy_pool_histograms_,
-                  host_resolver_,
-                  socket_factory_,
-                  net_log_)));
-  DCHECK(tcp_http_ret.second);
-
-  std::pair<TransportSocketPoolMap::iterator, bool> tcp_https_ret =
-      transport_socket_pools_for_https_proxies_.insert(
-          std::make_pair(
-              http_proxy,
-              new TransportClientSocketPool(
-                  g_max_sockets_per_proxy_server, g_max_sockets_per_group,
-                  &transport_for_https_proxy_pool_histograms_,
-                  host_resolver_,
-                  socket_factory_,
-                  net_log_)));
-  DCHECK(tcp_https_ret.second);
-
-  std::pair<SSLSocketPoolMap::iterator, bool> ssl_https_ret =
-      ssl_socket_pools_for_https_proxies_.insert(
-          std::make_pair(
-              http_proxy,
-              new SSLClientSocketPool(
-                  g_max_sockets_per_proxy_server, g_max_sockets_per_group,
-                  &ssl_for_https_proxy_pool_histograms_,
-                  host_resolver_,
-                  cert_verifier_,
-                  origin_bound_cert_service_,
-                  dnsrr_resolver_,
-                  dns_cert_checker_,
-                  ssl_host_info_factory_,
-                  socket_factory_,
-                  tcp_https_ret.first->second /* https proxy */,
-                  NULL /* no socks proxy */,
-                  NULL /* no http proxy */,
-                  ssl_config_service_, net_log_)));
-  DCHECK(tcp_https_ret.second);
-
-  std::pair<HTTPProxySocketPoolMap::iterator, bool> ret =
-      http_proxy_socket_pools_.insert(
-          std::make_pair(
-              http_proxy,
-              new HttpProxyClientSocketPool(
-                  g_max_sockets_per_proxy_server, g_max_sockets_per_group,
-                  &http_proxy_pool_histograms_,
-                  host_resolver_,
-                  tcp_http_ret.first->second,
-                  ssl_https_ret.first->second,
-                  net_log_)));
-
-  return ret.first->second;
-}
+ClientSocketPoolManager::ClientSocketPoolManager() {}
+ClientSocketPoolManager::~ClientSocketPoolManager() {}
 
-SSLClientSocketPool* ClientSocketPoolManager::GetSocketPoolForSSLWithProxy(
-    const HostPortPair& proxy_server) {
-  SSLSocketPoolMap::const_iterator it =
-      ssl_socket_pools_for_proxies_.find(proxy_server);
-  if (it != ssl_socket_pools_for_proxies_.end())
-    return it->second;
-
-  SSLClientSocketPool* new_pool = new SSLClientSocketPool(
-      g_max_sockets_per_proxy_server, g_max_sockets_per_group,
-      &ssl_pool_histograms_,
-      host_resolver_,
-      cert_verifier_,
-      origin_bound_cert_service_,
-      dnsrr_resolver_,
-      dns_cert_checker_,
-      ssl_host_info_factory_,
-      socket_factory_,
-      NULL, /* no tcp pool, we always go through a proxy */
-      GetSocketPoolForSOCKSProxy(proxy_server),
-      GetSocketPoolForHTTPProxy(proxy_server),
-      ssl_config_service_,
-      net_log_);
-
-  std::pair<SSLSocketPoolMap::iterator, bool> ret =
-      ssl_socket_pools_for_proxies_.insert(std::make_pair(proxy_server,
-                                                          new_pool));
-
-  return ret.first->second;
+// static
+int ClientSocketPoolManager::max_sockets_per_pool() {
+  return g_max_sockets_per_pool;
 }
 
 // static
@@ -562,6 +254,11 @@ void ClientSocketPoolManager::set_max_sockets_per_group(int socket_count) {
 }
 
 // static
+int ClientSocketPoolManager::max_sockets_per_proxy_server() {
+  return g_max_sockets_per_proxy_server;
+}
+
+// static
 void ClientSocketPoolManager::set_max_sockets_per_proxy_server(
     int socket_count) {
   DCHECK_LT(0, socket_count);
@@ -572,55 +269,7 @@ void ClientSocketPoolManager::set_max_sockets_per_proxy_server(
   g_max_sockets_per_proxy_server = socket_count;
 }
 
-Value* ClientSocketPoolManager::SocketPoolInfoToValue() const {
-  ListValue* list = new ListValue();
-  list->Append(transport_socket_pool_->GetInfoAsValue("transport_socket_pool",
-                                                "transport_socket_pool",
-                                                false));
-  // Third parameter is false because |ssl_socket_pool_| uses
-  // |transport_socket_pool_| internally, and do not want to add it a second
-  // time.
-  list->Append(ssl_socket_pool_->GetInfoAsValue("ssl_socket_pool",
-                                                "ssl_socket_pool",
-                                                false));
-  AddSocketPoolsToList(list,
-                       http_proxy_socket_pools_,
-                       "http_proxy_socket_pool",
-                       true);
-  AddSocketPoolsToList(list,
-                       socks_socket_pools_,
-                       "socks_socket_pool",
-                       true);
-
-  // Third parameter is false because |ssl_socket_pools_for_proxies_| use
-  // socket pools in |http_proxy_socket_pools_| and |socks_socket_pools_|.
-  AddSocketPoolsToList(list,
-                       ssl_socket_pools_for_proxies_,
-                       "ssl_socket_pool_for_proxies",
-                       false);
-  return list;
-}
-
-void ClientSocketPoolManager::OnUserCertAdded(const X509Certificate* cert) {
-  FlushSocketPools();
-}
-
-void ClientSocketPoolManager::OnCertTrustChanged(const X509Certificate* cert) {
-  // We should flush the socket pools if we removed trust from a
-  // cert, because a previously trusted server may have become
-  // untrusted.
-  //
-  // We should not flush the socket pools if we added trust to a
-  // cert.
-  //
-  // Since the OnCertTrustChanged method doesn't tell us what
-  // kind of trust change it is, we have to flush the socket
-  // pools to be safe.
-  FlushSocketPools();
-}
-
-// static
-int ClientSocketPoolManager::InitSocketHandleForHttpRequest(
+int InitSocketHandleForHttpRequest(
     const GURL& request_url,
     const HttpRequestHeaders& request_extra_headers,
     int request_load_flags,
@@ -652,8 +301,7 @@ int ClientSocketPoolManager::InitSocketHandleForHttpRequest(
                               callback);
 }
 
-// static
-int ClientSocketPoolManager::InitSocketHandleForRawConnect(
+int InitSocketHandleForRawConnect(
     const HostPortPair& host_port_pair,
     HttpNetworkSession* session,
     const ProxyInfo& proxy_info,
@@ -686,8 +334,7 @@ int ClientSocketPoolManager::InitSocketHandleForRawConnect(
                               callback);
 }
 
-// static
-int ClientSocketPoolManager::PreconnectSocketsForHttpRequest(
+int PreconnectSocketsForHttpRequest(
     const GURL& request_url,
     const HttpRequestHeaders& request_extra_headers,
     int request_load_flags,
@@ -717,5 +364,4 @@ int ClientSocketPoolManager::PreconnectSocketsForHttpRequest(
                               NULL);
 }
 
-
 }  // namespace net
diff --git a/net/socket/client_socket_pool_manager.h b/net/socket/client_socket_pool_manager.h
index 1b81781..2c51761 100644
--- a/net/socket/client_socket_pool_manager.h
+++ b/net/socket/client_socket_pool_manager.h
@@ -10,18 +10,9 @@
 #define NET_SOCKET_CLIENT_SOCKET_POOL_MANAGER_H_
 #pragma once
 
-#include <map>
-#include "base/basictypes.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/stl_util.h"
-#include "base/template_util.h"
-#include "base/threading/non_thread_safe.h"
-#include "net/base/cert_database.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_export.h"
 #include "net/base/request_priority.h"
-#include "net/socket/client_socket_pool_histograms.h"
 
 class GURL;
 
@@ -32,26 +23,15 @@ class Value;
 namespace net {
 
 class BoundNetLog;
-class CertVerifier;
-class ClientSocketFactory;
 class ClientSocketHandle;
-class ClientSocketPoolHistograms;
-class DnsCertProvenanceChecker;
-class DnsRRResolver;
-class HttpNetworkSession;
-class HttpRequestHeaders;
 class HostPortPair;
+class HttpNetworkSession;
 class HttpProxyClientSocketPool;
-class HostResolver;
-class NetLog;
-class OriginBoundCertService;
+class HttpRequestHeaders;
 class ProxyInfo;
-class ProxyService;
+class TransportClientSocketPool;
 class SOCKSClientSocketPool;
 class SSLClientSocketPool;
-class SSLConfigService;
-class SSLHostInfoFactory;
-class TransportClientSocketPool;
 
 struct SSLConfig;
 
@@ -59,177 +39,87 @@ struct SSLConfig;
 // really offer much flexiblity in exporting contants.
 enum DefaultMaxValues { kDefaultMaxSocketsPerProxyServer = 32 };
 
-namespace internal {
-
-// A helper class for auto-deleting Values in the destructor.
-template <typename Key, typename Value>
-class OwnedPoolMap : public std::map<Key, Value> {
+class NET_EXPORT_PRIVATE ClientSocketPoolManager {
  public:
-  OwnedPoolMap() {
-    COMPILE_ASSERT(base::is_pointer<Value>::value,
-                   value_must_be_a_pointer);
-  }
-
-  ~OwnedPoolMap() {
-    STLDeleteValues(this);
-  }
-};
-
-}  // namespace internal
-
-class ClientSocketPoolManager : public base::NonThreadSafe,
-                                public CertDatabase::Observer {
- public:
-  ClientSocketPoolManager(NetLog* net_log,
-                          ClientSocketFactory* socket_factory,
-                          HostResolver* host_resolver,
-                          CertVerifier* cert_verifier,
-                          OriginBoundCertService* origin_bound_cert_service,
-                          DnsRRResolver* dnsrr_resolver,
-                          DnsCertProvenanceChecker* dns_cert_checker,
-                          SSLHostInfoFactory* ssl_host_info_factory,
-                          ProxyService* proxy_service,
-                          SSLConfigService* ssl_config_service);
+  ClientSocketPoolManager();
   virtual ~ClientSocketPoolManager();
 
-  void FlushSocketPools();
-  void CloseIdleSockets();
-
-  TransportClientSocketPool* transport_socket_pool() {
-    return transport_socket_pool_.get();
-  }
-
-  SSLClientSocketPool* ssl_socket_pool() { return ssl_socket_pool_.get(); }
-
-  SOCKSClientSocketPool* GetSocketPoolForSOCKSProxy(
-      const HostPortPair& socks_proxy);
-
-  HttpProxyClientSocketPool* GetSocketPoolForHTTPProxy(
-      const HostPortPair& http_proxy);
-
-  SSLClientSocketPool* GetSocketPoolForSSLWithProxy(
-      const HostPortPair& proxy_server);
-
   // The setter methods below affect only newly created socket pools after the
   // methods are called. Normally they should be called at program startup
-  // before any ClientSocketPoolManager is created.
-  NET_EXPORT static void set_max_sockets_per_pool(int socket_count);
-  NET_EXPORT static int max_sockets_per_group();
-  NET_EXPORT static void set_max_sockets_per_group(int socket_count);
-  NET_EXPORT static void set_max_sockets_per_proxy_server(int socket_count);
-
-  // A helper method that uses the passed in proxy information to initialize a
-  // ClientSocketHandle with the relevant socket pool. Use this method for
-  // HTTP/HTTPS requests. |ssl_config_for_origin| is only used if the request
-  // uses SSL and |ssl_config_for_proxy| is used if the proxy server is HTTPS.
-  static int InitSocketHandleForHttpRequest(
-      const GURL& request_url,
-      const HttpRequestHeaders& request_extra_headers,
-      int request_load_flags,
-      RequestPriority request_priority,
-      HttpNetworkSession* session,
-      const ProxyInfo& proxy_info,
-      bool force_spdy_over_ssl,
-      bool want_spdy_over_npn,
-      const SSLConfig& ssl_config_for_origin,
-      const SSLConfig& ssl_config_for_proxy,
-      const BoundNetLog& net_log,
-      ClientSocketHandle* socket_handle,
-      OldCompletionCallback* callback);
-
-  // A helper method that uses the passed in proxy information to initialize a
-  // ClientSocketHandle with the relevant socket pool. Use this method for
-  // a raw socket connection to a host-port pair (that needs to tunnel through
-  // the proxies).
-  NET_EXPORT static int InitSocketHandleForRawConnect(
-      const HostPortPair& host_port_pair,
-      HttpNetworkSession* session,
-      const ProxyInfo& proxy_info,
-      const SSLConfig& ssl_config_for_origin,
-      const SSLConfig& ssl_config_for_proxy,
-      const BoundNetLog& net_log,
-      ClientSocketHandle* socket_handle,
-      OldCompletionCallback* callback);
-
-  // Similar to InitSocketHandleForHttpRequest except that it initiates the
-  // desired number of preconnect streams from the relevant socket pool.
-  static int PreconnectSocketsForHttpRequest(
-      const GURL& request_url,
-      const HttpRequestHeaders& request_extra_headers,
-      int request_load_flags,
-      RequestPriority request_priority,
-      HttpNetworkSession* session,
-      const ProxyInfo& proxy_info,
-      bool force_spdy_over_ssl,
-      bool want_spdy_over_npn,
-      const SSLConfig& ssl_config_for_origin,
-      const SSLConfig& ssl_config_for_proxy,
-      const BoundNetLog& net_log,
-      int num_preconnect_streams);
-
+  // before any ClientSocketPoolManagerImpl is created.
+  static int max_sockets_per_pool();
+  static void set_max_sockets_per_pool(int socket_count);
+
+  static int max_sockets_per_group();
+  static void set_max_sockets_per_group(int socket_count);
+
+  static int max_sockets_per_proxy_server();
+  static void set_max_sockets_per_proxy_server(int socket_count);
+
+  virtual void FlushSocketPools() = 0;
+  virtual void CloseIdleSockets() = 0;
+  virtual TransportClientSocketPool* GetTransportSocketPool() = 0;
+  virtual SSLClientSocketPool* GetSSLSocketPool() = 0;
+  virtual SOCKSClientSocketPool* GetSocketPoolForSOCKSProxy(
+      const HostPortPair& socks_proxy) = 0;
+  virtual HttpProxyClientSocketPool* GetSocketPoolForHTTPProxy(
+      const HostPortPair& http_proxy) = 0;
+  virtual SSLClientSocketPool* GetSocketPoolForSSLWithProxy(
+      const HostPortPair& proxy_server) = 0;
   // Creates a Value summary of the state of the socket pools. The caller is
   // responsible for deleting the returned value.
-  base::Value* SocketPoolInfoToValue() const;
-
-  // CertDatabase::Observer methods:
-  virtual void OnUserCertAdded(const X509Certificate* cert) OVERRIDE;
-  virtual void OnCertTrustChanged(const X509Certificate* cert) OVERRIDE;
-
- private:
-  friend class HttpNetworkSessionPeer;
-
-  typedef internal::OwnedPoolMap<HostPortPair, TransportClientSocketPool*>
-      TransportSocketPoolMap;
-  typedef internal::OwnedPoolMap<HostPortPair, SOCKSClientSocketPool*>
-      SOCKSSocketPoolMap;
-  typedef internal::OwnedPoolMap<HostPortPair, HttpProxyClientSocketPool*>
-      HTTPProxySocketPoolMap;
-  typedef internal::OwnedPoolMap<HostPortPair, SSLClientSocketPool*>
-      SSLSocketPoolMap;
-
-  NetLog* const net_log_;
-  ClientSocketFactory* const socket_factory_;
-  HostResolver* const host_resolver_;
-  CertVerifier* const cert_verifier_;
-  OriginBoundCertService* const origin_bound_cert_service_;
-  DnsRRResolver* const dnsrr_resolver_;
-  DnsCertProvenanceChecker* const dns_cert_checker_;
-  SSLHostInfoFactory* const ssl_host_info_factory_;
-  ProxyService* const proxy_service_;
-  const scoped_refptr<SSLConfigService> ssl_config_service_;
-
-  // Note: this ordering is important.
-
-  ClientSocketPoolHistograms transport_pool_histograms_;
-  scoped_ptr<TransportClientSocketPool> transport_socket_pool_;
-
-  ClientSocketPoolHistograms ssl_pool_histograms_;
-  scoped_ptr<SSLClientSocketPool> ssl_socket_pool_;
-
-  ClientSocketPoolHistograms transport_for_socks_pool_histograms_;
-  TransportSocketPoolMap transport_socket_pools_for_socks_proxies_;
-
-  ClientSocketPoolHistograms socks_pool_histograms_;
-  SOCKSSocketPoolMap socks_socket_pools_;
-
-  ClientSocketPoolHistograms transport_for_http_proxy_pool_histograms_;
-  TransportSocketPoolMap transport_socket_pools_for_http_proxies_;
-
-  ClientSocketPoolHistograms transport_for_https_proxy_pool_histograms_;
-  TransportSocketPoolMap transport_socket_pools_for_https_proxies_;
-
-  ClientSocketPoolHistograms ssl_for_https_proxy_pool_histograms_;
-  SSLSocketPoolMap ssl_socket_pools_for_https_proxies_;
-
-  ClientSocketPoolHistograms http_proxy_pool_histograms_;
-  HTTPProxySocketPoolMap http_proxy_socket_pools_;
-
-  ClientSocketPoolHistograms ssl_socket_pool_for_proxies_histograms_;
-  SSLSocketPoolMap ssl_socket_pools_for_proxies_;
-
-  DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolManager);
+  virtual base::Value* SocketPoolInfoToValue() const = 0;
 };
 
+// A helper method that uses the passed in proxy information to initialize a
+// ClientSocketHandle with the relevant socket pool. Use this method for
+// HTTP/HTTPS requests. |ssl_config_for_origin| is only used if the request
+// uses SSL and |ssl_config_for_proxy| is used if the proxy server is HTTPS.
+int InitSocketHandleForHttpRequest(
+    const GURL& request_url,
+    const HttpRequestHeaders& request_extra_headers,
+    int request_load_flags,
+    RequestPriority request_priority,
+    HttpNetworkSession* session,
+    const ProxyInfo& proxy_info,
+    bool force_spdy_over_ssl,
+    bool want_spdy_over_npn,
+    const SSLConfig& ssl_config_for_origin,
+    const SSLConfig& ssl_config_for_proxy,
+    const BoundNetLog& net_log,
+    ClientSocketHandle* socket_handle,
+    OldCompletionCallback* callback);
+
+// A helper method that uses the passed in proxy information to initialize a
+// ClientSocketHandle with the relevant socket pool. Use this method for
+// a raw socket connection to a host-port pair (that needs to tunnel through
+// the proxies).
+NET_EXPORT int InitSocketHandleForRawConnect(
+    const HostPortPair& host_port_pair,
+    HttpNetworkSession* session,
+    const ProxyInfo& proxy_info,
+    const SSLConfig& ssl_config_for_origin,
+    const SSLConfig& ssl_config_for_proxy,
+    const BoundNetLog& net_log,
+    ClientSocketHandle* socket_handle,
+    OldCompletionCallback* callback);
+
+// Similar to InitSocketHandleForHttpRequest except that it initiates the
+// desired number of preconnect streams from the relevant socket pool.
+int PreconnectSocketsForHttpRequest(
+    const GURL& request_url,
+    const HttpRequestHeaders& request_extra_headers,
+    int request_load_flags,
+    RequestPriority request_priority,
+    HttpNetworkSession* session,
+    const ProxyInfo& proxy_info,
+    bool force_spdy_over_ssl,
+    bool want_spdy_over_npn,
+    const SSLConfig& ssl_config_for_origin,
+    const SSLConfig& ssl_config_for_proxy,
+    const BoundNetLog& net_log,
+    int num_preconnect_streams);
+
 }  // namespace net
 
 #endif  // NET_SOCKET_CLIENT_SOCKET_POOL_MANAGER_H_
diff --git a/net/socket/client_socket_pool_manager_impl.cc b/net/socket/client_socket_pool_manager_impl.cc
new file mode 100644
index 0000000..3626ec7
--- /dev/null
+++ b/net/socket/client_socket_pool_manager_impl.cc
@@ -0,0 +1,394 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/socket/client_socket_pool_manager_impl.h"
+
+#include "base/logging.h"
+#include "base/values.h"
+#include "net/base/ssl_config_service.h"
+#include "net/http/http_proxy_client_socket_pool.h"
+#include "net/socket/socks_client_socket_pool.h"
+#include "net/socket/ssl_client_socket_pool.h"
+#include "net/socket/transport_client_socket_pool.h"
+
+namespace net {
+
+namespace {
+
+// Appends information about all |socket_pools| to the end of |list|.
+template <class MapType>
+void AddSocketPoolsToList(ListValue* list,
+                          const MapType& socket_pools,
+                          const std::string& type,
+                          bool include_nested_pools) {
+  for (typename MapType::const_iterator it = socket_pools.begin();
+       it != socket_pools.end(); it++) {
+    list->Append(it->second->GetInfoAsValue(it->first.ToString(),
+                                            type,
+                                            include_nested_pools));
+  }
+}
+
+}  // namespace
+
+ClientSocketPoolManagerImpl::ClientSocketPoolManagerImpl(
+    NetLog* net_log,
+    ClientSocketFactory* socket_factory,
+    HostResolver* host_resolver,
+    CertVerifier* cert_verifier,
+    OriginBoundCertService* origin_bound_cert_service,
+    DnsRRResolver* dnsrr_resolver,
+    DnsCertProvenanceChecker* dns_cert_checker,
+    SSLHostInfoFactory* ssl_host_info_factory,
+    ProxyService* proxy_service,
+    SSLConfigService* ssl_config_service)
+    : net_log_(net_log),
+      socket_factory_(socket_factory),
+      host_resolver_(host_resolver),
+      cert_verifier_(cert_verifier),
+      origin_bound_cert_service_(origin_bound_cert_service),
+      dnsrr_resolver_(dnsrr_resolver),
+      dns_cert_checker_(dns_cert_checker),
+      ssl_host_info_factory_(ssl_host_info_factory),
+      proxy_service_(proxy_service),
+      ssl_config_service_(ssl_config_service),
+      transport_pool_histograms_("TCP"),
+      transport_socket_pool_(new TransportClientSocketPool(
+          max_sockets_per_pool(), max_sockets_per_group(),
+          &transport_pool_histograms_,
+          host_resolver,
+          socket_factory_,
+          net_log)),
+      ssl_pool_histograms_("SSL2"),
+      ssl_socket_pool_(new SSLClientSocketPool(
+          max_sockets_per_pool(), max_sockets_per_group(),
+          &ssl_pool_histograms_,
+          host_resolver,
+          cert_verifier,
+          origin_bound_cert_service,
+          dnsrr_resolver,
+          dns_cert_checker,
+          ssl_host_info_factory,
+          socket_factory,
+          transport_socket_pool_.get(),
+          NULL /* no socks proxy */,
+          NULL /* no http proxy */,
+          ssl_config_service,
+          net_log)),
+      transport_for_socks_pool_histograms_("TCPforSOCKS"),
+      socks_pool_histograms_("SOCK"),
+      transport_for_http_proxy_pool_histograms_("TCPforHTTPProxy"),
+      transport_for_https_proxy_pool_histograms_("TCPforHTTPSProxy"),
+      ssl_for_https_proxy_pool_histograms_("SSLforHTTPSProxy"),
+      http_proxy_pool_histograms_("HTTPProxy"),
+      ssl_socket_pool_for_proxies_histograms_("SSLForProxies") {
+  CertDatabase::AddObserver(this);
+}
+
+ClientSocketPoolManagerImpl::~ClientSocketPoolManagerImpl() {
+  CertDatabase::RemoveObserver(this);
+}
+
+void ClientSocketPoolManagerImpl::FlushSocketPools() {
+  // Flush the highest level pools first, since higher level pools may release
+  // stuff to the lower level pools.
+
+  for (SSLSocketPoolMap::const_iterator it =
+       ssl_socket_pools_for_proxies_.begin();
+       it != ssl_socket_pools_for_proxies_.end();
+       ++it)
+    it->second->Flush();
+
+  for (HTTPProxySocketPoolMap::const_iterator it =
+       http_proxy_socket_pools_.begin();
+       it != http_proxy_socket_pools_.end();
+       ++it)
+    it->second->Flush();
+
+  for (SSLSocketPoolMap::const_iterator it =
+       ssl_socket_pools_for_https_proxies_.begin();
+       it != ssl_socket_pools_for_https_proxies_.end();
+       ++it)
+    it->second->Flush();
+
+  for (TransportSocketPoolMap::const_iterator it =
+       transport_socket_pools_for_https_proxies_.begin();
+       it != transport_socket_pools_for_https_proxies_.end();
+       ++it)
+    it->second->Flush();
+
+  for (TransportSocketPoolMap::const_iterator it =
+       transport_socket_pools_for_http_proxies_.begin();
+       it != transport_socket_pools_for_http_proxies_.end();
+       ++it)
+    it->second->Flush();
+
+  for (SOCKSSocketPoolMap::const_iterator it =
+       socks_socket_pools_.begin();
+       it != socks_socket_pools_.end();
+       ++it)
+    it->second->Flush();
+
+  for (TransportSocketPoolMap::const_iterator it =
+       transport_socket_pools_for_socks_proxies_.begin();
+       it != transport_socket_pools_for_socks_proxies_.end();
+       ++it)
+    it->second->Flush();
+
+  ssl_socket_pool_->Flush();
+  transport_socket_pool_->Flush();
+}
+
+void ClientSocketPoolManagerImpl::CloseIdleSockets() {
+  // Close sockets in the highest level pools first, since higher level pools'
+  // sockets may release stuff to the lower level pools.
+  for (SSLSocketPoolMap::const_iterator it =
+       ssl_socket_pools_for_proxies_.begin();
+       it != ssl_socket_pools_for_proxies_.end();
+       ++it)
+    it->second->CloseIdleSockets();
+
+  for (HTTPProxySocketPoolMap::const_iterator it =
+       http_proxy_socket_pools_.begin();
+       it != http_proxy_socket_pools_.end();
+       ++it)
+    it->second->CloseIdleSockets();
+
+  for (SSLSocketPoolMap::const_iterator it =
+       ssl_socket_pools_for_https_proxies_.begin();
+       it != ssl_socket_pools_for_https_proxies_.end();
+       ++it)
+    it->second->CloseIdleSockets();
+
+  for (TransportSocketPoolMap::const_iterator it =
+       transport_socket_pools_for_https_proxies_.begin();
+       it != transport_socket_pools_for_https_proxies_.end();
+       ++it)
+    it->second->CloseIdleSockets();
+
+  for (TransportSocketPoolMap::const_iterator it =
+       transport_socket_pools_for_http_proxies_.begin();
+       it != transport_socket_pools_for_http_proxies_.end();
+       ++it)
+    it->second->CloseIdleSockets();
+
+  for (SOCKSSocketPoolMap::const_iterator it =
+       socks_socket_pools_.begin();
+       it != socks_socket_pools_.end();
+       ++it)
+    it->second->CloseIdleSockets();
+
+  for (TransportSocketPoolMap::const_iterator it =
+       transport_socket_pools_for_socks_proxies_.begin();
+       it != transport_socket_pools_for_socks_proxies_.end();
+       ++it)
+    it->second->CloseIdleSockets();
+
+  ssl_socket_pool_->CloseIdleSockets();
+  transport_socket_pool_->CloseIdleSockets();
+}
+
+TransportClientSocketPool*
+ClientSocketPoolManagerImpl::GetTransportSocketPool() {
+  return transport_socket_pool_.get();
+}
+
+SSLClientSocketPool* ClientSocketPoolManagerImpl::GetSSLSocketPool() {
+  return ssl_socket_pool_.get();
+}
+
+SOCKSClientSocketPool* ClientSocketPoolManagerImpl::GetSocketPoolForSOCKSProxy(
+    const HostPortPair& socks_proxy) {
+  SOCKSSocketPoolMap::const_iterator it = socks_socket_pools_.find(socks_proxy);
+  if (it != socks_socket_pools_.end()) {
+    DCHECK(ContainsKey(transport_socket_pools_for_socks_proxies_, socks_proxy));
+    return it->second;
+  }
+
+  DCHECK(!ContainsKey(transport_socket_pools_for_socks_proxies_, socks_proxy));
+
+  std::pair<TransportSocketPoolMap::iterator, bool> tcp_ret =
+      transport_socket_pools_for_socks_proxies_.insert(
+          std::make_pair(
+              socks_proxy,
+              new TransportClientSocketPool(
+                  max_sockets_per_proxy_server(),
+                  max_sockets_per_group(),
+                  &transport_for_socks_pool_histograms_,
+                  host_resolver_,
+                  socket_factory_,
+                  net_log_)));
+  DCHECK(tcp_ret.second);
+
+  std::pair<SOCKSSocketPoolMap::iterator, bool> ret =
+      socks_socket_pools_.insert(
+          std::make_pair(socks_proxy, new SOCKSClientSocketPool(
+              max_sockets_per_proxy_server(),
+              max_sockets_per_group(),
+              &socks_pool_histograms_,
+              host_resolver_,
+              tcp_ret.first->second,
+              net_log_)));
+
+  return ret.first->second;
+}
+
+HttpProxyClientSocketPool*
+ClientSocketPoolManagerImpl::GetSocketPoolForHTTPProxy(
+    const HostPortPair& http_proxy) {
+  HTTPProxySocketPoolMap::const_iterator it =
+      http_proxy_socket_pools_.find(http_proxy);
+  if (it != http_proxy_socket_pools_.end()) {
+    DCHECK(ContainsKey(transport_socket_pools_for_http_proxies_, http_proxy));
+    DCHECK(ContainsKey(transport_socket_pools_for_https_proxies_, http_proxy));
+    DCHECK(ContainsKey(ssl_socket_pools_for_https_proxies_, http_proxy));
+    return it->second;
+  }
+
+  DCHECK(!ContainsKey(transport_socket_pools_for_http_proxies_, http_proxy));
+  DCHECK(!ContainsKey(transport_socket_pools_for_https_proxies_, http_proxy));
+  DCHECK(!ContainsKey(ssl_socket_pools_for_https_proxies_, http_proxy));
+
+  std::pair<TransportSocketPoolMap::iterator, bool> tcp_http_ret =
+      transport_socket_pools_for_http_proxies_.insert(
+          std::make_pair(
+              http_proxy,
+              new TransportClientSocketPool(
+                  max_sockets_per_proxy_server(),
+                  max_sockets_per_group(),
+                  &transport_for_http_proxy_pool_histograms_,
+                  host_resolver_,
+                  socket_factory_,
+                  net_log_)));
+  DCHECK(tcp_http_ret.second);
+
+  std::pair<TransportSocketPoolMap::iterator, bool> tcp_https_ret =
+      transport_socket_pools_for_https_proxies_.insert(
+          std::make_pair(
+              http_proxy,
+              new TransportClientSocketPool(
+                  max_sockets_per_proxy_server(),
+                  max_sockets_per_group(),
+                  &transport_for_https_proxy_pool_histograms_,
+                  host_resolver_,
+                  socket_factory_,
+                  net_log_)));
+  DCHECK(tcp_https_ret.second);
+
+  std::pair<SSLSocketPoolMap::iterator, bool> ssl_https_ret =
+      ssl_socket_pools_for_https_proxies_.insert(
+          std::make_pair(
+              http_proxy,
+              new SSLClientSocketPool(
+                  max_sockets_per_proxy_server(),
+                  max_sockets_per_group(),
+                  &ssl_for_https_proxy_pool_histograms_,
+                  host_resolver_,
+                  cert_verifier_,
+                  origin_bound_cert_service_,
+                  dnsrr_resolver_,
+                  dns_cert_checker_,
+                  ssl_host_info_factory_,
+                  socket_factory_,
+                  tcp_https_ret.first->second /* https proxy */,
+                  NULL /* no socks proxy */,
+                  NULL /* no http proxy */,
+                  ssl_config_service_, net_log_)));
+  DCHECK(tcp_https_ret.second);
+
+  std::pair<HTTPProxySocketPoolMap::iterator, bool> ret =
+      http_proxy_socket_pools_.insert(
+          std::make_pair(
+              http_proxy,
+              new HttpProxyClientSocketPool(
+                  max_sockets_per_proxy_server(),
+                  max_sockets_per_group(),
+                  &http_proxy_pool_histograms_,
+                  host_resolver_,
+                  tcp_http_ret.first->second,
+                  ssl_https_ret.first->second,
+                  net_log_)));
+
+  return ret.first->second;
+}
+
+SSLClientSocketPool* ClientSocketPoolManagerImpl::GetSocketPoolForSSLWithProxy(
+    const HostPortPair& proxy_server) {
+  SSLSocketPoolMap::const_iterator it =
+      ssl_socket_pools_for_proxies_.find(proxy_server);
+  if (it != ssl_socket_pools_for_proxies_.end())
+    return it->second;
+
+  SSLClientSocketPool* new_pool = new SSLClientSocketPool(
+      max_sockets_per_proxy_server(), max_sockets_per_group(),
+      &ssl_pool_histograms_,
+      host_resolver_,
+      cert_verifier_,
+      origin_bound_cert_service_,
+      dnsrr_resolver_,
+      dns_cert_checker_,
+      ssl_host_info_factory_,
+      socket_factory_,
+      NULL, /* no tcp pool, we always go through a proxy */
+      GetSocketPoolForSOCKSProxy(proxy_server),
+      GetSocketPoolForHTTPProxy(proxy_server),
+      ssl_config_service_,
+      net_log_);
+
+  std::pair<SSLSocketPoolMap::iterator, bool> ret =
+      ssl_socket_pools_for_proxies_.insert(std::make_pair(proxy_server,
+                                                          new_pool));
+
+  return ret.first->second;
+}
+
+Value* ClientSocketPoolManagerImpl::SocketPoolInfoToValue() const {
+  ListValue* list = new ListValue();
+  list->Append(transport_socket_pool_->GetInfoAsValue("transport_socket_pool",
+                                                "transport_socket_pool",
+                                                false));
+  // Third parameter is false because |ssl_socket_pool_| uses
+  // |transport_socket_pool_| internally, and do not want to add it a second
+  // time.
+  list->Append(ssl_socket_pool_->GetInfoAsValue("ssl_socket_pool",
+                                                "ssl_socket_pool",
+                                                false));
+  AddSocketPoolsToList(list,
+                       http_proxy_socket_pools_,
+                       "http_proxy_socket_pool",
+                       true);
+  AddSocketPoolsToList(list,
+                       socks_socket_pools_,
+                       "socks_socket_pool",
+                       true);
+
+  // Third parameter is false because |ssl_socket_pools_for_proxies_| use
+  // socket pools in |http_proxy_socket_pools_| and |socks_socket_pools_|.
+  AddSocketPoolsToList(list,
+                       ssl_socket_pools_for_proxies_,
+                       "ssl_socket_pool_for_proxies",
+                       false);
+  return list;
+}
+
+void ClientSocketPoolManagerImpl::OnUserCertAdded(const X509Certificate* cert) {
+  FlushSocketPools();
+}
+
+void ClientSocketPoolManagerImpl::OnCertTrustChanged(
+    const X509Certificate* cert) {
+  // We should flush the socket pools if we removed trust from a
+  // cert, because a previously trusted server may have become
+  // untrusted.
+  //
+  // We should not flush the socket pools if we added trust to a
+  // cert.
+  //
+  // Since the OnCertTrustChanged method doesn't tell us what
+  // kind of trust change it is, we have to flush the socket
+  // pools to be safe.
+  FlushSocketPools();
+}
+
+}  // namespace net
diff --git a/net/socket/client_socket_pool_manager_impl.h b/net/socket/client_socket_pool_manager_impl.h
new file mode 100644
index 0000000..554cfcb
--- /dev/null
+++ b/net/socket/client_socket_pool_manager_impl.h
@@ -0,0 +1,152 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef NET_SOCKET_CLIENT_SOCKET_POOL_MANAGER_IMPL_H_
+#define NET_SOCKET_CLIENT_SOCKET_POOL_MANAGER_IMPL_H_
+#pragma once
+
+#include <map>
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/stl_util.h"
+#include "base/template_util.h"
+#include "base/threading/non_thread_safe.h"
+#include "net/base/cert_database.h"
+#include "net/socket/client_socket_pool_histograms.h"
+#include "net/socket/client_socket_pool_manager.h"
+
+namespace net {
+
+class CertVerifier;
+class ClientSocketFactory;
+class ClientSocketPoolHistograms;
+class DnsCertProvenanceChecker;
+class DnsRRResolver;
+class HttpProxyClientSocketPool;
+class HostResolver;
+class NetLog;
+class OriginBoundCertService;
+class ProxyService;
+class SOCKSClientSocketPool;
+class SSLClientSocketPool;
+class SSLConfigService;
+class SSLHostInfoFactory;
+class TransportClientSocketPool;
+
+namespace internal {
+
+// A helper class for auto-deleting Values in the destructor.
+template <typename Key, typename Value>
+class OwnedPoolMap : public std::map<Key, Value> {
+ public:
+  OwnedPoolMap() {
+    COMPILE_ASSERT(base::is_pointer<Value>::value,
+                   value_must_be_a_pointer);
+  }
+
+  ~OwnedPoolMap() {
+    STLDeleteValues(this);
+  }
+};
+
+}  // namespace internal
+
+class ClientSocketPoolManagerImpl : public base::NonThreadSafe,
+                                    public ClientSocketPoolManager,
+                                    public CertDatabase::Observer {
+ public:
+  ClientSocketPoolManagerImpl(NetLog* net_log,
+                              ClientSocketFactory* socket_factory,
+                              HostResolver* host_resolver,
+                              CertVerifier* cert_verifier,
+                              OriginBoundCertService* origin_bound_cert_service,
+                              DnsRRResolver* dnsrr_resolver,
+                              DnsCertProvenanceChecker* dns_cert_checker,
+                              SSLHostInfoFactory* ssl_host_info_factory,
+                              ProxyService* proxy_service,
+                              SSLConfigService* ssl_config_service);
+  virtual ~ClientSocketPoolManagerImpl();
+
+  virtual void FlushSocketPools() OVERRIDE;
+  virtual void CloseIdleSockets() OVERRIDE;
+
+  virtual TransportClientSocketPool* GetTransportSocketPool() OVERRIDE;
+
+  virtual SSLClientSocketPool* GetSSLSocketPool() OVERRIDE;
+
+  virtual SOCKSClientSocketPool* GetSocketPoolForSOCKSProxy(
+      const HostPortPair& socks_proxy) OVERRIDE;
+
+  virtual HttpProxyClientSocketPool* GetSocketPoolForHTTPProxy(
+      const HostPortPair& http_proxy) OVERRIDE;
+
+  virtual SSLClientSocketPool* GetSocketPoolForSSLWithProxy(
+      const HostPortPair& proxy_server) OVERRIDE;
+
+  // Creates a Value summary of the state of the socket pools. The caller is
+  // responsible for deleting the returned value.
+  virtual base::Value* SocketPoolInfoToValue() const OVERRIDE;
+
+  // CertDatabase::Observer methods:
+  virtual void OnUserCertAdded(const X509Certificate* cert) OVERRIDE;
+  virtual void OnCertTrustChanged(const X509Certificate* cert) OVERRIDE;
+
+ private:
+  typedef internal::OwnedPoolMap<HostPortPair, TransportClientSocketPool*>
+      TransportSocketPoolMap;
+  typedef internal::OwnedPoolMap<HostPortPair, SOCKSClientSocketPool*>
+      SOCKSSocketPoolMap;
+  typedef internal::OwnedPoolMap<HostPortPair, HttpProxyClientSocketPool*>
+      HTTPProxySocketPoolMap;
+  typedef internal::OwnedPoolMap<HostPortPair, SSLClientSocketPool*>
+      SSLSocketPoolMap;
+
+  NetLog* const net_log_;
+  ClientSocketFactory* const socket_factory_;
+  HostResolver* const host_resolver_;
+  CertVerifier* const cert_verifier_;
+  OriginBoundCertService* const origin_bound_cert_service_;
+  DnsRRResolver* const dnsrr_resolver_;
+  DnsCertProvenanceChecker* const dns_cert_checker_;
+  SSLHostInfoFactory* const ssl_host_info_factory_;
+  ProxyService* const proxy_service_;
+  const scoped_refptr<SSLConfigService> ssl_config_service_;
+
+  // Note: this ordering is important.
+
+  ClientSocketPoolHistograms transport_pool_histograms_;
+  scoped_ptr<TransportClientSocketPool> transport_socket_pool_;
+
+  ClientSocketPoolHistograms ssl_pool_histograms_;
+  scoped_ptr<SSLClientSocketPool> ssl_socket_pool_;
+
+  ClientSocketPoolHistograms transport_for_socks_pool_histograms_;
+  TransportSocketPoolMap transport_socket_pools_for_socks_proxies_;
+
+  ClientSocketPoolHistograms socks_pool_histograms_;
+  SOCKSSocketPoolMap socks_socket_pools_;
+
+  ClientSocketPoolHistograms transport_for_http_proxy_pool_histograms_;
+  TransportSocketPoolMap transport_socket_pools_for_http_proxies_;
+
+  ClientSocketPoolHistograms transport_for_https_proxy_pool_histograms_;
+  TransportSocketPoolMap transport_socket_pools_for_https_proxies_;
+
+  ClientSocketPoolHistograms ssl_for_https_proxy_pool_histograms_;
+  SSLSocketPoolMap ssl_socket_pools_for_https_proxies_;
+
+  ClientSocketPoolHistograms http_proxy_pool_histograms_;
+  HTTPProxySocketPoolMap http_proxy_socket_pools_;
+
+  ClientSocketPoolHistograms ssl_socket_pool_for_proxies_histograms_;
+  SSLSocketPoolMap ssl_socket_pools_for_proxies_;
+
+  DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolManagerImpl);
+};
+
+}  // namespace net
+
+#endif  // NET_SOCKET_CLIENT_SOCKET_POOL_MANAGER_IMPL_H_
diff --git a/net/socket/mock_client_socket_pool_manager.cc b/net/socket/mock_client_socket_pool_manager.cc
new file mode 100644
index 0000000..717a0ae
--- /dev/null
+++ b/net/socket/mock_client_socket_pool_manager.cc
@@ -0,0 +1,94 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/socket/mock_client_socket_pool_manager.h"
+
+#include "net/http/http_proxy_client_socket_pool.h"
+#include "net/socket/socks_client_socket_pool.h"
+#include "net/socket/ssl_client_socket_pool.h"
+#include "net/socket/transport_client_socket_pool.h"
+
+namespace net {
+
+MockClientSocketPoolManager::MockClientSocketPoolManager() {}
+MockClientSocketPoolManager::~MockClientSocketPoolManager() {}
+
+void MockClientSocketPoolManager::SetTransportSocketPool(
+    TransportClientSocketPool* pool) {
+  transport_socket_pool_.reset(pool);
+}
+
+void MockClientSocketPoolManager::SetSSLSocketPool(
+    SSLClientSocketPool* pool) {
+  ssl_socket_pool_.reset(pool);
+}
+
+void MockClientSocketPoolManager::SetSocketPoolForSOCKSProxy(
+    const HostPortPair& socks_proxy,
+    SOCKSClientSocketPool* pool) {
+  socks_socket_pools_[socks_proxy] = pool;
+}
+
+void MockClientSocketPoolManager::SetSocketPoolForHTTPProxy(
+    const HostPortPair& http_proxy,
+    HttpProxyClientSocketPool* pool) {
+  http_proxy_socket_pools_[http_proxy] = pool;
+}
+
+void MockClientSocketPoolManager::SetSocketPoolForSSLWithProxy(
+    const HostPortPair& proxy_server,
+    SSLClientSocketPool* pool) {
+  ssl_socket_pools_for_proxies_[proxy_server] = pool;
+}
+
+void MockClientSocketPoolManager::FlushSocketPools() {
+  NOTIMPLEMENTED();
+}
+
+void MockClientSocketPoolManager::CloseIdleSockets() {
+  NOTIMPLEMENTED();
+}
+
+TransportClientSocketPool*
+MockClientSocketPoolManager::GetTransportSocketPool() {
+  return transport_socket_pool_.get();
+}
+
+SSLClientSocketPool* MockClientSocketPoolManager::GetSSLSocketPool() {
+  return ssl_socket_pool_.get();
+}
+
+SOCKSClientSocketPool* MockClientSocketPoolManager::GetSocketPoolForSOCKSProxy(
+    const HostPortPair& socks_proxy) {
+  SOCKSSocketPoolMap::const_iterator it = socks_socket_pools_.find(socks_proxy);
+  if (it != socks_socket_pools_.end())
+    return it->second;
+  return NULL;
+}
+
+HttpProxyClientSocketPool*
+MockClientSocketPoolManager::GetSocketPoolForHTTPProxy(
+    const HostPortPair& http_proxy) {
+  HTTPProxySocketPoolMap::const_iterator it =
+      http_proxy_socket_pools_.find(http_proxy);
+  if (it != http_proxy_socket_pools_.end())
+    return it->second;
+  return NULL;
+}
+
+SSLClientSocketPool* MockClientSocketPoolManager::GetSocketPoolForSSLWithProxy(
+    const HostPortPair& proxy_server) {
+  SSLSocketPoolMap::const_iterator it =
+      ssl_socket_pools_for_proxies_.find(proxy_server);
+  if (it != ssl_socket_pools_for_proxies_.end())
+    return it->second;
+  return NULL;
+}
+
+Value* MockClientSocketPoolManager::SocketPoolInfoToValue() const {
+  NOTIMPLEMENTED();
+  return NULL;
+}
+
+}  // namespace net
diff --git a/net/socket/mock_client_socket_pool_manager.h b/net/socket/mock_client_socket_pool_manager.h
new file mode 100644
index 0000000..cf8eceb
--- /dev/null
+++ b/net/socket/mock_client_socket_pool_manager.h
@@ -0,0 +1,64 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef NET_SOCKET_MOCK_CLIENT_SOCKET_POOL_MANAGER_H_
+#define NET_SOCKET_MOCK_CLIENT_SOCKET_POOL_MANAGER_H_
+#pragma once
+
+#include "base/basictypes.h"
+#include "net/socket/client_socket_pool_manager.h"
+#include "net/socket/client_socket_pool_manager_impl.h"
+
+namespace net {
+
+class MockClientSocketPoolManager : public ClientSocketPoolManager {
+ public:
+  MockClientSocketPoolManager();
+  virtual ~MockClientSocketPoolManager();
+
+  // Sets "override" socket pools that get used instead.
+  void SetTransportSocketPool(TransportClientSocketPool* pool);
+  void SetSSLSocketPool(SSLClientSocketPool* pool);
+  void SetSocketPoolForSOCKSProxy(const HostPortPair& socks_proxy,
+                                  SOCKSClientSocketPool* pool);
+  void SetSocketPoolForHTTPProxy(const HostPortPair& http_proxy,
+                                 HttpProxyClientSocketPool* pool);
+  void SetSocketPoolForSSLWithProxy(const HostPortPair& proxy_server,
+                                    SSLClientSocketPool* pool);
+
+  // ClientSocketPoolManager methods:
+  virtual void FlushSocketPools() OVERRIDE;
+  virtual void CloseIdleSockets() OVERRIDE;
+  virtual TransportClientSocketPool* GetTransportSocketPool() OVERRIDE;
+  virtual SSLClientSocketPool* GetSSLSocketPool() OVERRIDE;
+  virtual SOCKSClientSocketPool* GetSocketPoolForSOCKSProxy(
+      const HostPortPair& socks_proxy) OVERRIDE;
+  virtual HttpProxyClientSocketPool* GetSocketPoolForHTTPProxy(
+      const HostPortPair& http_proxy) OVERRIDE;
+  virtual SSLClientSocketPool* GetSocketPoolForSSLWithProxy(
+      const HostPortPair& proxy_server) OVERRIDE;
+  virtual base::Value* SocketPoolInfoToValue() const OVERRIDE;
+
+ private:
+  typedef internal::OwnedPoolMap<HostPortPair, TransportClientSocketPool*>
+      TransportSocketPoolMap;
+  typedef internal::OwnedPoolMap<HostPortPair, SOCKSClientSocketPool*>
+      SOCKSSocketPoolMap;
+  typedef internal::OwnedPoolMap<HostPortPair, HttpProxyClientSocketPool*>
+      HTTPProxySocketPoolMap;
+  typedef internal::OwnedPoolMap<HostPortPair, SSLClientSocketPool*>
+      SSLSocketPoolMap;
+
+  scoped_ptr<TransportClientSocketPool> transport_socket_pool_;
+  scoped_ptr<SSLClientSocketPool> ssl_socket_pool_;
+  SOCKSSocketPoolMap socks_socket_pools_;
+  HTTPProxySocketPoolMap http_proxy_socket_pools_;
+  SSLSocketPoolMap ssl_socket_pools_for_proxies_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockClientSocketPoolManager);
+};
+
+}  // namespace net
+
+#endif  // NET_SOCKET_MOCK_CLIENT_SOCKET_POOL_MANAGER_H_