Move a number of static variables SPDY to HttpNetworkSession::Params.

net/spdy/spdy_session_pool.cc

 // Copyright (c) 2012 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/spdy/spdy_session_pool.h"
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
@@ skipping 18 matching lines @@
 bool HostPortProxyPairsAreEqual(const HostPortProxyPair& a,
                                 const HostPortProxyPair& b) {
   return a.first.Equals(b.first) && a.second == b.second;
 }
 
 }
 
 // The maximum number of sessions to open to a single domain.
 static const size_t kMaxSessionsPerDomain = 1;
 
-size_t SpdySessionPool::g_max_sessions_per_domain = kMaxSessionsPerDomain;
-bool SpdySessionPool::g_force_single_domain = false;
-bool SpdySessionPool::g_enable_ip_pooling = true;
-
 SpdySessionPool::SpdySessionPool(
     HostResolver* resolver,
     SSLConfigService* ssl_config_service,
     HttpServerProperties* http_server_properties,
+    size_t max_sessions_per_domain,
+    bool force_single_domain,
+    bool enable_ip_pooling,
+    bool enable_credential_frames,
+    bool enable_compression,
+    bool enable_ping_based_connection_checking,
+    NextProto default_protocol,
+    size_t initial_recv_window_size,
+    size_t initial_max_concurrent_streams,
+    size_t max_concurrent_streams_limit,
+    SpdySessionPool::TimeFunc time_func,
     const std::string& trusted_spdy_proxy)
     : http_server_properties_(http_server_properties),
       ssl_config_service_(ssl_config_service),
       resolver_(resolver),
       verify_domain_authentication_(true),
       enable_sending_initial_settings_(true),
+      max_sessions_per_domain_(max_sessions_per_domain == 0 ?
+                               kMaxSessionsPerDomain :
+                               max_sessions_per_domain),
+      force_single_domain_(force_single_domain),
+      enable_ip_pooling_(enable_ip_pooling),
+      enable_credential_frames_(enable_credential_frames),
+      enable_compression_(enable_compression),
+      enable_ping_based_connection_checking_(
+          enable_ping_based_connection_checking),
+      default_protocol_(default_protocol),
+      initial_recv_window_size_(initial_recv_window_size),
+      initial_max_concurrent_streams_(initial_max_concurrent_streams),
+      max_concurrent_streams_limit_(max_concurrent_streams_limit),
+      time_func_(time_func),
       trusted_spdy_proxy_(
           HostPortPair::FromString(trusted_spdy_proxy)) {
   NetworkChangeNotifier::AddIPAddressObserver(this);
   if (ssl_config_service_)
     ssl_config_service_->AddObserver(this);
   CertDatabase::GetInstance()->AddObserver(this);
 }
 
 SpdySessionPool::~SpdySessionPool() {
   CloseAllSessions();
@@ skipping 37 matching lines @@
       list->push_back(spdy_session);
       spdy_session->AddPooledAlias(host_port_proxy_pair);
       return spdy_session;
     } else if (only_use_existing_sessions) {
       return NULL;
     }
     list = AddSessionList(host_port_proxy_pair);
   }
 
   DCHECK(list);
