Do not mark alternate-protocol broken unless the main job succeeds.

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 90 matching lines @@
       using_existing_quic_session_(false),
       force_spdy_always_(HttpStreamFactory::force_spdy_always()),
       force_spdy_over_ssl_(HttpStreamFactory::force_spdy_over_ssl()),
       spdy_certificate_error_(OK),
       establishing_tunnel_(false),
       was_npn_negotiated_(false),
       protocol_negotiated_(kProtoUnknown),
       num_streams_(0),
       spdy_session_direct_(false),
       existing_available_pipeline_(false),
+      job_status_(STATUS_RUNNING),
+      other_job_status_(STATUS_RUNNING),
       ptr_factory_(this) {
   DCHECK(stream_factory);
   DCHECK(session);
 }
 
 HttpStreamFactoryImpl::Job::~Job() {
   net_log_.EndEvent(NetLog::TYPE_HTTP_STREAM_JOB);
 
   // When we're in a partially constructed state, waiting for the user to
   // provide certificate handling information or authentication, we can't reuse
@@ skipping 386 matching lines @@
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(&Job::OnHttpsProxyTunnelResponseCallback,
                      ptr_factory_.GetWeakPtr(),
                      *proxy_socket->GetConnectResponseInfo(),
                      proxy_socket->CreateConnectResponseStream()));
       return ERR_IO_PENDING;
     }
 
     case OK:
+      job_status_ = STATUS_SUCCEEDED;
+      MaybeMarkAlternateProtocolBroken();
       next_state_ = STATE_DONE;
       if (new_spdy_session_.get()) {
         base::MessageLoop::current()->PostTask(
             FROM_HERE,
             base::Bind(&Job::OnNewSpdySessionReadyCallback,
                        ptr_factory_.GetWeakPtr()));
       } else if (stream_factory_->for_websockets_) {
         DCHECK(websocket_stream_);
         base::MessageLoop::current()->PostTask(
             FROM_HERE,
             base::Bind(&Job::OnWebSocketHandshakeStreamReadyCallback,
                        ptr_factory_.GetWeakPtr()));
       } else {
         DCHECK(stream_.get());
         base::MessageLoop::current()->PostTask(
             FROM_HERE,
             base::Bind(&Job::OnStreamReadyCallback, ptr_factory_.GetWeakPtr()));
       }
       return ERR_IO_PENDING;
 
     default:
+      if (job_status_ != STATUS_BROKEN) {
+        DCHECK_EQ(STATUS_RUNNING, job_status_);
+        job_status_ = STATUS_FAILED;
+        MaybeMarkAlternateProtocolBroken();
+      }
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(&Job::OnStreamFailedCallback, ptr_factory_.GetWeakPtr(),
                      result));
       return ERR_IO_PENDING;
   }
 }
 
 int HttpStreamFactoryImpl::Job::DoLoop(int result) {
   DCHECK_NE(next_state_, STATE_NONE);
@@ skipping 423 matching lines @@
     // SSL socket, but there was an error before that could happen.  This
     // puts the in progress HttpProxy socket into |connection_| in order to
     // complete the auth (or read the response body).  The tunnel restart code
     // is careful to remove it before returning control to the rest of this
     // class.
     connection_.reset(connection_->release_pending_http_proxy_connection());
     return result;
   }
 
   if (!ssl_started && result < 0 && original_url_.get()) {
-    HistogramBrokenAlternateProtocolLocation(
-        BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_IMPL_JOB);
-    // Mark the alternate protocol as broken and fallback.
-    session_->http_server_properties()->SetBrokenAlternateProtocol(
-        HostPortPair::FromURL(*original_url_));
+    job_status_ = STATUS_BROKEN;
+    MaybeMarkAlternateProtocolBroken();
     return result;
   }
 
   if (using_quic_) {
     if (result < 0)
       return result;
     stream_ = quic_request_.ReleaseStream();
     next_state_ = STATE_NONE;
     return OK;
   }
@@ skipping 464 matching lines @@
   } else if (original_url_) {
     // This job was the alternate protocol job, and hence won the race.
     HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_WON_RACE);
   } else {
     // This job was the normal job, and hence the alternate protocol job lost
     // the race.
     HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_LOST_RACE);
   }
 }
 
+void HttpStreamFactoryImpl::Job::MarkOtherJobComplete(const Job& job) {
+  DCHECK_EQ(STATUS_RUNNING, other_job_status_);
+  other_job_status_ = job.job_status_;
+  MaybeMarkAlternateProtocolBroken();
+}
+
 bool HttpStreamFactoryImpl::Job::IsRequestEligibleForPipelining() {
   if (IsPreconnecting() || !request_) {
     return false;
   }
   if (stream_factory_->for_websockets_) {
     return false;
   }
   if (session_->force_http_pipelining()) {
     return true;
   }
   if (!session_->params().http_pipelining_enabled) {
     return false;
   }
   if (using_ssl_) {
     return false;
   }
   if (request_info_.method != "GET" && request_info_.method != "HEAD") {
     return false;
   }
   if (request_info_.load_flags &
       (net::LOAD_MAIN_FRAME | net::LOAD_SUB_FRAME | net::LOAD_PREFETCH |
        net::LOAD_IS_DOWNLOAD)) {
     // Avoid pipelining resources that may be streamed for a long time.
     return false;
   }
   return stream_factory_->http_pipelined_host_pool_.IsKeyEligibleForPipelining(
       *http_pipelining_key_.get());
 }
 
+void HttpStreamFactoryImpl::Job::MaybeMarkAlternateProtocolBroken() {
+  if (job_status_ == STATUS_RUNNING || other_job_status_ == STATUS_RUNNING)
+    return;
+
+  bool is_alternate_protocol_job = original_url_.get();
+  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_));
+    }
+    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));
+  }
+}
+
 }  // namespace net