Save pipelining capabilities for the most used hosts between sessions.

chrome/browser/net/http_server_properties_manager.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 "chrome/browser/net/http_server_properties_manager.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 153 matching lines @@
   http_server_properties_impl_->ClearSpdySettings();
   ScheduleUpdatePrefsOnIO();
 }
 
 const net::SpdySettingsMap&
 HttpServerPropertiesManager::spdy_settings_map() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return http_server_properties_impl_->spdy_settings_map();
 }
 
+net::HttpPipelinedHostCapability
+HttpServerPropertiesManager::GetPipelineCapability(
+    const net::HostPortPair& origin) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  return http_server_properties_impl_->GetPipelineCapability(origin);
+}
+
+void HttpServerPropertiesManager::SetPipelineCapability(
+    const net::HostPortPair& origin,
+    net::HttpPipelinedHostCapability capability) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  http_server_properties_impl_->SetPipelineCapability(origin, capability);
+  ScheduleUpdatePrefsOnIO();
+}
+
+void HttpServerPropertiesManager::ClearPipelineCapabilities() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  http_server_properties_impl_->ClearPipelineCapabilities();
+  ScheduleUpdatePrefsOnIO();
+}
+
+net::PipelineCapabilityMap
+HttpServerPropertiesManager::GetPipelineCapabilityMap() const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  return http_server_properties_impl_->GetPipelineCapabilityMap();
+}
+
 //
 // Update the HttpServerPropertiesImpl's cache with data from preferences.
 //
 void HttpServerPropertiesManager::ScheduleUpdateCacheOnUI() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Cancel pending updates, if any.
   ui_cache_update_timer_->Stop();
   StartCacheUpdateTimerOnUI(
       base::TimeDelta::FromMilliseconds(kUpdateCacheDelayMs));
 }
@@ skipping 16 matching lines @@
   // String is host/port pair of spdy server.
   StringVector* spdy_servers = new StringVector;
 
   // Parse the preferences into a SpdySettingsMap.
   net::SpdySettingsMap* spdy_settings_map = new net::SpdySettingsMap;
 
   // Parse the preferences into a AlternateProtocolMap.
   net::AlternateProtocolMap* alternate_protocol_map =
       new net::AlternateProtocolMap;
 
+  net::PipelineCapabilityMap* pipeline_capability_map =
+      new net::PipelineCapabilityMap;
+
   const base::DictionaryValue& http_server_properties_dict =
       *pref_service_->GetDictionary(prefs::kHttpServerProperties);
   for (base::DictionaryValue::key_iterator it =
        http_server_properties_dict.begin_keys();
        it != http_server_properties_dict.end_keys(); ++it) {
     // Get server's host/pair.
     const std::string& server_str = *it;
     net::HostPortPair server = net::HostPortPair::FromString(server_str);
     if (server.host().empty()) {
       DVLOG(1) << "Malformed http_server_properties for server: " << server_str;
@@ skipping 54 matching lines @@
         spdy::SettingsFlagsAndId flags_and_id(0);
         flags_and_id.set_id(id);
         flags_and_id.set_flags(spdy::SETTINGS_FLAG_PERSISTED);
 
         spdy_settings.push_back(spdy::SpdySetting(flags_and_id, value));
       }
 
       (*spdy_settings_map)[server] = spdy_settings;
     }
 