-  if (list->size() && list->size() == g_max_sessions_per_domain) {
+  if (list->size() && list->size() == max_sessions_per_domain_) {
     UMA_HISTOGRAM_ENUMERATION("Net.SpdySessionGet",
                               FOUND_EXISTING,
                               SPDY_SESSION_GET_MAX);
     spdy_session = GetExistingSession(list, net_log);
     net_log.AddEvent(
       NetLog::TYPE_SPDY_SESSION_POOL_FOUND_EXISTING_SESSION,
       spdy_session->net_log().source().ToEventParametersCallback());
     return spdy_session;
   }
 
   DCHECK(!only_use_existing_sessions);
 
   spdy_session = new SpdySession(host_port_proxy_pair, this,
                                  http_server_properties_,
                                  verify_domain_authentication_,
                                  enable_sending_initial_settings_,
+                                 enable_credential_frames_,
+                                 enable_compression_,
+                                 enable_ping_based_connection_checking_,
+                                 default_protocol_,
+                                 initial_recv_window_size_,
+                                 initial_max_concurrent_streams_,
+                                 max_concurrent_streams_limit_,
+                                 time_func_,
                                  trusted_spdy_proxy_,
                                  net_log.net_log());
   UMA_HISTOGRAM_ENUMERATION("Net.SpdySessionGet",
                             CREATED_NEW,
                             SPDY_SESSION_GET_MAX);
   list->push_back(spdy_session);
   net_log.AddEvent(
       NetLog::TYPE_SPDY_SESSION_POOL_CREATED_NEW_SESSION,
       spdy_session->net_log().source().ToEventParametersCallback());
-  DCHECK_LE(list->size(), g_max_sessions_per_domain);
+  DCHECK_LE(list->size(), max_sessions_per_domain_);
   return spdy_session;
 }
 
 net::Error SpdySessionPool::GetSpdySessionFromSocket(
     const HostPortProxyPair& host_port_proxy_pair,
     ClientSocketHandle* connection,
     const BoundNetLog& net_log,
     int certificate_error_code,
     scoped_refptr<SpdySession>* spdy_session,
     bool is_secure) {
   UMA_HISTOGRAM_ENUMERATION("Net.SpdySessionGet",
                             IMPORTED_FROM_SOCKET,
                             SPDY_SESSION_GET_MAX);
   // Create the SPDY session and add it to the pool.
   *spdy_session = new SpdySession(host_port_proxy_pair, this,
                                   http_server_properties_,
                                   verify_domain_authentication_,
                                   enable_sending_initial_settings_,
+                                  enable_credential_frames_,
+                                  enable_compression_,
+                                  enable_ping_based_connection_checking_,
+                                  default_protocol_,
+                                  initial_recv_window_size_,
+                                  initial_max_concurrent_streams_,
+                                  max_concurrent_streams_limit_,
+                                  time_func_,
                                   trusted_spdy_proxy_,
                                   net_log.net_log());
   SpdySessionList* list = GetSessionList(host_port_proxy_pair);
   if (!list)
     list = AddSessionList(host_port_proxy_pair);
   DCHECK(list->empty());
   list->push_back(*spdy_session);
 
   net_log.AddEvent(
       NetLog::TYPE_SPDY_SESSION_POOL_IMPORTED_SESSION_FROM_SOCKET,
       (*spdy_session)->net_log().source().ToEventParametersCallback());
 
   // We have a new session.  Lookup the IP address for this session so that we
   // can match future Sessions (potentially to different domains) which can
   // potentially be pooled with this one. Because GetPeerAddress() reports the
   // proxy's address instead of the origin server, check to see if this is a
   // direct connection.
-  if (g_enable_ip_pooling  && host_port_proxy_pair.second.is_direct()) {
+  if (enable_ip_pooling_  && host_port_proxy_pair.second.is_direct()) {
     IPEndPoint address;
     if (connection->socket()->GetPeerAddress(&address) == OK)
       AddAlias(address, host_port_proxy_pair);
   }
 
   // Now we can initialize the session with the SSL socket.
   return (*spdy_session)->InitializeWithSocket(connection, is_secure,
                                                certificate_error_code);
 }
 
@@ skipping 77 matching lines @@
   return spdy_session;
 }
 
 scoped_refptr<SpdySession> SpdySessionPool::GetFromAlias(
       const HostPortProxyPair& host_port_proxy_pair,
       const BoundNetLog& net_log,
       bool record_histograms) const {
   // We should only be checking aliases when there is no direct session.
   DCHECK(!GetSessionList(host_port_proxy_pair));
 
-  if (!g_enable_ip_pooling)
+  if (!enable_ip_pooling_)
     return NULL;
 
   AddressList addresses;
   if (!LookupAddresses(host_port_proxy_pair, net_log, &addresses))
     return NULL;
   for (AddressList::const_iterator iter = addresses.begin();
        iter != addresses.end();
        ++iter) {
     SpdyAliasMap::const_iterator alias_iter = aliases_.find(*iter);
     if (alias_iter == aliases_.end())
@@ skipping 35 matching lines @@
 void SpdySessionPool::OnCertTrustChanged(const X509Certificate* cert) {
   // Per wtc, we actually only need to CloseCurrentSessions when trust is
   // reduced. CloseCurrentSessions now because OnCertTrustChanged does not
   // tell us this.
   // See comments in ClientSocketPoolManager::OnCertTrustChanged.
   CloseCurrentSessions();
 }
 
 const HostPortProxyPair& SpdySessionPool::NormalizeListPair(
     const HostPortProxyPair& host_port_proxy_pair) const {
-  if (!g_force_single_domain)
+  if (!force_single_domain_)
     return host_port_proxy_pair;
 
   static HostPortProxyPair* single_domain_pair = NULL;
   if (!single_domain_pair) {
     HostPortPair single_domain = HostPortPair("singledomain.com", 80);
     single_domain_pair = new HostPortProxyPair(single_domain,
                                                ProxyServer::Direct());
   }
   return *single_domain_pair;
 }
@@ skipping 35 matching lines @@
                                       const BoundNetLog& net_log,
                                       AddressList* addresses) const {
   net::HostResolver::RequestInfo resolve_info(pair.first);
   int rv = resolver_->ResolveFromCache(resolve_info, addresses, net_log);
   DCHECK_NE(ERR_IO_PENDING, rv);
   return rv == OK;
 }
 
 void SpdySessionPool::AddAlias(const IPEndPoint& endpoint,
                                const HostPortProxyPair& pair) {
-  DCHECK(g_enable_ip_pooling);
+  DCHECK(enable_ip_pooling_);
   aliases_[endpoint] = pair;
 }
 
 void SpdySessionPool::RemoveAliases(const HostPortProxyPair& pair) {
   // Walk the aliases map, find references to this pair.
   // TODO(mbelshe):  Figure out if this is too expensive.
   SpdyAliasMap::iterator alias_it = aliases_.begin();
   while (alias_it != aliases_.end()) {
     if (HostPortProxyPairsAreEqual(alias_it->second, pair)) {
       aliases_.erase(alias_it);
@@ skipping 59 matching lines @@
     const scoped_refptr<SpdySession>& session = *session_it;
     CHECK(session);
     if (!session->is_active()) {
       session->CloseSessionOnError(
           net::ERR_ABORTED, true, "Closing idle sessions.");
     }
   }
 }
 
 }  // namespace net