Remove HttpStreamFactoryImpl::Job::MarkAsAlternate.

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 81 matching lines @@
   Job* job = new Job(this, session_, request_info, priority, server_ssl_config,
                      proxy_ssl_config, net_log.net_log());
   request->AttachJob(job);
 
   AlternativeService alternative_service =
       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"));
 
-    Job* alternate_job =
+    Job* alternative_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(alternative_service);
+                proxy_ssl_config, alternative_service, net_log.net_log());
+    request->AttachJob(alternative_job);
 
-    job->WaitFor(alternate_job);
+    job->WaitFor(alternative_job);
     // Make sure to wait until we call WaitFor(), before starting
-    // |alternate_job|, otherwise |alternate_job| will not notify |job|
+    // |alternative_job|, otherwise |alternative_job| will not notify |job|
     // appropriately.
-    alternate_job->Start(request);
+    alternative_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.
+  // Even if |alternative_job| has already finished, it will not 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_);
   AlternativeService alternative_service =
       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) {
-    job->MarkAsAlternate(alternative_service);
-  }
+  Job* job =
+      new Job(this, session_, request_info, priority, server_ssl_config,
+              proxy_ssl_config, alternative_service, session_->net_log());
   preconnect_job_set_.insert(job);
   job->Preconnect(num_streams);
 }
 
 const HostMappingRules* HttpStreamFactoryImpl::GetHostMappingRules() const {
   return session_->params().host_mapping_rules;
 }
 
 AlternativeService HttpStreamFactoryImpl::GetAlternativeServiceFor(
     const GURL& original_url) {
@@ skipping 120 matching lines @@
   delete job;
 }
 
 void HttpStreamFactoryImpl::OnPreconnectsComplete(const Job* job) {
   preconnect_job_set_.erase(job);
   delete job;
   OnPreconnectsCompleteInternal();
 }
 
 }  // namespace net