+    int pipeline_capability = net::PIPELINE_UNKNOWN;
+    if ((server_pref_dict->GetInteger(
+         "pipeline_capability", &pipeline_capability)) &&
+        pipeline_capability != net::PIPELINE_UNKNOWN) {
+      (*pipeline_capability_map)[server] =
+          static_cast<net::HttpPipelinedHostCapability>(pipeline_capability);
+    }
+
     // Get alternate_protocol server.
     DCHECK(!ContainsKey(*alternate_protocol_map, server));
     base::DictionaryValue* port_alternate_protocol_dict = NULL;
     if (!server_pref_dict->GetDictionaryWithoutPathExpansion(
         "alternate_protocol", &port_alternate_protocol_dict)) {
       continue;
     }
 
     do {
       int port = 0;
@@ skipping 22 matching lines @@
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&HttpServerPropertiesManager::
                  UpdateCacheFromPrefsOnIO,
                  base::Unretained(this),
                  base::Owned(spdy_servers),
                  base::Owned(spdy_settings_map),
-                 base::Owned(alternate_protocol_map)));
+                 base::Owned(alternate_protocol_map),
+                 base::Owned(pipeline_capability_map)));
 }
 
 void HttpServerPropertiesManager::UpdateCacheFromPrefsOnIO(
     StringVector* spdy_servers,
     net::SpdySettingsMap* spdy_settings_map,
-    net::AlternateProtocolMap* alternate_protocol_map) {
+    net::AlternateProtocolMap* alternate_protocol_map,
+    net::PipelineCapabilityMap* pipeline_capability_map) {
   // Preferences have the master data because admins might have pushed new
   // preferences. Update the cached data with new data from preferences.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   http_server_properties_impl_->InitializeSpdyServers(spdy_servers, true);
 
   // Clear the cached data and use the new spdy_settings from preferences.
   http_server_properties_impl_->InitializeSpdySettingsServers(
       spdy_settings_map);
 
   // Clear the cached data and use the new Alternate-Protocol server list from
   // preferences.
   http_server_properties_impl_->InitializeAlternateProtocolServers(
       alternate_protocol_map);
+
+  http_server_properties_impl_->InitializePipelineCapabilities(
+      pipeline_capability_map);
 }
 
 
 //
 // Update Preferences with data from the cached data.
 //
 void HttpServerPropertiesManager::ScheduleUpdatePrefsOnIO() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Cancel pending updates, if any.
   io_prefs_update_timer_->Stop();
@@ skipping 17 matching lines @@
   http_server_properties_impl_->GetSpdyServerList(spdy_server_list);
 
   net::SpdySettingsMap* spdy_settings_map = new net::SpdySettingsMap;
   *spdy_settings_map = http_server_properties_impl_->spdy_settings_map();
 
   net::AlternateProtocolMap* alternate_protocol_map =
       new net::AlternateProtocolMap;
   *alternate_protocol_map =
       http_server_properties_impl_->alternate_protocol_map();
 
+  net::PipelineCapabilityMap* pipeline_capability_map =
+      new net::PipelineCapabilityMap;
+  *pipeline_capability_map =
+      http_server_properties_impl_->GetPipelineCapabilityMap();
+
   // Update the preferences on the UI thread.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&HttpServerPropertiesManager::UpdatePrefsOnUI,
                  ui_weak_ptr_,
                  base::Owned(spdy_server_list),
                  base::Owned(spdy_settings_map),
-                 base::Owned(alternate_protocol_map)));
+                 base::Owned(alternate_protocol_map),
+                 base::Owned(pipeline_capability_map)));
 }
 
