Remove HTTP pipelining support.

chrome/browser/net/http_server_properties_manager.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 "chrome/browser/net/http_server_properties_manager.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
@@ skipping 246 matching lines @@
     NetworkStats stats) {
   http_server_properties_impl_->SetServerNetworkStats(host_port_pair, stats);
 }
 
 const HttpServerPropertiesManager::NetworkStats*
 HttpServerPropertiesManager::GetServerNetworkStats(
     const net::HostPortPair& host_port_pair) const {
   return http_server_properties_impl_->GetServerNetworkStats(host_port_pair);
 }
 
-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 30 matching lines @@
   if (!http_server_properties_dict.GetDictionaryWithoutPathExpansion(
       "servers", &servers_dict)) {
     DVLOG(1) << "Malformed http_server_properties for servers.";
     return;
   }
 
   // String is host/port pair of spdy server.
   scoped_ptr<StringVector> spdy_servers(new StringVector);
   scoped_ptr<net::SpdySettingsMap> spdy_settings_map(
       new net::SpdySettingsMap(kMaxSpdySettingsHostsToPersist));
-  scoped_ptr<net::PipelineCapabilityMap> pipeline_capability_map(
-      new net::PipelineCapabilityMap);
   scoped_ptr<net::AlternateProtocolMap> alternate_protocol_map(
       new net::AlternateProtocolMap(kMaxAlternateProtocolHostsToPersist));
 
   for (base::DictionaryValue::Iterator it(*servers_dict); !it.IsAtEnd();
        it.Advance()) {
     // Get server's host/pair.
     const std::string& server_str = it.key();
     net::HostPortPair server = net::HostPortPair::FromString(server_str);
     if (server.host().empty()) {
       DVLOG(1) << "Malformed http_server_properties for server: " << server_str;
@@ skipping 38 matching lines @@
           NOTREACHED();
           continue;
         }
         net::SettingsFlagsAndValue flags_and_value(
             net::SETTINGS_FLAG_PERSISTED, value);
         settings_map[static_cast<net::SpdySettingsIds>(id)] = flags_and_value;
       }
       spdy_settings_map->Put(server, settings_map);
     }
 
-    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(alternate_protocol_map->Peek(server) ==
            alternate_protocol_map->end());
     const base::DictionaryValue* port_alternate_protocol_dict = NULL;
     if (!server_pref_dict->GetDictionaryWithoutPathExpansion(
         "alternate_protocol", &port_alternate_protocol_dict)) {
       continue;
     }
 
     do {
@@ skipping 29 matching lines @@
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&HttpServerPropertiesManager::
                  UpdateCacheFromPrefsOnIO,
                  base::Unretained(this),
                  base::Owned(spdy_servers.release()),
                  base::Owned(spdy_settings_map.release()),
                  base::Owned(alternate_protocol_map.release()),
-                 base::Owned(pipeline_capability_map.release()),
                  detected_corrupted_prefs));
 }
 
 void HttpServerPropertiesManager::UpdateCacheFromPrefsOnIO(
     StringVector* spdy_servers,
     net::SpdySettingsMap* spdy_settings_map,
     net::AlternateProtocolMap* alternate_protocol_map,
-    net::PipelineCapabilityMap* pipeline_capability_map,
     bool detected_corrupted_prefs) {
   // 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));
 
   UMA_HISTOGRAM_COUNTS("Net.CountOfSpdyServers", spdy_servers->size());
   http_server_properties_impl_->InitializeSpdyServers(spdy_servers, true);
 
   // Clear the cached data and use the new spdy_settings from preferences.
   UMA_HISTOGRAM_COUNTS("Net.CountOfSpdySettings", spdy_settings_map->size());
   http_server_properties_impl_->InitializeSpdySettingsServers(
       spdy_settings_map);
 
   // Clear the cached data and use the new Alternate-Protocol server list from
   // preferences.
   UMA_HISTOGRAM_COUNTS("Net.CountOfAlternateProtocolServers",
                        alternate_protocol_map->size());
   http_server_properties_impl_->InitializeAlternateProtocolServers(
       alternate_protocol_map);
 
-  UMA_HISTOGRAM_COUNTS("Net.CountOfPipelineCapableServers",
-                       pipeline_capability_map->size());
-  http_server_properties_impl_->InitializePipelineCapabilities(
-      pipeline_capability_map);
-
   // Update the prefs with what we have read (delete all corrupted prefs).
   if (detected_corrupted_prefs)
     ScheduleUpdatePrefsOnIO();
 }
 
 
 //
 // Update Preferences with data from the cached data.
 //
 void HttpServerPropertiesManager::ScheduleUpdatePrefsOnIO() {
@@ skipping 41 matching lines @@
       new net::AlternateProtocolMap(kMaxAlternateProtocolHostsToPersist);
   const net::AlternateProtocolMap& map =
       http_server_properties_impl_->alternate_protocol_map();
   count = 0;
   for (net::AlternateProtocolMap::const_iterator it = map.begin();
        it != map.end() && count < kMaxAlternateProtocolHostsToPersist;
        ++it, ++count) {
     alternate_protocol_map->Put(it->first, it->second);
   }
 
-  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(pipeline_capability_map),
                  completion));
 }
 
 // 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.
