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"
 
 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.

[willchan no longer on Chromium, 2011/12/02 23:35:29]

Good idea. But perhaps we should put this in the constructor so that the
embedder can decide. Memory utilization is best decided by the embedder, which
will have a better knowledge of the memory availability on the platform.

[James Simonsen, 2011/12/03 03:16:00]

Hmm. I started in on this, but that constructor is all over the place and I
suspect most users have no idea what to set it to.

Instead, how about we go with a conservative default and then provide the option
to resize it? The MRUCache can easily be resized and I've added the code for
that.

+static const int kNumHostsToRemember = 200;
+
+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(
+    PipelineCapabilityMap* pipeline_capability_map) {
+  PipelineCapabilityMap::const_iterator it;
+  pipeline_capability_map_.Clear();

[mmenke, 2011/12/02 21:52:10]

Whenever we call this, we basically put the pipeline capabilities in the MRU
cache in random order.  Looks like the only fix for this would be to either not
store pipeline capabilities in the ServerPref structure with the other
properties, or keep track of the order in the ServerPref structure, which seems
like too much effort.

[James Simonsen, 2011/12/03 03:16:00]

Yeah, I know. :( I debated it for a bit, but decided this is probably good
enough, at least for now. We can always fix it later on. I want to start getting
some metrics before playing around with the code too much more.

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

Sounds good to me.  Just wanted to make sure you were thinking about it.

+  for (it = pipeline_capability_map->begin();
+       it != pipeline_capability_map->end(); ++it) {
+    pipeline_capability_map_.Put(it->first, it->second);
+  }
+}
+
 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_;
 }
 
+HttpPipelinedHost::Capability HttpServerPropertiesImpl::GetPipelineCapability(
+    const HostPortPair& origin) {
+  HttpPipelinedHost::Capability capability = HttpPipelinedHost::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,
+      HttpPipelinedHost::Capability capability) {
+  CachedPipelineCapabilityMap::iterator it =
+      pipeline_capability_map_.Peek(origin);
+  if (it == pipeline_capability_map_.end() ||
+      it->second != HttpPipelinedHost::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