Remove HTTP pipelining support.

net/http/http_server_properties_impl.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 "net/http/http_server_properties_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
-#include "net/http/http_pipelined_host_capability.h"
 
 namespace net {
 
 namespace {
 
-// 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.
-const int kDefaultNumHostsToRemember = 200;
-
 const uint64 kBrokenAlternateProtocolDelaySecs = 300;
 
 }  // namespace
 
 HttpServerPropertiesImpl::HttpServerPropertiesImpl()
     : spdy_servers_map_(SpdyServerHostPortMap::NO_AUTO_EVICT),
       alternate_protocol_map_(AlternateProtocolMap::NO_AUTO_EVICT),
       spdy_settings_map_(SpdySettingsMap::NO_AUTO_EVICT),
-      pipeline_capability_map_(
-          new CachedPipelineCapabilityMap(kDefaultNumHostsToRemember)),
       weak_ptr_factory_(this) {
   canoncial_suffixes_.push_back(".c.youtube.com");
   canoncial_suffixes_.push_back(".googlevideo.com");
 }
 
 HttpServerPropertiesImpl::~HttpServerPropertiesImpl() {
 }
 
 void HttpServerPropertiesImpl::InitializeSpdyServers(
     std::vector<std::string>* spdy_servers,
@@ skipping 55 matching lines @@
 }
 
 void HttpServerPropertiesImpl::InitializeSpdySettingsServers(
     SpdySettingsMap* spdy_settings_map) {
   for (SpdySettingsMap::reverse_iterator it = spdy_settings_map->rbegin();
        it != spdy_settings_map->rend(); ++it) {
     spdy_settings_map_.Put(it->first, it->second);
   }
 }
 
-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) {
-  DCHECK(pipeline_capability_map_->empty());
-  pipeline_capability_map_.reset(new CachedPipelineCapabilityMap(max_size));
-}
-
 void HttpServerPropertiesImpl::GetSpdyServerList(
     base::ListValue* spdy_server_list,
     size_t max_size) const {
   DCHECK(CalledOnValidThread());
   DCHECK(spdy_server_list);
   spdy_server_list->Clear();
   size_t count = 0;
   // Get the list of servers (host/port) that support SPDY.
   for (SpdyServerHostPortMap::const_iterator it = spdy_servers_map_.begin();
        it != spdy_servers_map_.end() && count < max_size; ++it) {
@@ skipping 34 matching lines @@
 
 base::WeakPtr<HttpServerProperties> HttpServerPropertiesImpl::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void HttpServerPropertiesImpl::Clear() {
   DCHECK(CalledOnValidThread());
   spdy_servers_map_.Clear();
   alternate_protocol_map_.Clear();
   spdy_settings_map_.Clear();
-  pipeline_capability_map_->Clear();
 }
 
 bool HttpServerPropertiesImpl::SupportsSpdy(
     const net::HostPortPair& host_port_pair) {
   DCHECK(CalledOnValidThread());
   if (host_port_pair.host().empty())
     return false;
   std::string spdy_server = GetFlattenedSpdyServer(host_port_pair);
 
   SpdyServerHostPortMap::iterator spdy_host_port =
@@ skipping 207 matching lines @@
 HttpServerPropertiesImpl::GetServerNetworkStats(
     const HostPortPair& host_port_pair) const {
   ServerNetworkStatsMap::const_iterator it =
       server_network_stats_map_.find(host_port_pair);
   if (it == server_network_stats_map_.end()) {
     return NULL;
   }
   return &it->second;
 }
 
-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;
-}
-
 HttpServerPropertiesImpl::CanonicalHostMap::const_iterator
 HttpServerPropertiesImpl::GetCanonicalHost(HostPortPair server) const {
   for (size_t i = 0; i < canoncial_suffixes_.size(); ++i) {
     std::string canonical_suffix = canoncial_suffixes_[i];
     if (EndsWith(server.host(), canoncial_suffixes_[i], false)) {
       HostPortPair canonical_host(canonical_suffix, server.port());
       return canonical_host_to_origin_map_.find(canonical_host);
     }
   }
 
@@ skipping 25 matching lines @@
   base::TimeDelta delay = when > now ? when - now : base::TimeDelta();
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(
           &HttpServerPropertiesImpl::ExpireBrokenAlternateProtocolMappings,
           weak_ptr_factory_.GetWeakPtr()),
       delay);
 }
 
 }  // namespace net