Change SupportsSpdy dict, SpdySettingsMap, ServerNetworkStatsMap, AlternativeServiceMap and disk da…

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 <algorithm>
 #include <memory>
 #include <utility>
 
@@ skipping 10 matching lines @@
 
 namespace net {
 
 namespace {
 
 const uint64_t kBrokenAlternativeProtocolDelaySecs = 300;
 
 }  // namespace
 
 HttpServerPropertiesImpl::HttpServerPropertiesImpl()
-    : spdy_servers_map_(SpdyServerHostPortMap::NO_AUTO_EVICT),
+    : spdy_servers_map_(SpdyServersMap::NO_AUTO_EVICT),
       alternative_service_map_(AlternativeServiceMap::NO_AUTO_EVICT),
       spdy_settings_map_(SpdySettingsMap::NO_AUTO_EVICT),
       server_network_stats_map_(ServerNetworkStatsMap::NO_AUTO_EVICT),
       quic_server_info_map_(QuicServerInfoMap::NO_AUTO_EVICT),
       max_server_configs_stored_in_properties_(kMaxQuicServersToPersist),
       weak_ptr_factory_(this) {
   canonical_suffixes_.push_back(".ggpht.com");
   canonical_suffixes_.push_back(".c.youtube.com");
   canonical_suffixes_.push_back(".googlevideo.com");
   canonical_suffixes_.push_back(".googleusercontent.com");
 }
 
 HttpServerPropertiesImpl::~HttpServerPropertiesImpl() {
 }
 
 void HttpServerPropertiesImpl::InitializeSpdyServers(
     std::vector<std::string>* spdy_servers,
     bool support_spdy) {
   DCHECK(CalledOnValidThread());
   if (!spdy_servers)
     return;
 
   // Add the entries from persisted data.
-  SpdyServerHostPortMap spdy_servers_map(SpdyServerHostPortMap::NO_AUTO_EVICT);
+  SpdyServersMap spdy_servers_map(SpdyServersMap::NO_AUTO_EVICT);
   for (std::vector<std::string>::reverse_iterator it = spdy_servers->rbegin();
        it != spdy_servers->rend(); ++it) {
     spdy_servers_map.Put(*it, support_spdy);
   }
 
   // |spdy_servers_map| will have the memory cache.
   spdy_servers_map_.Swap(spdy_servers_map);
 
   // Add the entries from the memory cache.
-  for (SpdyServerHostPortMap::reverse_iterator it = spdy_servers_map.rbegin();
+  for (SpdyServersMap::reverse_iterator it = spdy_servers_map.rbegin();
        it != spdy_servers_map.rend(); ++it) {
     // Add the entry if it is not in the cache, otherwise move it to the front
     // of recency list.
     if (spdy_servers_map_.Get(it->first) == spdy_servers_map_.end())
       spdy_servers_map_.Put(it->first, it->second);
   }
 }
 
 void HttpServerPropertiesImpl::InitializeAlternativeServiceServers(
     AlternativeServiceMap* alternative_service_map) {
@@ skipping 22 matching lines @@
   // Add the entries from the memory cache.
   for (AlternativeServiceMap::reverse_iterator input_it =
            new_alternative_service_map.rbegin();
        input_it != new_alternative_service_map.rend(); ++input_it) {
     if (alternative_service_map_.Get(input_it->first) ==
         alternative_service_map_.end()) {
       alternative_service_map_.Put(input_it->first, input_it->second);
     }
   }
 
-  // Attempt to find canonical servers.
-  uint16_t canonical_ports[] = {80, 443};
+  // Attempt to find canonical servers. Canonical suffix only apply to HTTPS.
+  uint16_t canonical_port = 443;
+  const char* canonical_scheme = "https";
   for (size_t i = 0; i < canonical_suffixes_.size(); ++i) {
     std::string canonical_suffix = canonical_suffixes_[i];
-    for (size_t j = 0; j < arraysize(canonical_ports); ++j) {
-      HostPortPair canonical_host(canonical_suffix, canonical_ports[j]);
-      // If we already have a valid canonical server, we're done.
-      if (ContainsKey(canonical_host_to_origin_map_, canonical_host) &&
-          (alternative_service_map_.Peek(
-               canonical_host_to_origin_map_[canonical_host]) !=
-           alternative_service_map_.end())) {
-        continue;
-      }
-      // Now attempt to find a server which matches this origin and set it as
-      // canonical.
-      for (AlternativeServiceMap::const_iterator it =
-               alternative_service_map_.begin();
-           it != alternative_service_map_.end(); ++it) {
-        if (base::EndsWith(it->first.host(), canonical_suffixes_[i],
-                           base::CompareCase::INSENSITIVE_ASCII)) {
-          canonical_host_to_origin_map_[canonical_host] = it->first;
-          break;
-        }
+    url::SchemeHostPort canonical_server(canonical_scheme, canonical_suffix,
+                                         canonical_port);
+    // If we already have a valid canonical server, we're done.
+    if (ContainsKey(canonical_host_to_origin_map_, canonical_server) &&
+        (alternative_service_map_.Peek(
+             canonical_host_to_origin_map_[canonical_server]) !=
+         alternative_service_map_.end())) {
+      continue;
+    }
+    // Now attempt to find a server which matches this origin and set it as
+    // canonical.
+    for (AlternativeServiceMap::const_iterator it =
+             alternative_service_map_.begin();
+         it != alternative_service_map_.end(); ++it) {
+      if (base::EndsWith(it->first.host(), canonical_suffixes_[i],
+                         base::CompareCase::INSENSITIVE_ASCII) &&
+          it->first.scheme() == canonical_server.scheme()) {
+        canonical_host_to_origin_map_[canonical_server] = it->first;
+        break;
       }
     }
   }
 }
 
 void HttpServerPropertiesImpl::InitializeSpdySettingsServers(
     SpdySettingsMap* spdy_settings_map) {
   // Add the entries from persisted data.
   SpdySettingsMap new_spdy_settings_map(SpdySettingsMap::NO_AUTO_EVICT);
   for (SpdySettingsMap::reverse_iterator it = spdy_settings_map->rbegin();
@@ skipping 60 matching lines @@
   }
 }
 
 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();
+  // Get the list of servers (scheme/host/port) that support SPDY.
+  for (SpdyServersMap::const_iterator it = spdy_servers_map_.begin();
        it != spdy_servers_map_.end() && count < max_size; ++it) {
-    const std::string spdy_server_host_port = it->first;
+    const std::string spdy_server = it->first;
     if (it->second) {
-      spdy_server_list->Append(new base::StringValue(spdy_server_host_port));
+      spdy_server_list->Append(new base::StringValue(spdy_server));
       ++count;
     }
   }
 }
 
 base::WeakPtr<HttpServerProperties> HttpServerPropertiesImpl::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void HttpServerPropertiesImpl::Clear() {
   DCHECK(CalledOnValidThread());
   spdy_servers_map_.Clear();
   alternative_service_map_.Clear();
   canonical_host_to_origin_map_.clear();
   spdy_settings_map_.Clear();
   last_quic_address_ = IPAddress();
   server_network_stats_map_.Clear();
   quic_server_info_map_.Clear();
 }
 
 bool HttpServerPropertiesImpl::SupportsRequestPriority(
-    const HostPortPair& host_port_pair) {
+    const url::SchemeHostPort& server) {
   DCHECK(CalledOnValidThread());
-  if (host_port_pair.host().empty())
+  if (server.host().empty())
     return false;
 
-  if (GetSupportsSpdy(host_port_pair))
+  if (GetSupportsSpdy(server))
     return true;
-
   const AlternativeServiceVector alternative_service_vector =
-      GetAlternativeServices(host_port_pair);
+      GetAlternativeServices(server);
   for (const AlternativeService& alternative_service :
        alternative_service_vector) {
     if (alternative_service.protocol == QUIC) {
       return true;
     }
   }
   return false;
 }
 
 bool HttpServerPropertiesImpl::GetSupportsSpdy(
-    const HostPortPair& host_port_pair) {
+    const url::SchemeHostPort& server) {
   DCHECK(CalledOnValidThread());
-  if (host_port_pair.host().empty())
+  if (server.host().empty())
     return false;
 
-  SpdyServerHostPortMap::iterator spdy_host_port =
-      spdy_servers_map_.Get(host_port_pair.ToString());
-  return spdy_host_port != spdy_servers_map_.end() && spdy_host_port->second;
+  SpdyServersMap::iterator spdy_server =
+      spdy_servers_map_.Get(server.Serialize());
+  return spdy_server != spdy_servers_map_.end() && spdy_server->second;
 }
 
 void HttpServerPropertiesImpl::SetSupportsSpdy(
-    const HostPortPair& host_port_pair,
+    const url::SchemeHostPort& server,
     bool support_spdy) {
   DCHECK(CalledOnValidThread());
-  if (host_port_pair.host().empty())
+  if (server.host().empty())
     return;
 
-  SpdyServerHostPortMap::iterator spdy_host_port =
-      spdy_servers_map_.Get(host_port_pair.ToString());
-  if ((spdy_host_port != spdy_servers_map_.end()) &&
-      (spdy_host_port->second == support_spdy)) {
+  SpdyServersMap::iterator spdy_server =
+      spdy_servers_map_.Get(server.Serialize());
+  if ((spdy_server != spdy_servers_map_.end()) &&
+      (spdy_server->second == support_spdy)) {
     return;
   }
   // Cache the data.
-  spdy_servers_map_.Put(host_port_pair.ToString(), support_spdy);
+  spdy_servers_map_.Put(server.Serialize(), support_spdy);
 }
 
 bool HttpServerPropertiesImpl::RequiresHTTP11(
     const HostPortPair& host_port_pair) {
   DCHECK(CalledOnValidThread());
   if (host_port_pair.host().empty())
     return false;
 
   return (http11_servers_.find(host_port_pair) != http11_servers_.end());
 }
@@ skipping 22 matching lines @@
     std::string canonical_suffix = canonical_suffixes_[i];
     if (base::EndsWith(host, canonical_suffixes_[i],
                        base::CompareCase::INSENSITIVE_ASCII)) {
       return canonical_suffix;
     }
   }
   return std::string();
 }
 
 AlternativeServiceVector HttpServerPropertiesImpl::GetAlternativeServices(
-    const HostPortPair& origin) {
+    const url::SchemeHostPort& origin) {
   // Copy valid alternative services into |valid_alternative_services|.
   AlternativeServiceVector valid_alternative_services;
   const base::Time now = base::Time::Now();
   AlternativeServiceMap::iterator map_it = alternative_service_map_.Get(origin);
   if (map_it != alternative_service_map_.end()) {
+    HostPortPair host_port_pair(origin.host(), origin.port());
     for (AlternativeServiceInfoVector::iterator it = map_it->second.begin();
          it != map_it->second.end();) {
       if (it->expiration < now) {
         it = map_it->second.erase(it);
         continue;
       }
       AlternativeService alternative_service(it->alternative_service);
       if (alternative_service.host.empty()) {
         alternative_service.host = origin.host();
       }
       // If the alternative service is equivalent to the origin (same host, same
-      // port, and both TCP), then there is already a Job for it, so do not
-      // return it here.
-      if (origin.Equals(alternative_service.host_port_pair()) &&
+      // port, and both TCP), skip it.
+      if (host_port_pair.Equals(alternative_service.host_port_pair()) &&
           NPN_SPDY_MINIMUM_VERSION <= alternative_service.protocol &&
           alternative_service.protocol <= NPN_SPDY_MAXIMUM_VERSION) {
         ++it;
         continue;
       }
       valid_alternative_services.push_back(alternative_service);
       ++it;
     }
     if (map_it->second.empty()) {
       alternative_service_map_.Erase(map_it);
@@ skipping 30 matching lines @@
     valid_alternative_services.push_back(alternative_service);
     ++it;
   }
   if (map_it->second.empty()) {
     alternative_service_map_.Erase(map_it);
   }
   return valid_alternative_services;
 }
 
 bool HttpServerPropertiesImpl::SetAlternativeService(
-    const HostPortPair& origin,
+    const url::SchemeHostPort& origin,
     const AlternativeService& alternative_service,
     base::Time expiration) {
   return SetAlternativeServices(
       origin,
       AlternativeServiceInfoVector(
           /*size=*/1, AlternativeServiceInfo(alternative_service, expiration)));
 }
 
 bool HttpServerPropertiesImpl::SetAlternativeServices(
-    const HostPortPair& origin,
+    const url::SchemeHostPort& origin,
     const AlternativeServiceInfoVector& alternative_service_info_vector) {
   AlternativeServiceMap::iterator it = alternative_service_map_.Peek(origin);
 
   if (alternative_service_info_vector.empty()) {
     if (it == alternative_service_map_.end()) {
       return false;
     }
     ClearAlternativeServices(origin);
     return true;
   }
@@ skipping 15 matching lines @@
   if (previously_no_alternative_services &&
       !GetAlternativeServices(origin).empty()) {
     // 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);
   }
 
   // If this host ends with a canonical suffix, then set it as the
   // canonical host.
+  const char* canonical_scheme = "https";
   for (size_t i = 0; i < canonical_suffixes_.size(); ++i) {
     std::string canonical_suffix = canonical_suffixes_[i];
-    if (base::EndsWith(origin.host(), canonical_suffixes_[i],
+    // canonical suffixes only apply to HTTPS.
+    if (origin.scheme() == canonical_scheme &&
+        base::EndsWith(origin.host(), canonical_suffixes_[i],
                        base::CompareCase::INSENSITIVE_ASCII)) {
-      HostPortPair canonical_host(canonical_suffix, origin.port());
-      canonical_host_to_origin_map_[canonical_host] = origin;
+      url::SchemeHostPort canonical_server(canonical_scheme, canonical_suffix,
+                                           origin.port());
+      canonical_host_to_origin_map_[canonical_server] = origin;
       break;
     }
   }
 
   return changed;
 }
 
 void HttpServerPropertiesImpl::MarkAlternativeServiceBroken(
     const AlternativeService& alternative_service) {
   // Empty host means use host of origin, callers are supposed to substitute.
@@ skipping 43 matching lines @@
 
 void HttpServerPropertiesImpl::ConfirmAlternativeService(
     const AlternativeService& alternative_service) {
   if (alternative_service.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL)
     return;
   broken_alternative_services_.erase(alternative_service);
   recently_broken_alternative_services_.erase(alternative_service);
 }
 
 void HttpServerPropertiesImpl::ClearAlternativeServices(
-    const HostPortPair& origin) {
+    const url::SchemeHostPort& origin) {
   RemoveCanonicalHost(origin);
 
   AlternativeServiceMap::iterator it = alternative_service_map_.Peek(origin);
   if (it == alternative_service_map_.end()) {
     return;
   }
   alternative_service_map_.Erase(it);
 }
 
 const AlternativeServiceMap& HttpServerPropertiesImpl::alternative_service_map()
     const {
   return alternative_service_map_;
 }
 
 std::unique_ptr<base::Value>
 HttpServerPropertiesImpl::GetAlternativeServiceInfoAsValue() const {
   std::unique_ptr<base::ListValue> dict_list(new base::ListValue);
   for (const auto& alternative_service_map_item : alternative_service_map_) {
     std::unique_ptr<base::ListValue> alternative_service_list(
         new base::ListValue);
-    const HostPortPair& host_port_pair = alternative_service_map_item.first;
+    const url::SchemeHostPort& server = alternative_service_map_item.first;
     for (const AlternativeServiceInfo& alternative_service_info :
          alternative_service_map_item.second) {
       std::string alternative_service_string(
           alternative_service_info.ToString());
       AlternativeService alternative_service(
           alternative_service_info.alternative_service);
       if (alternative_service.host.empty()) {
-        alternative_service.host = host_port_pair.host();
+        alternative_service.host = server.host();
       }
       if (IsAlternativeServiceBroken(alternative_service)) {
         alternative_service_string.append(" (broken)");
       }
       alternative_service_list->Append(
           new base::StringValue(alternative_service_string));
     }
     if (alternative_service_list->empty())
       continue;
     std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-    dict->SetString("host_port_pair", host_port_pair.ToString());
+    dict->SetString("server", server.Serialize());
     dict->Set("alternative_service", std::unique_ptr<base::Value>(
                                          std::move(alternative_service_list)));
     dict_list->Append(std::move(dict));
   }
   return std::move(dict_list);
 }
 
 const SettingsMap& HttpServerPropertiesImpl::GetSpdySettings(
-    const HostPortPair& host_port_pair) {
-  SpdySettingsMap::iterator it = spdy_settings_map_.Get(host_port_pair);
+    const url::SchemeHostPort& server) {
+  SpdySettingsMap::iterator it = spdy_settings_map_.Get(server);
   if (it == spdy_settings_map_.end()) {
     CR_DEFINE_STATIC_LOCAL(SettingsMap, kEmptySettingsMap, ());
     return kEmptySettingsMap;
   }
   return it->second;
 }
 
-bool HttpServerPropertiesImpl::SetSpdySetting(
-    const HostPortPair& host_port_pair,
-    SpdySettingsIds id,
-    SpdySettingsFlags flags,
-    uint32_t value) {
+bool HttpServerPropertiesImpl::SetSpdySetting(const url::SchemeHostPort& server,
+                                              SpdySettingsIds id,
+                                              SpdySettingsFlags flags,
+                                              uint32_t value) {
   if (!(flags & SETTINGS_FLAG_PLEASE_PERSIST))
       return false;
 
   SettingsFlagsAndValue flags_and_value(SETTINGS_FLAG_PERSISTED, value);
-  SpdySettingsMap::iterator it = spdy_settings_map_.Get(host_port_pair);
+  SpdySettingsMap::iterator it = spdy_settings_map_.Get(server);
   if (it == spdy_settings_map_.end()) {
     SettingsMap settings_map;
     settings_map[id] = flags_and_value;
-    spdy_settings_map_.Put(host_port_pair, settings_map);
+    spdy_settings_map_.Put(server, settings_map);
   } else {
     SettingsMap& settings_map = it->second;
     settings_map[id] = flags_and_value;
   }
   return true;
 }
 
 void HttpServerPropertiesImpl::ClearSpdySettings(
-    const HostPortPair& host_port_pair) {
-  SpdySettingsMap::iterator it = spdy_settings_map_.Peek(host_port_pair);
+    const url::SchemeHostPort& server) {
+  SpdySettingsMap::iterator it = spdy_settings_map_.Peek(server);
   if (it != spdy_settings_map_.end())
     spdy_settings_map_.Erase(it);
 }
 
 void HttpServerPropertiesImpl::ClearAllSpdySettings() {
   spdy_settings_map_.Clear();
 }
 
 const SpdySettingsMap&
 HttpServerPropertiesImpl::spdy_settings_map() const {
@@ skipping 11 matching lines @@
 void HttpServerPropertiesImpl::SetSupportsQuic(bool used_quic,
                                                const IPAddress& address) {
   if (!used_quic) {
     last_quic_address_ = IPAddress();
   } else {
     last_quic_address_ = address;
   }
 }
 
 void HttpServerPropertiesImpl::SetServerNetworkStats(
-    const HostPortPair& host_port_pair,
+    const url::SchemeHostPort& server,
     ServerNetworkStats stats) {
-  server_network_stats_map_.Put(host_port_pair, stats);
+  server_network_stats_map_.Put(server, stats);
 }
 
 const ServerNetworkStats* HttpServerPropertiesImpl::GetServerNetworkStats(
-    const HostPortPair& host_port_pair) {
-  ServerNetworkStatsMap::iterator it =
-      server_network_stats_map_.Get(host_port_pair);
+    const url::SchemeHostPort& server) {
+  ServerNetworkStatsMap::iterator it = server_network_stats_map_.Get(server);
   if (it == server_network_stats_map_.end()) {
     return NULL;
   }
   return &it->second;
 }
 
 const ServerNetworkStatsMap&
 HttpServerPropertiesImpl::server_network_stats_map() const {
   return server_network_stats_map_;
 }
@@ skipping 38 matching lines @@
   for (QuicServerInfoMap::reverse_iterator it = quic_server_info_map_.rbegin();
        it != quic_server_info_map_.rend(); ++it) {
     temp_map.Put(it->first, it->second);
   }
 
   quic_server_info_map_.Swap(temp_map);
 }
 
 AlternativeServiceMap::const_iterator
 HttpServerPropertiesImpl::GetAlternateProtocolIterator(
-    const HostPortPair& server) {
+    const url::SchemeHostPort& server) {
   AlternativeServiceMap::const_iterator it =
       alternative_service_map_.Get(server);
   if (it != alternative_service_map_.end())
     return it;
 
   CanonicalHostMap::const_iterator canonical = GetCanonicalHost(server);
   if (canonical == canonical_host_to_origin_map_.end()) {
     return alternative_service_map_.end();
   }
 
-  const HostPortPair canonical_host_port = canonical->second;
-  it = alternative_service_map_.Get(canonical_host_port);
+  const url::SchemeHostPort canonical_server = canonical->second;
+  it = alternative_service_map_.Get(canonical_server);
   if (it == alternative_service_map_.end()) {
     return alternative_service_map_.end();
   }
 
   for (const AlternativeServiceInfo& alternative_service_info : it->second) {
     AlternativeService alternative_service(
         alternative_service_info.alternative_service);
     if (alternative_service.host.empty()) {
-      alternative_service.host = canonical_host_port.host();
+      alternative_service.host = canonical_server.host();
     }
     if (!IsAlternativeServiceBroken(alternative_service)) {
       return it;
     }
   }
 
-  RemoveCanonicalHost(canonical_host_port);
+  RemoveCanonicalHost(canonical_server);
   return alternative_service_map_.end();
 }
 
 HttpServerPropertiesImpl::CanonicalHostMap::const_iterator
-HttpServerPropertiesImpl::GetCanonicalHost(HostPortPair server) const {
+HttpServerPropertiesImpl::GetCanonicalHost(
+    const url::SchemeHostPort& server) const {
+  const char* canonical_scheme = "https";
+  if (server.scheme() != canonical_scheme)
+    return canonical_host_to_origin_map_.end();
+
   for (size_t i = 0; i < canonical_suffixes_.size(); ++i) {
     std::string canonical_suffix = canonical_suffixes_[i];
     if (base::EndsWith(server.host(), canonical_suffixes_[i],
                        base::CompareCase::INSENSITIVE_ASCII)) {
-      HostPortPair canonical_host(canonical_suffix, server.port());
-      return canonical_host_to_origin_map_.find(canonical_host);
+      url::SchemeHostPort canonical_server(canonical_scheme, canonical_suffix,
+                                           server.port());
+      return canonical_host_to_origin_map_.find(canonical_server);
     }
   }
 
   return canonical_host_to_origin_map_.end();
 }
 
 void HttpServerPropertiesImpl::RemoveCanonicalHost(
-    const HostPortPair& server) {
+    const url::SchemeHostPort& server) {
   CanonicalHostMap::const_iterator canonical = GetCanonicalHost(server);
   if (canonical == canonical_host_to_origin_map_.end())
     return;
 
   if (!canonical->second.Equals(server))
     return;
 
   canonical_host_to_origin_map_.erase(canonical->first);
 }
 
@@ skipping 52 matching lines @@
   base::TimeDelta delay = when > now ? when - now : base::TimeDelta();
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(
           &HttpServerPropertiesImpl::ExpireBrokenAlternateProtocolMappings,
           weak_ptr_factory_.GetWeakPtr()),
       delay);
 }
 
 }  // namespace net