Save pipelining capabilities for the most used hosts between sessions.

net/http/http_server_properties_impl.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/http/http_server_properties_impl.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
+#include "net/http/http_pipelined_host_capability.h"
 
 namespace net {
 
-HttpServerPropertiesImpl::HttpServerPropertiesImpl() {
+// TODO(simonjam): Run experiments with different values of this to see what
+// value is good at avoiding evictions without eating too much memory. Until
+// then, this is just a bad guess.
+static const int kNumHostsToRemember = 200;

[mmenke, 2011/12/06 15:50:38]

nit:  This should now be kDefaultNumHostsToRemember or something along those
lines.

[James Simonsen, 2011/12/06 19:57:49]

Done.

+
+HttpServerPropertiesImpl::HttpServerPropertiesImpl()
+    : pipeline_capability_map_(kNumHostsToRemember) {
 }
 
 HttpServerPropertiesImpl::~HttpServerPropertiesImpl() {
 }
 
 void HttpServerPropertiesImpl::InitializeSpdyServers(
     std::vector<std::string>* spdy_servers,
     bool support_spdy) {
   DCHECK(CalledOnValidThread());
   spdy_servers_table_.clear();
@@ skipping 16 matching lines @@
     if (it->second.protocol == ALTERNATE_PROTOCOL_BROKEN)
       alternate_protocol_map_[it->first] = it->second;
   }
 }
 
 void HttpServerPropertiesImpl::InitializeSpdySettingsServers(
     std::map<HostPortPair, spdy::SpdySettings>* spdy_settings_map) {
   spdy_settings_map_.swap(*spdy_settings_map);
 }
 
+void HttpServerPropertiesImpl::InitializePipelineCapabilities(
+    const PipelineCapabilityMap* pipeline_capability_map) {
+  PipelineCapabilityMap::const_iterator it;
+  pipeline_capability_map_.Clear();
+  for (it = pipeline_capability_map->begin();
+       it != pipeline_capability_map->end(); ++it) {
+    pipeline_capability_map_.Put(it->first, it->second);
+  }
+}
+
+void HttpServerPropertiesImpl::SetNumPipelinedHostsToRemember(int max_size) {

[mmenke, 2011/12/06 15:50:38]

Just to make things simple, you could just require this to be created on
construction, and recreate the map from scratch, with a DCHECK that it's empty. 
Up to you, but I don't think there's much need for it to be changed after
startup, and think it's best to keep things simple when there's no need for
complexiy.

[James Simonsen, 2011/12/06 19:57:49]

Ok. Done.

+  pipeline_capability_map_.SetMaxSize(max_size);
+}
+
 void HttpServerPropertiesImpl::GetSpdyServerList(
     base::ListValue* spdy_server_list) const {
   DCHECK(CalledOnValidThread());
   DCHECK(spdy_server_list);
   spdy_server_list->Clear();
   // Get the list of servers (host/port) that support SPDY.
   for (SpdyServerHostPortTable::const_iterator it = spdy_servers_table_.begin();
        it != spdy_servers_table_.end(); ++it) {
     const std::string spdy_server_host_port = it->first;
     if (it->second)
@@ skipping 26 matching lines @@
 void HttpServerPropertiesImpl::DisableForcedAlternateProtocol() {
   delete g_forced_alternate_protocol;
   g_forced_alternate_protocol = NULL;
 }
 
 void HttpServerPropertiesImpl::Clear() {
   DCHECK(CalledOnValidThread());
   spdy_servers_table_.clear();
   alternate_protocol_map_.clear();
   spdy_settings_map_.clear();
+  pipeline_capability_map_.Clear();
 }
 
 bool HttpServerPropertiesImpl::SupportsSpdy(
     const net::HostPortPair& host_port_pair) const {
   DCHECK(CalledOnValidThread());
   if (host_port_pair.host().empty())
     return false;
   std::string spdy_server = GetFlattenedSpdyServer(host_port_pair);
 
   SpdyServerHostPortTable::const_iterator spdy_host_port =
@@ skipping 125 matching lines @@
 
 void HttpServerPropertiesImpl::ClearSpdySettings() {
   spdy_settings_map_.clear();
 }
 
 const SpdySettingsMap&
 HttpServerPropertiesImpl::spdy_settings_map() const {
   return spdy_settings_map_;
 }
 
+HttpPipelinedHostCapability HttpServerPropertiesImpl::GetPipelineCapability(
+    const HostPortPair& origin) {
+  HttpPipelinedHostCapability capability = PIPELINE_UNKNOWN;
+  CachedPipelineCapabilityMap::const_iterator it =
+      pipeline_capability_map_.Get(origin);
+  if (it != pipeline_capability_map_.end()) {
+    capability = it->second;
+  }
+  return capability;
+}
+
+void HttpServerPropertiesImpl::SetPipelineCapability(
+      const HostPortPair& origin,
+      HttpPipelinedHostCapability capability) {
+  CachedPipelineCapabilityMap::iterator it =
+      pipeline_capability_map_.Peek(origin);
+  if (it == pipeline_capability_map_.end() ||
+      it->second != PIPELINE_INCAPABLE) {
+    pipeline_capability_map_.Put(origin, capability);
+  }
+}
+
+void HttpServerPropertiesImpl::ClearPipelineCapabilities() {
+  pipeline_capability_map_.Clear();
+}
+
+PipelineCapabilityMap
+HttpServerPropertiesImpl::GetPipelineCapabilityMap() const {
+  PipelineCapabilityMap result;
+  CachedPipelineCapabilityMap::const_iterator it;
+  for (it = pipeline_capability_map_.begin();
+       it != pipeline_capability_map_.end(); ++it) {
+    result[it->first] = it->second;
+  }
+  return result;
+}
+
 }  // namespace net