Reland rest of r77399.

net/http/http_stream_factory_impl_request.cc

 // Copyright (c) 2011 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_request.h"
 
 #include "base/logging.h"
 #include "base/stl_util-inl.h"
 #include "net/http/http_stream_factory_impl_job.h"
 #include "net/spdy/spdy_http_stream.h"
 #include "net/spdy/spdy_session.h"
 
 namespace net {
 
 HttpStreamFactoryImpl::Request::Request(const GURL& url,
                                         HttpStreamFactoryImpl* factory,
                                         HttpStreamRequest::Delegate* delegate,
                                         const BoundNetLog& net_log)
     : url_(url),
       factory_(factory),
       delegate_(delegate),
       net_log_(net_log),
       completed_(false),
-      was_alternate_protocol_available_(false),
       was_npn_negotiated_(false),
       using_spdy_(false) {
   DCHECK(factory_);
   DCHECK(delegate_);
 
   net_log_.BeginEvent(NetLog::TYPE_HTTP_STREAM_REQUEST, NULL);
 }
 
 HttpStreamFactoryImpl::Request::~Request() {
   if (bound_job_.get())
@@ skipping 21 matching lines @@
   request_set.insert(this);
 }
 
 void HttpStreamFactoryImpl::Request::AttachJob(Job* job) {
   DCHECK(job);
   jobs_.insert(job);
   factory_->request_map_[job] = this;
 }
 
 void HttpStreamFactoryImpl::Request::Complete(
-    bool was_alternate_protocol_available,
     bool was_npn_negotiated,
     bool using_spdy,
     const NetLog::Source& job_source) {
   DCHECK(!completed_);
   completed_ = true;
-  was_alternate_protocol_available_ = was_alternate_protocol_available;
   was_npn_negotiated_ = was_npn_negotiated;
   using_spdy_ = using_spdy;
   net_log_.AddEvent(
       NetLog::TYPE_HTTP_STREAM_REQUEST_BOUND_TO_JOB,
       make_scoped_refptr(new NetLogSourceParameter(
           "source_dependency", job_source)));
 }
 
 void HttpStreamFactoryImpl::Request::OnStreamReady(
     Job* job,
@@ skipping 24 matching lines @@
     DCHECK(jobs_.empty());
   }
   delegate_->OnStreamReady(used_ssl_config, used_proxy_info, stream);
 }
 
 void HttpStreamFactoryImpl::Request::OnStreamFailed(
     Job* job,
     int status,
     const SSLConfig& used_ssl_config) {
   DCHECK_NE(OK, status);
-  if (!bound_job_.get())
-    OrphanJobsExcept(job);
-  else
+  if (!bound_job_.get()) {
+    // Hey, we've got other jobs! Maybe one of them will succeed, let's just
+    // ignore this failure.
+    if (jobs_.size() > 1) {
+      jobs_.erase(job);
+      factory_->request_map_.erase(job);
+      delete job;
+      return;
+    } else {
+      bound_job_.reset(job);
+      jobs_.erase(job);
+      DCHECK(jobs_.empty());
+      factory_->request_map_.erase(job);
+    }
+  } else {
     DCHECK(jobs_.empty());
+  }
   delegate_->OnStreamFailed(status, used_ssl_config);
 }
 
 void HttpStreamFactoryImpl::Request::OnCertificateError(
     Job* job,
     int status,
     const SSLConfig& used_ssl_config,
     const SSLInfo& ssl_info) {
   DCHECK_NE(OK, status);
   if (!bound_job_.get())
@@ skipping 51 matching lines @@
 
 LoadState HttpStreamFactoryImpl::Request::GetLoadState() const {
   if (bound_job_.get())
     return bound_job_->GetLoadState();
   DCHECK(!jobs_.empty());
 
   // Just pick the first one.
   return (*jobs_.begin())->GetLoadState();
 }
 
-bool HttpStreamFactoryImpl::Request::was_alternate_protocol_available() const {
-  DCHECK(completed_);
-  return was_alternate_protocol_available_;
-}
-
 bool HttpStreamFactoryImpl::Request::was_npn_negotiated() const {
   DCHECK(completed_);
   return was_npn_negotiated_;
 }
 
 bool HttpStreamFactoryImpl::Request::using_spdy() const {
   DCHECK(completed_);
   return using_spdy_;
 }
 
@@ skipping 24 matching lines @@
   if (!bound_job_.get()) {
     OrphanJobsExcept(job);
   } else { // This is the case for HTTPS proxy tunneling.
     DCHECK_EQ(bound_job_.get(), job);
     DCHECK(jobs_.empty());
   }
 
   // Cache these values in case the job gets deleted.
   const SSLConfig used_ssl_config = job->ssl_config();
   const ProxyInfo used_proxy_info = job->proxy_info();
-  const bool was_alternate_protocol_available =
-      job->was_alternate_protocol_available();
   const bool was_npn_negotiated = job->was_npn_negotiated();
   const bool using_spdy = job->using_spdy();
   const NetLog::Source source = job->net_log().source();
 
-  Complete(was_alternate_protocol_available,
-           was_npn_negotiated,
+  Complete(was_npn_negotiated,
            using_spdy,
            source);
 
   // Cache this so we can still use it if the request is deleted.
   HttpStreamFactoryImpl* factory = factory_;
 
   bool use_relative_url = direct || url().SchemeIs("https");
   delegate_->OnStreamReady(
       job->ssl_config(),
       job->proxy_info(),
       new SpdyHttpStream(spdy_session, use_relative_url));
   // |this| may be deleted after this point.
   factory->OnSpdySessionReady(
       spdy_session, direct, used_ssl_config, used_proxy_info,
-      was_alternate_protocol_available, was_npn_negotiated, using_spdy, source);
+      was_npn_negotiated, using_spdy, source);
 }
 
 void HttpStreamFactoryImpl::Request::OrphanJobsExcept(Job* job) {
   DCHECK(job);
   DCHECK(!bound_job_.get());
   DCHECK(ContainsKey(jobs_, job));
   bound_job_.reset(job);
   jobs_.erase(job);
   factory_->request_map_.erase(job);
 
   OrphanJobs();
 }
 
 void HttpStreamFactoryImpl::Request::OrphanJobs() {
   RemoveRequestFromSpdySessionRequestMap();
 
   std::set<Job*> tmp;
   tmp.swap(jobs_);
 
   for (std::set<Job*>::iterator it = tmp.begin(); it != tmp.end(); ++it)
     factory_->OrphanJob(*it, this);
 }
 
 }  // namespace net