Persist dynamically learned SPDY settings (like CWND).

net/spdy/spdy_session_pool.cc

 // 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/spdy/spdy_session_pool.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
 #include "net/base/address_list.h"
 #include "net/base/sys_addrinfo.h"
 #include "net/http/http_network_session.h"
+#include "net/http/http_server_properties.h"
 #include "net/spdy/spdy_session.h"
 
 
 namespace net {
 
 namespace {
 
 enum SpdySessionGetTypes {
   CREATED_NEW                 = 0,
   FOUND_EXISTING              = 1,
@@ skipping 10 matching lines @@
 }
 
 // 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)
-    : ssl_config_service_(ssl_config_service),
+                                 SSLConfigService* ssl_config_service,
+                                 HttpServerProperties* http_server_properties)
+    : http_server_properties_(http_server_properties),
+      ssl_config_service_(ssl_config_service),
       resolver_(resolver),
       verify_domain_authentication_(true) {
   NetworkChangeNotifier::AddIPAddressObserver(this);
   if (ssl_config_service_)
     ssl_config_service_->AddObserver(this);
   CertDatabase::AddObserver(this);
 }
 
 SpdySessionPool::~SpdySessionPool() {
   CloseAllSessions();
@@ skipping 48 matching lines @@
     spdy_session = GetExistingSession(list, net_log);
     net_log.AddEvent(
       NetLog::TYPE_SPDY_SESSION_POOL_FOUND_EXISTING_SESSION,
       make_scoped_refptr(new NetLogSourceParameter(
           "session", spdy_session->net_log().source())));
     return spdy_session;
   }
 
   DCHECK(!only_use_existing_sessions);
 
-  spdy_session = new SpdySession(host_port_proxy_pair, this, &spdy_settings_,
+  spdy_session = new SpdySession(host_port_proxy_pair, this,
+                                 http_server_properties_,
                                  verify_domain_authentication_,
                                  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,
       make_scoped_refptr(new NetLogSourceParameter(
           "session", spdy_session->net_log().source())));
   DCHECK_LE(list->size(), g_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, &spdy_settings_,
+  *spdy_session = new SpdySession(host_port_proxy_pair, this,
+                                  http_server_properties_,
                                   verify_domain_authentication_,
                                   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,
@@ skipping 50 matching lines @@
     for (SpdySessionList::const_iterator session = sessions->begin();
          session != sessions->end(); ++session) {
       list->Append(session->get()->GetInfoAsValue());
     }
   }
   return list;
 }
 
 void SpdySessionPool::OnIPAddressChanged() {
   CloseCurrentSessions();
-  spdy_settings_.Clear();
+  http_server_properties_->ClearSpdySettings();
 }
 
 void SpdySessionPool::OnSSLConfigChanged() {
   CloseCurrentSessions();
 }
 
 scoped_refptr<SpdySession> SpdySessionPool::GetExistingSession(
     SpdySessionList* list,
     const BoundNetLog& net_log) const {
   DCHECK(list);
@@ skipping 202 matching lines @@
     // Assumes there is only 1 element in the list
     SpdySessionList::iterator session_it = list->begin();
     const scoped_refptr<SpdySession>& session = *session_it;
     CHECK(session);
     if (!session->is_active())
       session->CloseSessionOnError(net::ERR_ABORTED, true);
   }
 }
 
 }  // namespace net