Make GetAlternateProtocol return AlternativeService.

net/http/http_stream_factory_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_stream_factory_impl.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 168 matching lines @@
 
   if (!session_->params().use_alternate_protocols)
     return kNoAlternativeService;
 
   if (original_url.SchemeIs("ftp"))
     return kNoAlternativeService;
 
   HostPortPair origin = HostPortPair::FromURL(original_url);
   HttpServerProperties& http_server_properties =
       *session_->http_server_properties();
-  const AlternateProtocolInfo alternate =
-      http_server_properties.GetAlternateProtocol(origin);
+  const AlternativeService alternative_service =
+      http_server_properties.GetAlternativeService(origin);
 
-  if (alternate.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL)
+  if (alternative_service.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL)
     return kNoAlternativeService;
-  const AlternativeService alternative_service(alternate.protocol,
-                                               origin.host(), alternate.port);
+  // TODO(bnc):  Make sure that callers connect to the specified host, and that
+  // certificate requirements are enforced.  Then remove the following two
+  // lines.
+  if (alternative_service.host != origin.host())
+    return kNoAlternativeService;
   if (http_server_properties.IsAlternativeServiceBroken(alternative_service)) {
     HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_BROKEN);
     return kNoAlternativeService;
   }
-  if (!IsAlternateProtocolValid(alternate.protocol)) {
+  if (!IsAlternateProtocolValid(alternative_service.protocol)) {
     NOTREACHED();
     return kNoAlternativeService;
   }
 
   // Some shared unix systems may have user home directories (like
   // http://foo.com/~mike) which allow users to emit headers.  This is a bad
   // idea already, but with Alternate-Protocol, it provides the ability for a
   // single user on a multi-user system to hijack the alternate protocol.
   // These systems also enforce ports <1024 as restricted ports.  So don't
   // allow protocol upgrades to user-controllable ports.
   const int kUnrestrictedPort = 1024;
   if (!session_->params().enable_user_alternate_protocol_ports &&
-      (alternate.port >= kUnrestrictedPort &&
+      (alternative_service.port >= kUnrestrictedPort &&
        origin.port() < kUnrestrictedPort))
     return kNoAlternativeService;
 
-  origin.set_port(alternate.port);
-  if (alternate.protocol >= NPN_SPDY_MINIMUM_VERSION &&
-      alternate.protocol <= NPN_SPDY_MAXIMUM_VERSION) {
+  origin.set_port(alternative_service.port);
+  if (alternative_service.protocol >= NPN_SPDY_MINIMUM_VERSION &&
+      alternative_service.protocol <= NPN_SPDY_MAXIMUM_VERSION) {
     if (!HttpStreamFactory::spdy_enabled())
       return kNoAlternativeService;
 
     if (session_->HasSpdyExclusion(origin))
       return kNoAlternativeService;
 
-    *alternate_url = UpgradeUrlToHttps(original_url, alternate.port);
+    *alternate_url = UpgradeUrlToHttps(original_url, alternative_service.port);
   } else {
-    DCHECK_EQ(QUIC, alternate.protocol);
+    DCHECK_EQ(QUIC, alternative_service.protocol);
     if (!session_->params().enable_quic)
       return kNoAlternativeService;
 
     // TODO(rch):  Figure out how to make QUIC iteract with PAC
     // scripts.  By not re-writing the URL, we will query the PAC script
     // for the proxy to use to reach the original URL via TCP.  But
     // the alternate request will be going via UDP to a different port.
     *alternate_url = original_url;
   }
-  return AlternativeService(alternate.protocol, origin.host(), alternate.port);
+  return alternative_service;
 }
 
 void HttpStreamFactoryImpl::OrphanJob(Job* job, const Request* request) {
   DCHECK(ContainsKey(request_map_, job));
   DCHECK_EQ(request_map_[job], request);
   DCHECK(!ContainsKey(orphaned_job_set_, job));
 
   request_map_.erase(job);
 
   orphaned_job_set_.insert(job);
@@ skipping 48 matching lines @@
   delete job;
 }
 
 void HttpStreamFactoryImpl::OnPreconnectsComplete(const Job* job) {
   preconnect_job_set_.erase(job);
   delete job;
   OnPreconnectsCompleteInternal();
 }
 
 }  // namespace net