-// A local or temporary data structure to hold supports_spdy, SpdySettings and
-// PortAlternateProtocolPair preferences for a server. This is used only in
-// UpdatePrefsOnUI.
+// A local or temporary data structure to hold |supports_spdy|, SpdySettings,
+// PortAlternateProtocolPair, and |pipeline_capability| preferences for a
+// server. This is used only in UpdatePrefsOnUI.
 struct ServerPref {
   ServerPref()
       : supports_spdy(false),
         settings(NULL),
-        alternate_protocol(NULL) {
+        alternate_protocol(NULL),
+        pipeline_capability(net::PIPELINE_UNKNOWN) {
   }
   ServerPref(bool supports_spdy,
              const spdy::SpdySettings* settings,
              const net::PortAlternateProtocolPair* alternate_protocol)
       : supports_spdy(supports_spdy),
         settings(settings),
-        alternate_protocol(alternate_protocol) {
+        alternate_protocol(alternate_protocol),
+        pipeline_capability(net::PIPELINE_UNKNOWN) {
   }
   bool supports_spdy;
   const spdy::SpdySettings* settings;
   const net::PortAlternateProtocolPair* alternate_protocol;
+  net::HttpPipelinedHostCapability pipeline_capability;
 };
 
 void HttpServerPropertiesManager::UpdatePrefsOnUI(
     base::ListValue* spdy_server_list,
     net::SpdySettingsMap* spdy_settings_map,
-    net::AlternateProtocolMap* alternate_protocol_map) {
+    net::AlternateProtocolMap* alternate_protocol_map,
+    net::PipelineCapabilityMap* pipeline_capability_map) {
 
   typedef std::map<net::HostPortPair, ServerPref> ServerPrefMap;
   ServerPrefMap server_pref_map;
 
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Add servers that support spdy to server_pref_map.
   std::string s;
   for (base::ListValue::const_iterator list_it = spdy_server_list->begin();
        list_it != spdy_server_list->end(); ++list_it) {
@@ skipping 39 matching lines @@
 
     ServerPrefMap::iterator it = server_pref_map.find(server);
     if (it == server_pref_map.end()) {
       ServerPref server_pref(false, NULL, &map_it->second);
       server_pref_map[server] = server_pref;
     } else {
       it->second.alternate_protocol = &map_it->second;
     }
   }
 
+  for (net::PipelineCapabilityMap::const_iterator map_it =
+           pipeline_capability_map->begin();
+       map_it != pipeline_capability_map->end(); ++map_it) {
+    const net::HostPortPair& server = map_it->first;
+    const net::HttpPipelinedHostCapability& pipeline_capability =
+        map_it->second;
+
+    ServerPrefMap::iterator it = server_pref_map.find(server);
+    if (it == server_pref_map.end()) {
+      ServerPref server_pref;
+      server_pref.pipeline_capability = pipeline_capability;
+      server_pref_map[server] = server_pref;
+    } else {
+      it->second.pipeline_capability = pipeline_capability;
+    }
+  }
+
   // Persist the prefs::kHttpServerProperties.
   base::DictionaryValue http_server_properties_dict;
   for (ServerPrefMap::const_iterator map_it =
        server_pref_map.begin();
        map_it != server_pref_map.end(); ++map_it) {
     const net::HostPortPair& server = map_it->first;
     const ServerPref& server_pref = map_it->second;
 
     base::DictionaryValue* server_pref_dict = new base::DictionaryValue;
 
@@ skipping 22 matching lines @@
           new base::DictionaryValue;
       const net::PortAlternateProtocolPair* port_alternate_protocol =
           server_pref.alternate_protocol;
       port_alternate_protocol_dict->SetInteger(
           "port", port_alternate_protocol->port);
       port_alternate_protocol_dict->SetInteger(
           "protocol", port_alternate_protocol->protocol);
       server_pref_dict->SetWithoutPathExpansion(
           "alternate_protocol", port_alternate_protocol_dict);
     }
-    http_server_properties_dict.SetWithoutPathExpansion(
-          server.ToString(), server_pref_dict);
+
+    if (server_pref.pipeline_capability != net::PIPELINE_UNKNOWN) {
+      server_pref_dict->SetInteger("pipeline_capability",
+                                   server_pref.pipeline_capability);
+    }
+
+    http_server_properties_dict.SetWithoutPathExpansion(server.ToString(),
+                                                        server_pref_dict);
   }
 
   setting_prefs_ = true;
   pref_service_->Set(prefs::kHttpServerProperties,
                      http_server_properties_dict);
   setting_prefs_ = false;
 }
 
 void HttpServerPropertiesManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(type == chrome::NOTIFICATION_PREF_CHANGED);
   PrefService* prefs = content::Source<PrefService>(source).ptr();
   DCHECK(prefs == pref_service_);
   std::string* pref_name = content::Details<std::string>(details).ptr();
   if (*pref_name == prefs::kHttpServerProperties) {
     if (!setting_prefs_)
       ScheduleUpdateCacheOnUI();
   } else {
     NOTREACHED();
   }
 }
 
 }  // namespace chrome_browser_net