Change the AlternativeServiceMap with SchemeOriginPair key.

net/http/http_network_transaction.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_network_transaction.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 55 matching lines @@
 #include "net/ssl/token_binding.h"
 #include "url/gurl.h"
 #include "url/url_canon.h"
 
 namespace net {
 
 namespace {
 
 void ProcessAlternativeServices(HttpNetworkSession* session,
                                 const HttpResponseHeaders& headers,
-                                const HostPortPair& http_host_port_pair) {
+                                const SchemeOriginPair& scheme_origin_pair) {
   if (session->params().parse_alternative_services) {
     if (headers.HasHeader(kAlternativeServiceHeader)) {
       std::string alternative_service_str;
       headers.GetNormalizedHeader(kAlternativeServiceHeader,
                                   &alternative_service_str);
       session->http_stream_factory()->ProcessAlternativeService(
           session->http_server_properties(), alternative_service_str,
-          http_host_port_pair, *session);
+          scheme_origin_pair, *session);
     }
     // If "Alt-Svc" is enabled, then ignore "Alternate-Protocol".
     return;
   }
 
   if (!headers.HasHeader(kAlternateProtocolHeader))
     return;
 
   std::vector<std::string> alternate_protocol_values;
   size_t iter = 0;
   std::string alternate_protocol_str;
   while (headers.EnumerateHeader(&iter, kAlternateProtocolHeader,
                                  &alternate_protocol_str)) {
     base::TrimWhitespaceASCII(alternate_protocol_str, base::TRIM_ALL,
                               &alternate_protocol_str);
     if (!alternate_protocol_str.empty()) {
       alternate_protocol_values.push_back(alternate_protocol_str);
     }
   }
 
   session->http_stream_factory()->ProcessAlternateProtocol(
-      session->http_server_properties(),
-      alternate_protocol_values,
-      http_host_port_pair,
-      *session);
+      session->http_server_properties(), alternate_protocol_values,
+      scheme_origin_pair, *session);
 }
 
 scoped_ptr<base::Value> NetLogSSLVersionFallbackCallback(
     const GURL* url,
     int net_error,
     SSLFailureState ssl_failure_state,
     uint16_t version_before,
     uint16_t version_after,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
@@ skipping 1111 matching lines @@
   // We treat any other 1xx in this same way (although in practice getting
   // a 1xx that isn't a 100 is rare).
   // Unless this is a WebSocket request, in which case we pass it on up.
   if (response_.headers->response_code() / 100 == 1 &&
       !ForWebSocketHandshake()) {
     response_.headers = new HttpResponseHeaders(std::string());
     next_state_ = STATE_READ_HEADERS;
     return OK;
   }
 
+  SchemeOriginPair scheme_origin_pair =
+      SchemeOriginPair::FromURL(request_->url);
+
   ProcessAlternativeServices(session_, *response_.headers.get(),
-                             HostPortPair::FromURL(request_->url));
+                             scheme_origin_pair);
 
   int rv = HandleAuthChallenge();
   if (rv != OK)
     return rv;
 
   if (IsSecureRequest())
     stream_->GetSSLInfo(&response_.ssl_info);
 
   headers_valid_ = true;
   return OK;
@@ skipping 540 matching lines @@
   DCHECK(stream_request_);
 
   // Since the transaction can restart with auth credentials, it may create a
   // stream more than once. Accumulate all of the connection attempts across
   // those streams by appending them to the vector:
   for (const auto& attempt : stream_request_->connection_attempts())
     connection_attempts_.push_back(attempt);
 }
 
 }  // namespace net