+// and PortAlternateProtocolPair preferences for a server. This is used only in
+// UpdatePrefsOnUI.
 struct ServerPref {
   ServerPref()
       : supports_spdy(false),
         settings_map(NULL),
-        alternate_protocol(NULL),
-        pipeline_capability(net::PIPELINE_UNKNOWN) {
+        alternate_protocol(NULL) {
   }
   ServerPref(bool supports_spdy,
              const net::SettingsMap* settings_map,
              const net::PortAlternateProtocolPair* alternate_protocol)
       : supports_spdy(supports_spdy),
         settings_map(settings_map),
-        alternate_protocol(alternate_protocol),
-        pipeline_capability(net::PIPELINE_UNKNOWN) {
+        alternate_protocol(alternate_protocol) {
   }
   bool supports_spdy;
   const net::SettingsMap* settings_map;
   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::PipelineCapabilityMap* pipeline_capability_map,
     const base::Closure& completion) {
 
   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();
@@ skipping 38 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;
   base::DictionaryValue* servers_dict = new base::DictionaryValue;
   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 24 matching lines @@
           server_pref.alternate_protocol;
       port_alternate_protocol_dict->SetInteger(
           "port", port_alternate_protocol->port);
       const char* protocol_str =
           net::AlternateProtocolToString(port_alternate_protocol->protocol);
       port_alternate_protocol_dict->SetString("protocol_str", protocol_str);
       server_pref_dict->SetWithoutPathExpansion(
           "alternate_protocol", port_alternate_protocol_dict);
     }
 
-    if (server_pref.pipeline_capability != net::PIPELINE_UNKNOWN) {
-      server_pref_dict->SetInteger("pipeline_capability",
-                                   server_pref.pipeline_capability);
-    }
-
     servers_dict->SetWithoutPathExpansion(server.ToString(), server_pref_dict);
   }
 
   http_server_properties_dict.SetWithoutPathExpansion("servers", servers_dict);
   SetVersion(&http_server_properties_dict, kVersionNumber);
   setting_prefs_ = true;
   pref_service_->Set(prefs::kHttpServerProperties,
                      http_server_properties_dict);
   setting_prefs_ = false;
 
   // Note that |completion| will be fired after we have written everything to
   // the Preferences, but likely before these changes are serialized to disk.
   // This is not a problem though, as JSONPrefStore guarantees that this will
   // happen, pretty soon, and even in the case we shut down immediately.
   if (!completion.is_null())
     completion.Run();
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!setting_prefs_)
     ScheduleUpdateCacheOnUI();
 }
 
 }  // namespace chrome_browser_net