ABANDONED Handle multiple AlternateProtocols for each HostPortPair.

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"
@@ skipping 54 matching lines @@
   dict->SetString("proto", *proto);
   return dict;
 }
 
 HttpStreamFactoryImpl::Job::Job(HttpStreamFactoryImpl* stream_factory,
                                 HttpNetworkSession* session,
                                 const HttpRequestInfo& request_info,
                                 RequestPriority priority,
                                 const SSLConfig& server_ssl_config,
                                 const SSLConfig& proxy_ssl_config,
-                                NetLog* net_log)
+                                NetLog* net_log,
+                                AlternateProtocolInfo alternate_protocol)
     : request_(NULL),
       request_info_(request_info),
       priority_(priority),
       server_ssl_config_(server_ssl_config),
       proxy_ssl_config_(proxy_ssl_config),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_HTTP_STREAM_JOB)),
       io_callback_(base::Bind(&Job::OnIOComplete, base::Unretained(this))),
       connection_(new ClientSocketHandle),
       session_(session),
       stream_factory_(stream_factory),
       next_state_(STATE_NONE),
       pac_request_(NULL),
+      alternate_protocol_(alternate_protocol),
       blocking_job_(NULL),
       waiting_job_(NULL),
       using_ssl_(false),
       using_spdy_(false),
       using_quic_(false),
       quic_request_(session_->quic_stream_factory()),
       using_existing_quic_session_(false),
       spdy_certificate_error_(OK),
       establishing_tunnel_(false),
       was_npn_negotiated_(false),
@@ skipping 58 matching lines @@
     case STATE_RESOLVE_PROXY_COMPLETE:
       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,
-    AlternateProtocolInfo alternate) {
+void HttpStreamFactoryImpl::Job::MarkAsAlternate(const GURL& original_url) {
   DCHECK(!original_url_.get());
   original_url_.reset(new GURL(original_url));
-  if (alternate.protocol == QUIC) {
+  if (alternate_protocol_.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_);
   DCHECK(!blocking_job_);
   DCHECK(!job->waiting_job_);
@@ skipping 1277 matching lines @@
 void HttpStreamFactoryImpl::Job::MaybeMarkAlternateProtocolBroken() {
   if (job_status_ == STATUS_RUNNING || other_job_status_ == STATUS_RUNNING)
     return;
 
   bool is_alternate_protocol_job = original_url_.get() != NULL;
   if (is_alternate_protocol_job) {
     if (job_status_ == STATUS_BROKEN && other_job_status_ == STATUS_SUCCEEDED) {
       HistogramBrokenAlternateProtocolLocation(
           BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_IMPL_JOB_ALT);
       session_->http_server_properties()->SetBrokenAlternateProtocol(
-          HostPortPair::FromURL(*original_url_));
+          HostPortPair::FromURL(*original_url_), alternate_protocol_);
     }
     return;
   }
 
   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()->SetBrokenAlternateProtocol(
-        HostPortPair::FromURL(request_info_.url));
+        HostPortPair::FromURL(request_info_.url), alternate_protocol_);
   }
 }
 
 }  // namespace net