Remove the "alternate_url" outparam from

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"
-#include "base/strings/string_number_conversions.h"
 #include "net/base/net_util.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties.h"
 #include "net/http/http_stream_factory_impl_job.h"
 #include "net/http/http_stream_factory_impl_request.h"
 #include "net/log/net_log.h"
 #include "net/spdy/spdy_http_stream.h"
 #include "url/gurl.h"
 
 namespace net {
 
-namespace {
-
-GURL UpgradeUrlToHttps(const GURL& original_url, int 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(port);
-  replacements.SetSchemeStr("https");
-  replacements.SetPortStr(new_port);
-  return original_url.ReplaceComponents(replacements);
-}
-
-}  // namespace
-
 HttpStreamFactoryImpl::HttpStreamFactoryImpl(HttpNetworkSession* session,
                                              bool for_websockets)
     : session_(session),
       for_websockets_(for_websockets) {}
 
 HttpStreamFactoryImpl::~HttpStreamFactoryImpl() {
   DCHECK(request_map_.empty());
   DCHECK(spdy_session_request_map_.empty());
 
   std::set<const Job*> tmp_job_set;
@@ skipping 50 matching lines @@
     const SSLConfig& proxy_ssl_config,
     HttpStreamRequest::Delegate* delegate,
     WebSocketHandshakeStreamBase::CreateHelper*
         websocket_handshake_stream_create_helper,
     const BoundNetLog& net_log) {
   Request* request = new Request(request_info.url,
                                  this,
                                  delegate,
                                  websocket_handshake_stream_create_helper,
                                  net_log);
+  Job* job = new Job(this, session_, request_info, priority, server_ssl_config,
+                     proxy_ssl_config, net_log.net_log());
+  request->AttachJob(job);
 
-  // TODO(bnc): Get rid of |alternate_url|.
-  GURL alternate_url;
   AlternativeService alternative_service =
-      GetAlternativeServiceRequestFor(request_info.url, &alternate_url);
-  Job* alternate_job = NULL;
+      GetAlternativeServiceFor(request_info.url);
   if (alternative_service.protocol != UNINITIALIZED_ALTERNATE_PROTOCOL) {
     // Never share connection with other jobs for FTP requests.
     DCHECK(!request_info.url.SchemeIs("ftp"));
 
-    HttpRequestInfo alternate_request_info = request_info;
-    alternate_request_info.url = alternate_url;
-    alternate_job =
-        new Job(this, session_, alternate_request_info, priority,
-                server_ssl_config, proxy_ssl_config, net_log.net_log());
+    Job* alternate_job =
+        new Job(this, session_, request_info, priority, server_ssl_config,
+                proxy_ssl_config, net_log.net_log());
     request->AttachJob(alternate_job);
-    alternate_job->MarkAsAlternate(request_info.url, alternative_service);
-  }
+    alternate_job->MarkAsAlternate(alternative_service);
 
-  Job* job = new Job(this, session_, request_info, priority,
-                     server_ssl_config, proxy_ssl_config, net_log.net_log());
-  request->AttachJob(job);
-  if (alternate_job) {
     // Never share connection with other jobs for FTP requests.
     DCHECK(!request_info.url.SchemeIs("ftp"));
 
     job->WaitFor(alternate_job);
     // Make sure to wait until we call WaitFor(), before starting
     // |alternate_job|, otherwise |alternate_job| will not notify |job|
     // appropriately.
     alternate_job->Start(request);
   }
+
   // Even if |alternate_job| has already finished, it won't have notified the
   // request yet, since we defer that to the next iteration of the MessageLoop,
   // so starting |job| is always safe.
   job->Start(request);
   return request;
 }
 
 void HttpStreamFactoryImpl::PreconnectStreams(
     int num_streams,
     const HttpRequestInfo& request_info,
     RequestPriority priority,
     const SSLConfig& server_ssl_config,
     const SSLConfig& proxy_ssl_config) {
   DCHECK(!for_websockets_);
-  GURL alternate_url;
   AlternativeService alternative_service =
-      GetAlternativeServiceRequestFor(request_info.url, &alternate_url);
-  Job* job = NULL;
+      GetAlternativeServiceFor(request_info.url);
+  Job* job = new Job(this, session_, request_info, priority, server_ssl_config,
+                     proxy_ssl_config, session_->net_log());
   if (alternative_service.protocol != UNINITIALIZED_ALTERNATE_PROTOCOL) {
-    HttpRequestInfo alternate_request_info = request_info;
-    alternate_request_info.url = alternate_url;
-    job = new Job(this, session_, alternate_request_info, priority,
-                  server_ssl_config, proxy_ssl_config, session_->net_log());
-    job->MarkAsAlternate(request_info.url, alternative_service);
-  } else {
-    job = new Job(this, session_, request_info, priority,
-                  server_ssl_config, proxy_ssl_config, session_->net_log());
+    job->MarkAsAlternate(alternative_service);
   }
   preconnect_job_set_.insert(job);
   job->Preconnect(num_streams);
 }
 
 const HostMappingRules* HttpStreamFactoryImpl::GetHostMappingRules() const {
   return session_->params().host_mapping_rules;
 }
 
-AlternativeService HttpStreamFactoryImpl::GetAlternativeServiceRequestFor(
-    const GURL& original_url,
-    GURL* alternate_url) {
+AlternativeService HttpStreamFactoryImpl::GetAlternativeServiceFor(
+    const GURL& original_url) {
   const AlternativeService kNoAlternativeService;
 
   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 =
@@ skipping 31 matching lines @@
 
   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, alternative_service.port);
-  } else {
-    DCHECK_EQ(QUIC, alternative_service.protocol);
-    if (!session_->params().enable_quic)
-      return kNoAlternativeService;
+    return alternative_service;
+  }
 
-    if (session_->quic_stream_factory()->IsQuicDisabled(origin.port()))
-      return kNoAlternativeService;
+  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;
-  }
+  if (session_->quic_stream_factory()->IsQuicDisabled(origin.port()))
+    return kNoAlternativeService;
+
   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);
 
@@ skipping 49 matching lines @@
   delete job;
 }
 
 void HttpStreamFactoryImpl::OnPreconnectsComplete(const Job* job) {
   preconnect_job_set_.erase(job);
   delete job;
   OnPreconnectsCompleteInternal();
 }
 
 }  // namespace net