Change GetAlternativeServies to return alternative service infos.

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 204 matching lines @@
 }
 
 bool HttpServerPropertiesImpl::SupportsRequestPriority(
     const url::SchemeHostPort& server) {
   DCHECK(CalledOnValidThread());
   if (server.host().empty())
     return false;
 
   if (GetSupportsSpdy(server))
     return true;
-  const AlternativeServiceVector alternative_service_vector =
-      GetAlternativeServices(server);
-  for (const AlternativeService& alternative_service :
-       alternative_service_vector) {
-    if (alternative_service.protocol == kProtoQUIC) {
+  const AlternativeServiceInfoVector alternative_service_info_vector =
+      GetAlternativeServiceInfos(server);
+  for (const AlternativeServiceInfo& alternative_service_info :
+       alternative_service_info_vector) {
+    if (alternative_service_info.alternative_service.protocol == kProtoQUIC) {
       return true;
     }
   }
   return false;
 }
 
 bool HttpServerPropertiesImpl::GetSupportsSpdy(
     const url::SchemeHostPort& server) {
   DCHECK(CalledOnValidThread());
   if (server.host().empty())
@@ skipping 52 matching lines @@
   // suffix.
   for (const std::string& canonical_suffix : canonical_suffixes_) {
     if (base::EndsWith(host, canonical_suffix,
                        base::CompareCase::INSENSITIVE_ASCII)) {
       return &canonical_suffix;
     }
   }
   return nullptr;
 }
 
-AlternativeServiceVector HttpServerPropertiesImpl::GetAlternativeServices(
+AlternativeServiceInfoVector
+HttpServerPropertiesImpl::GetAlternativeServiceInfos(
     const url::SchemeHostPort& origin) {
-  // Copy valid alternative services into |valid_alternative_services|.
-  AlternativeServiceVector valid_alternative_services;
+  // Copy valid alternative service infos into
+  // |valid_alternative_service_infos|.
+  AlternativeServiceInfoVector valid_alternative_service_infos;
   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), skip it.
       if (host_port_pair.Equals(alternative_service.host_port_pair()) &&
           alternative_service.protocol == kProtoHTTP2) {
         ++it;
         continue;
       }
-      valid_alternative_services.push_back(alternative_service);
+      valid_alternative_service_infos.push_back(
+          AlternativeServiceInfo(alternative_service, it->expiration));

[Ryan Hamilton, 2017/05/18 17:45:33]

Can you just push_back(*it)?

[Zhongyi Shi, 2017/05/18 19:24:38]

Unfortunately, I couldn't. If the it->alternative_service has an empty host
name, the returned alt svc will need to have the host name filled in. 
Using *it requires us to modify alt svc in memory, which will introduces changes
in Get(Broken)AlternativeServicesAsValue.

I am trying to be conservative in this CL. We could have a follow up to decide
whether we want to fill in the empty host names for alternative service map.

[Ryan Hamilton, 2017/05/18 19:59:46]

Ah, yes. Good point. 

       ++it;
     }
     if (map_it->second.empty()) {
       alternative_service_map_.Erase(map_it);
     }
-    return valid_alternative_services;
+    return valid_alternative_service_infos;
   }
 
   CanonicalHostMap::const_iterator canonical = GetCanonicalHost(origin);
   if (canonical == canonical_host_to_origin_map_.end()) {
-    return AlternativeServiceVector();
+    return AlternativeServiceInfoVector();
   }
   map_it = alternative_service_map_.Get(canonical->second);
   if (map_it == alternative_service_map_.end()) {
-    return AlternativeServiceVector();
+    return AlternativeServiceInfoVector();
   }
   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 = canonical->second.host();
       if (IsAlternativeServiceBroken(alternative_service)) {
         ++it;
         continue;
       }
       alternative_service.host = origin.host();
     } else if (IsAlternativeServiceBroken(alternative_service)) {
       ++it;
       continue;
     }
-    valid_alternative_services.push_back(alternative_service);
+    valid_alternative_service_infos.push_back(
+        AlternativeServiceInfo(alternative_service, it->expiration));
     ++it;
   }
   if (map_it->second.empty()) {
     alternative_service_map_.Erase(map_it);
   }
-  return valid_alternative_services;
+  return valid_alternative_service_infos;
 }
 
 bool HttpServerPropertiesImpl::SetAlternativeService(
     const url::SchemeHostPort& origin,
     const AlternativeService& alternative_service,
     base::Time expiration) {
   return SetAlternativeServices(
       origin,
       AlternativeServiceInfoVector(
           /*size=*/1, AlternativeServiceInfo(alternative_service, expiration)));
@@ skipping 40 matching lines @@
       }
     }
   }
 
   const bool previously_no_alternative_services =
       (GetAlternateProtocolIterator(origin) == alternative_service_map_.end());
 
   alternative_service_map_.Put(origin, alternative_service_info_vector);
 
   if (previously_no_alternative_services &&
-      !GetAlternativeServices(origin).empty()) {
+      !GetAlternativeServiceInfos(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,
                                     false);
   }
 
   // If this host ends with a canonical suffix, then set it as the
   // canonical host.
   const char* kCanonicalScheme = "https";
@@ skipping 323 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