Remove the "alternate_url" outparam from

net/http/http_stream_factory_impl_job.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_job.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/stl_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "net/base/connection_type_histograms.h"
 #include "net/base/net_util.h"
 #include "net/http/http_basic_stream.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_proxy_client_socket.h"
 #include "net/http/http_proxy_client_socket_pool.h"
@@ skipping 12 matching lines @@
 #include "net/spdy/spdy_http_stream.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/ssl/ssl_cert_request_info.h"
 
 namespace net {
 
 // Returns parameters associated with the start of a HTTP stream job.
 base::Value* NetLogHttpStreamJobCallback(const GURL* original_url,
                                          const GURL* url,
+                                         const GURL* alternate_url,
                                          RequestPriority priority,
                                          NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("original_url", original_url->GetOrigin().spec());
   dict->SetString("url", url->GetOrigin().spec());
+  dict->SetString("alternate_service_url", alternate_url->GetOrigin().spec());
   dict->SetString("priority", RequestPriorityToString(priority));
   return dict;
 }
 
 // Returns parameters associated with the Proto (with NPN negotiation) of a HTTP
 // stream.
 base::Value* NetLogHttpStreamProtoCallback(
     const SSLClientSocket::NextProtoStatus status,
     const std::string* proto,
     NetLog::LogLevel /* log_level */) {
@@ skipping 97 matching lines @@
       return session_->proxy_service()->GetLoadState(pac_request_);
     case STATE_INIT_CONNECTION_COMPLETE:
     case STATE_CREATE_STREAM_COMPLETE:
       return using_quic_ ? LOAD_STATE_CONNECTING : connection_->GetLoadState();
     default:
       return LOAD_STATE_IDLE;
   }
 }
 
 void HttpStreamFactoryImpl::Job::MarkAsAlternate(
-    const GURL& original_url,
     AlternativeService alternative_service) {
   DCHECK(!IsAlternate());
-  original_url_ = original_url;
   alternative_service_ = alternative_service;
   if (alternative_service.protocol == QUIC) {
     DCHECK(session_->params().enable_quic);
     using_quic_ = true;
   }
 }
 
 void HttpStreamFactoryImpl::Job::WaitFor(Job* job) {
   DCHECK_EQ(STATE_NONE, next_state_);
   DCHECK_EQ(STATE_NONE, job->next_state_);
@@ skipping 95 matching lines @@
 }
 
 bool HttpStreamFactoryImpl::Job::CanUseExistingSpdySession() const {
   // We need to make sure that if a spdy session was created for
   // https://somehost/ that we don't use that session for http://somehost:443/.
   // The only time we can use an existing session is if the request URL is
   // https (the normal case) or if we're connection to a SPDY proxy, or
   // if we're running with force_spdy_always_.  crbug.com/133176
   // TODO(ricea): Add "wss" back to this list when SPDY WebSocket support is
   // working.
-  return request_info_.url.SchemeIs("https") ||
+  return alternative_service_url_.SchemeIs("https") ||
          proxy_info_.proxy_server().is_https() ||
          session_->params().force_spdy_always;
 }
 
 void HttpStreamFactoryImpl::Job::OnStreamReadyCallback() {
   DCHECK(stream_.get());
   DCHECK(!IsPreconnecting());
   DCHECK(!stream_factory_->for_websockets_);
   if (IsOrphaned()) {
     stream_factory_->OnOrphanedJobComplete(this);
@@ skipping 315 matching lines @@
 }
 
 int HttpStreamFactoryImpl::Job::DoStart() {
   if (IsAlternate()) {
     server_ = alternative_service_.host_port_pair();
   } else {
     server_ = HostPortPair::FromURL(request_info_.url);
   }
   origin_url_ =
       stream_factory_->ApplyHostMappingRules(request_info_.url, &server_);
+  alternative_service_url_ = origin_url_;
+  // For SPDY via Alt-Svc, set |alternative_service_url_| to
+  // https://<alternative host>:<alternative port>/...
+  // so the proxy resolution works with the actual destination, and so
+  // that the correct socket pool is used.
+  // TODO(rch): change the socket pool API to not require a full URL.
+  if (alternative_service_.protocol >= NPN_SPDY_MINIMUM_VERSION &&
+      alternative_service_.protocol <= NPN_SPDY_MAXIMUM_VERSION) {
+    // 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.
+    GURL::Replacements replacements;
+    // new_port needs to be in scope here because GURL::Replacements references
+    // the memory contained by it directly.
+    const std::string new_port = base::IntToString(alternative_service_.port);
+    replacements.SetSchemeStr("https");
+    replacements.SetPortStr(new_port);
+    alternative_service_url_ =
+        alternative_service_url_.ReplaceComponents(replacements);
+  }
 
-  net_log_.BeginEvent(NetLog::TYPE_HTTP_STREAM_JOB,
-                      base::Bind(&NetLogHttpStreamJobCallback,
-                                 &request_info_.url, &origin_url_,
-                                 priority_));
+  net_log_.BeginEvent(
+      NetLog::TYPE_HTTP_STREAM_JOB,
+      base::Bind(&NetLogHttpStreamJobCallback, &request_info_.url, &origin_url_,
+                 &alternative_service_url_, priority_));
 
   // Don't connect to restricted ports.
   bool is_port_allowed = IsPortAllowedByDefault(server_.port());
   if (request_info_.url.SchemeIs("ftp")) {
     // Never share connection with other jobs for FTP requests.
     DCHECK(!waiting_job_);
 
     is_port_allowed = IsPortAllowedByFtp(server_.port());
   }
   if (!is_port_allowed && !IsPortAllowedByOverride(server_.port())) {
@@ skipping 13 matching lines @@
   DCHECK(session_);
 
   next_state_ = STATE_RESOLVE_PROXY_COMPLETE;
 
   if (request_info_.load_flags & LOAD_BYPASS_PROXY) {
     proxy_info_.UseDirect();
     return OK;
   }
 
   return session_->proxy_service()->ResolveProxy(
-      request_info_.url, request_info_.load_flags, &proxy_info_, io_callback_,
-      &pac_request_, session_->network_delegate(), net_log_);
+      alternative_service_url_, request_info_.load_flags, &proxy_info_,
+      io_callback_, &pac_request_, session_->network_delegate(), net_log_);
 }
 
 int HttpStreamFactoryImpl::Job::DoResolveProxyComplete(int result) {
   pac_request_ = NULL;
 
   if (result == OK) {
     // Remove unsupported proxies from the list.
     int supported_proxies =
         ProxyServer::SCHEME_DIRECT | ProxyServer::SCHEME_HTTP |
         ProxyServer::SCHEME_HTTPS | ProxyServer::SCHEME_SOCKS4 |
@@ skipping 65 matching lines @@
 int HttpStreamFactoryImpl::Job::DoInitConnection() {
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/462812 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "462812 HttpStreamFactoryImpl::Job::DoInitConnection"));
   DCHECK(!blocking_job_);
   DCHECK(!connection_->is_initialized());
   DCHECK(proxy_info_.proxy_server().is_valid());
   next_state_ = STATE_INIT_CONNECTION_COMPLETE;
 
-  using_ssl_ = request_info_.url.SchemeIs("https") ||
-      request_info_.url.SchemeIs("wss") || ShouldForceSpdySSL();
+  using_ssl_ = alternative_service_url_.SchemeIs("https") ||
+               alternative_service_url_.SchemeIs("wss") || ShouldForceSpdySSL();
   using_spdy_ = false;
 
   if (ShouldForceQuic())
     using_quic_ = true;
 
   DCHECK(!using_quic_ || session_->params().enable_quic);
 
   if (proxy_info_.is_quic()) {
     using_quic_ = true;
     DCHECK(session_->params().enable_quic_for_proxies);
@@ skipping 79 matching lines @@
     http_server_properties->MaybeForceHTTP11(server_, &server_ssl_config_);
     if (proxy_info_.is_http() || proxy_info_.is_https()) {
       http_server_properties->MaybeForceHTTP11(
           proxy_info_.proxy_server().host_port_pair(), &proxy_ssl_config_);
     }
   }
 
   if (IsPreconnecting()) {
     DCHECK(!stream_factory_->for_websockets_);
     return PreconnectSocketsForHttpRequest(
-        origin_url_,
-        request_info_.extra_headers,
-        request_info_.load_flags,
-        priority_,
-        session_,
-        proxy_info_,
-        ShouldForceSpdySSL(),
-        want_spdy_over_npn,
-        server_ssl_config_,
-        proxy_ssl_config_,
-        request_info_.privacy_mode,
-        net_log_,
-        num_streams_);
+        alternative_service_url_, request_info_.extra_headers,
+        request_info_.load_flags, priority_, session_, proxy_info_,
+        ShouldForceSpdySSL(), want_spdy_over_npn, server_ssl_config_,
+        proxy_ssl_config_, request_info_.privacy_mode, net_log_, num_streams_);
   }
 
-  // If we can't use a SPDY session, don't both checking for one after
+  // If we can't use a SPDY session, don't bother checking for one after
   // the hostname is resolved.
   OnHostResolutionCallback resolution_callback = CanUseExistingSpdySession() ?
       base::Bind(&Job::OnHostResolution, session_->spdy_session_pool(),
                  GetSpdySessionKey()) :
       OnHostResolutionCallback();
   if (stream_factory_->for_websockets_) {
     // TODO(ricea): Re-enable NPN when WebSockets over SPDY is supported.
     SSLConfig websocket_server_ssl_config = server_ssl_config_;
     websocket_server_ssl_config.next_protos.clear();
     return InitSocketHandleForWebSocketRequest(
         origin_url_, request_info_.extra_headers, request_info_.load_flags,
         priority_, session_, proxy_info_, ShouldForceSpdySSL(),
         want_spdy_over_npn, websocket_server_ssl_config, proxy_ssl_config_,
         request_info_.privacy_mode, net_log_,
         connection_.get(), resolution_callback, io_callback_);
   }
 
   return InitSocketHandleForHttpRequest(
-      origin_url_, request_info_.extra_headers, request_info_.load_flags,
-      priority_, session_, proxy_info_, ShouldForceSpdySSL(),
-      want_spdy_over_npn, server_ssl_config_, proxy_ssl_config_,
-      request_info_.privacy_mode, net_log_,
+      alternative_service_url_, request_info_.extra_headers,
+      request_info_.load_flags, priority_, session_, proxy_info_,
+      ShouldForceSpdySSL(), want_spdy_over_npn, server_ssl_config_,
+      proxy_ssl_config_, request_info_.privacy_mode, net_log_,
       connection_.get(), resolution_callback, io_callback_);
 }
 
 int HttpStreamFactoryImpl::Job::DoInitConnectionComplete(int result) {
   if (IsPreconnecting()) {
     if (using_quic_)
       return result;
     DCHECK_EQ(OK, result);
     return OK;
   }
@@ skipping 121 matching lines @@
     if (!connection_->is_reused()) {
       ConnectionType type = using_spdy_ ? CONNECTION_SPDY : CONNECTION_HTTP;
       UpdateConnectionTypeHistograms(type);
     }
   }
 
   // Handle SSL errors below.
   if (using_ssl_) {
     DCHECK(ssl_started);
     if (IsCertificateError(result)) {
-      if (using_spdy_ && IsAlternate() && original_url_.SchemeIs("http")) {
+      if (using_spdy_ && IsAlternate() && origin_url_.SchemeIs("http")) {
         // We ignore certificate errors for http over spdy.
         spdy_certificate_error_ = result;
         result = OK;
       } else {
         result = HandleCertificateError(result);
         if (result == OK && !connection_->socket()->IsConnectedAndIdle()) {
           ReturnToStateInitConnection(true /* close connection */);
           return result;
         }
       }
@@ skipping 183 matching lines @@
     connection_->socket()->SetOmniboxSpeculation();
   // TODO(mbelshe): Add other motivations (like EARLY_LOAD_MOTIVATED).
 }
 
 bool HttpStreamFactoryImpl::Job::IsHttpsProxyAndHttpUrl() const {
   if (!proxy_info_.is_https())
     return false;
   if (IsAlternate()) {
     // We currently only support Alternate-Protocol where the original scheme
     // is http.
-    DCHECK(original_url_.SchemeIs("http"));
-    return original_url_.SchemeIs("http");
+    DCHECK(origin_url_.SchemeIs("http"));
+    return origin_url_.SchemeIs("http");
   }
   return request_info_.url.SchemeIs("http");
 }
 
 bool HttpStreamFactoryImpl::Job::IsAlternate() const {
   return alternative_service_.protocol != UNINITIALIZED_ALTERNATE_PROTOCOL;
 }
 
 void HttpStreamFactoryImpl::Job::InitSSLConfig(const HostPortPair& server,
                                                SSLConfig* ssl_config,
@@ skipping 222 matching lines @@
 
   if (job_status_ == STATUS_SUCCEEDED && other_job_status_ == STATUS_BROKEN) {
     HistogramBrokenAlternateProtocolLocation(
         BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_IMPL_JOB_MAIN);
     session_->http_server_properties()->MarkAlternativeServiceBroken(
         other_job_alternative_service_);
   }
 }
 
 }  // namespace net