QUIC - Persist 1000 MRU alternate protocols to preferences file.

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"
@@ skipping 11 matching lines @@
 // 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),
+      alternate_protocol_experiment_(
+          ALTERNATE_PROTOCOL_NOT_PART_OF_EXPERIMENT),
       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() {
 }
@@ skipping 171 matching lines @@
 
 bool HttpServerPropertiesImpl::HasAlternateProtocol(
     const HostPortPair& server) {
   if (alternate_protocol_map_.Get(server) != alternate_protocol_map_.end() ||
       g_forced_alternate_protocol)
     return true;
 
   return GetCanonicalHost(server) != canonical_host_to_origin_map_.end();
 }
 
+std::string HttpServerPropertiesImpl::GetCanonicalSuffix(
+    const HostPortPair& server) {
+  // If this host ends with a canonical suffix, then return the canonical
+  // suffix.
+  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)) {
+      return canonical_suffix;
+    }
+  }
+  return std::string();
+}
+
 PortAlternateProtocolPair
 HttpServerPropertiesImpl::GetAlternateProtocol(
     const HostPortPair& server) {
   DCHECK(HasAlternateProtocol(server));
 
   // First check the map.
   AlternateProtocolMap::iterator it = alternate_protocol_map_.Get(server);
   if (it != alternate_protocol_map_.end())
     return it->second;
 
@@ skipping 35 matching lines @@
                    << " from [Port: " << existing_alternate.port
                    << ", Protocol: " << existing_alternate.protocol
                    << "] to [Port: " << alternate_port
                    << ", Protocol: " << alternate_protocol
                    << "].";
     }
   } else {
     // TODO(rch): Consider the case where multiple requests are started
     // before the first completes. In this case, only one of the jobs
     // would reach this code, whereas all of them should should have.
-    HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_MAPPING_MISSING);
+    HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_MAPPING_MISSING,
+                                    alternate_protocol_experiment_);
   }
 
   alternate_protocol_map_.Put(server, alternate);
 
   // If this host ends with a canonical suffix, then set it as the
   // canonical host.
   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());
@@ skipping 44 matching lines @@
   AlternateProtocolMap::iterator it = alternate_protocol_map_.Peek(server);
   if (it != alternate_protocol_map_.end())
     alternate_protocol_map_.Erase(it);
 }
 
 const AlternateProtocolMap&
 HttpServerPropertiesImpl::alternate_protocol_map() const {
   return alternate_protocol_map_;
 }
 
+void HttpServerPropertiesImpl::SetAlternateProtocolExperiment(
+    AlternateProtocolExperiment experiment) {
+  alternate_protocol_experiment_ = experiment;
+}
+
+AlternateProtocolExperiment
+HttpServerPropertiesImpl::GetAlternateProtocolExperiment() const {
+  return alternate_protocol_experiment_;
+}
+
 const SettingsMap& HttpServerPropertiesImpl::GetSpdySettings(
     const HostPortPair& host_port_pair) {
   SpdySettingsMap::iterator it = spdy_settings_map_.Get(host_port_pair);
   if (it == spdy_settings_map_.end()) {
     CR_DEFINE_STATIC_LOCAL(SettingsMap, kEmptySettingsMap, ());
     return kEmptySettingsMap;
   }
   return it->second;
 }
 
@@ skipping 126 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