Change the AlternativeServiceMap with SchemeOriginPair key.

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 <utility>
 
 #include "base/bind.h"
@@ skipping 95 matching lines @@
   }
 
   // Attempt to find canonical servers.
   uint16_t canonical_ports[] = {80, 443};
   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_.Peek(SchemeOriginPair(
+               "https", canonical_host_to_origin_map_[canonical_host])) !=

[Ryan Hamilton, 2016/03/24 22:23:14]

If we want canoncical suffixes to only apply to HTTPS (which seems reasonable)
it'd be good to add a comment to that effect. Should also remove port 80 on line
109 (and avoid the loop).

[Zhongyi Shi, 2016/04/04 18:58:36]

Done.

            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;
+          canonical_host_to_origin_map_[canonical_host] =
+              it->first.host_port_pair();
           break;
         }
       }
     }
   }
 }
 
 void HttpServerPropertiesImpl::InitializeSpdySettingsServers(
     SpdySettingsMap* spdy_settings_map) {
   // Add the entries from persisted data.
@@ skipping 89 matching lines @@
   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 SchemeOriginPair& server) {
   DCHECK(CalledOnValidThread());
-  if (host_port_pair.host().empty())
+  if (server.host().empty())
     return false;
 
-  if (GetSupportsSpdy(host_port_pair))
+  if (GetSupportsSpdy(server.host_port_pair()))
     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(
@@ skipping 57 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 SchemeOriginPair& origin) {
   // Copy alternative services with probability greater than or equal to the
   // threshold into |alternative_services_above_threshold|.
   AlternativeServiceVector alternative_services_above_threshold;
   const base::Time now = base::Time::Now();
   AlternativeServiceMap::iterator map_it = alternative_service_map_.Get(origin);
   if (map_it != alternative_service_map_.end()) {
     for (AlternativeServiceInfoVector::iterator it = map_it->second.begin();
          it != map_it->second.end();) {
       if (it->expiration < now) {
         it = map_it->second.erase(it);
         continue;
       }
       if (it->probability == 0 ||
           it->probability < alternative_service_probability_threshold_) {
         ++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()) &&
+      if (origin.scheme() == "https" &&

[Ryan Hamilton, 2016/03/24 22:23:14]

I don't understand this check. Can you say more?

[Zhongyi Shi, 2016/04/04 18:58:35]

I thought we want to check whether the alt-svc is equivalent to origin. But, I
think you're right, we are actually checking whether there's a job already
running. So no need to check the origin's scheme. 

+          origin.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;
       }
       alternative_services_above_threshold.push_back(alternative_service);
       ++it;
     }
     if (map_it->second.empty()) {
       alternative_service_map_.Erase(map_it);
     }
     return alternative_services_above_threshold;
   }
 
-  CanonicalHostMap::const_iterator canonical = GetCanonicalHost(origin);
+  if (origin.scheme() != "https")

[Ryan Hamilton, 2016/03/24 22:23:14]

Comments.

[Zhongyi Shi, 2016/04/04 18:58:35]

Changing the CanonicalHostMap to be <SHP, SHP>, no need to check origin's scheme
anymore :D

+    return AlternativeServiceVector();
+
+  CanonicalHostMap::const_iterator canonical =
+      GetCanonicalHost(origin.host_port_pair());
   if (canonical == canonical_host_to_origin_map_.end()) {
     return AlternativeServiceVector();
   }
-  map_it = alternative_service_map_.Get(canonical->second);
+  map_it = alternative_service_map_.Get(
+      SchemeOriginPair("https", canonical->second));

[Ryan Hamilton, 2016/03/24 22:23:14]

can you use origin.scheme() instead?

[Zhongyi Shi, 2016/04/04 18:58:35]

Acknowledged.

   if (map_it == alternative_service_map_.end()) {
     return AlternativeServiceVector();
   }
   for (AlternativeServiceInfoVector::iterator it = map_it->second.begin();
        it != map_it->second.end();) {
     if (it->expiration < now) {
       it = map_it->second.erase(it);
       continue;
     }
     if (it->probability < alternative_service_probability_threshold_) {
@@ skipping 15 matching lines @@
     alternative_services_above_threshold.push_back(alternative_service);
     ++it;
   }
   if (map_it->second.empty()) {
     alternative_service_map_.Erase(map_it);
   }
   return alternative_services_above_threshold;
 }
 
 bool HttpServerPropertiesImpl::SetAlternativeService(
-    const HostPortPair& origin,
+    const SchemeOriginPair& origin,
     const AlternativeService& alternative_service,
     double alternative_probability,
     base::Time expiration) {
   return SetAlternativeServices(
       origin, AlternativeServiceInfoVector(
                   /*size=*/1,
                   AlternativeServiceInfo(alternative_service,
                                          alternative_probability, expiration)));
 }
 
 bool HttpServerPropertiesImpl::SetAlternativeServices(
-    const HostPortPair& origin,
+    const SchemeOriginPair& 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 17 matching lines @@
     // 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.
   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],
+    if (origin.scheme() == "https" &&

[Ryan Hamilton, 2016/03/24 22:23:14]

comments.

[Zhongyi Shi, 2016/04/04 18:58:35]

Done.

+        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;
+      canonical_host_to_origin_map_[canonical_host] = origin.host_port_pair();
       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) {
-  RemoveCanonicalHost(origin);
+    const SchemeOriginPair& origin) {
+  if (origin.scheme() == "https")

[Ryan Hamilton, 2016/03/24 22:23:14]

comments.

[Zhongyi Shi, 2016/04/04 18:58:35]

Acknowledged.

+    RemoveCanonicalHost(origin.host_port_pair());
 
   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_;
 }
 
 scoped_ptr<base::Value>
 HttpServerPropertiesImpl::GetAlternativeServiceInfoAsValue()
     const {
   scoped_ptr<base::ListValue> dict_list(new base::ListValue);
   for (const auto& alternative_service_map_item : alternative_service_map_) {
     scoped_ptr<base::ListValue> alternative_service_list(new base::ListValue);
-    const HostPortPair& host_port_pair = alternative_service_map_item.first;
+    const HostPortPair& host_port_pair =
+        alternative_service_map_item.first.host_port_pair();
     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();
       }
       if (IsAlternativeServiceBroken(alternative_service)) {
@@ skipping 143 matching lines @@
   quic_server_info_map_.Swap(temp_map);
 }
 
 void HttpServerPropertiesImpl::SetAlternativeServiceProbabilityThreshold(
     double threshold) {
   alternative_service_probability_threshold_ = threshold;
 }
 
 AlternativeServiceMap::const_iterator
 HttpServerPropertiesImpl::GetAlternateProtocolIterator(
-    const HostPortPair& server) {
+    const SchemeOriginPair& 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 (server.scheme() != "https")
+    return alternative_service_map_.end();
+
+  CanonicalHostMap::const_iterator canonical =
+      GetCanonicalHost(server.host_port_pair());
   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);
+  it = alternative_service_map_.Get(
+      SchemeOriginPair("https", canonical_host_port));
   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();
     }
@@ skipping 60 matching lines @@
         if (alternative_service == expired_alternative_service) {
           it = map_it->second.erase(it);
           continue;
         }
         ++it;
       }
       // If an origin has an empty list of alternative services, then remove it
       // from both |canonical_host_to_origin_map_| and
       // |alternative_service_map_|.
       if (map_it->second.empty()) {
-        RemoveCanonicalHost(map_it->first);
+        RemoveCanonicalHost(map_it->first.host_port_pair());
         map_it = alternative_service_map_.Erase(map_it);
         continue;
       }
       ++map_it;
     }
   }
   ScheduleBrokenAlternateProtocolMappingsExpiration();
 }
 
 void
 HttpServerPropertiesImpl::ScheduleBrokenAlternateProtocolMappingsExpiration() {
   if (broken_alternative_services_.empty()) {
     return;
   }
   base::TimeTicks now = base::TimeTicks::Now();
   base::TimeTicks when = broken_alternative_services_.front().second;
   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