Mark QUIC broken when the network blackholes after the handshake

net/quic/chromium/quic_http_stream.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/quic/chromium/quic_http_stream.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/callback_helpers.h"
@@ skipping 28 matching lines @@
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("stream_id", stream_id);
   dict->SetString("url", url->spec());
   return std::move(dict);
 }
 
 }  // namespace
 
 QuicHttpStream::QuicHttpStream(
     const base::WeakPtr<QuicChromiumClientSession>& session,
-    HttpServerProperties* http_server_properties)
+    HttpServerProperties* http_server_properties,
+    bool mark_quic_broken_when_network_suspected)
     : MultiplexedHttpStream(MultiplexedSessionHandle(session)),
       next_state_(STATE_NONE),
       session_(session),
+      server_id_(session->server_id()),
       http_server_properties_(http_server_properties),
+      mark_quic_broken_when_network_suspected_(
+          mark_quic_broken_when_network_suspected),
       quic_version_(session->GetQuicVersion()),
       session_error_(ERR_UNEXPECTED),
       was_handshake_confirmed_(session->IsCryptoHandshakeConfirmed()),
       stream_(nullptr),
       request_info_(nullptr),
       request_body_stream_(nullptr),
       priority_(MINIMUM_PRIORITY),
       response_info_(nullptr),
       has_response_status_(false),
       response_status_(ERR_UNEXPECTED),
@@ skipping 249 matching lines @@
 
   return rv > 0 ? OK : rv;
 }
 
 int QuicHttpStream::ReadResponseHeaders(const CompletionCallback& callback) {
   CHECK(callback_.is_null());
   CHECK(!callback.is_null());
 
   if (stream_ == nullptr)
     return GetResponseStatus();
-
   // Check if we already have the response headers. If so, return synchronously.
   if (response_headers_received_)
     return OK;
 
   // Still waiting for the response, return IO_PENDING.
   CHECK(callback_.is_null());
   callback_ = callback;
   return ERR_IO_PENDING;
 }
 
@@ skipping 21 matching lines @@
   if (rv != ERR_IO_PENDING)
     return rv;
 
   callback_ = callback;
   user_buffer_ = buf;
   user_buffer_len_ = buf_len;
   return ERR_IO_PENDING;
 }
 
 void QuicHttpStream::Close(bool /*not_reusable*/) {
+  session_error_ = ERR_ABORTED;
   SaveResponseStatus();
   // Note: the not_reusable flag has no meaning for QUIC streams.
   if (stream_) {
     stream_->SetDelegate(nullptr);
     stream_->Reset(QUIC_STREAM_CANCELLED);
   }
   ResetStream();
 }
 
 bool QuicHttpStream::IsResponseBodyComplete() const {
@@ skipping 475 matching lines @@
 }
 
 void QuicHttpStream::SetResponseStatus(int response_status) {
   has_response_status_ = true;
   response_status_ = response_status;
 }
 
 int QuicHttpStream::ComputeResponseStatus() const {
   DCHECK(!has_response_status_);
 
-  // If the handshake has failed this will be handled by the
-  // QuicStreamFactory and HttpStreamFactory to mark QUIC as broken.
+  // If the handshake has failed this will be handled by the QuicStreamFactory
+  // and HttpStreamFactory to mark QUIC as broken if TCP is actually working.
   if (!was_handshake_confirmed_)
     return ERR_QUIC_HANDSHAKE_FAILED;
 
   // If the session was aborted by a higher layer, simply use that error code.
   if (session_error_ != ERR_UNEXPECTED)
     return session_error_;
 
   // If |response_info_| is null then the request has not been sent, so
   // return ERR_CONNECTION_CLOSED to permit HttpNetworkTransaction to
   // retry the request.
   if (!response_info_)
     return ERR_CONNECTION_CLOSED;
 
+  // Explicit stream error are always fatal.
+  if (quic_stream_error_ != QUIC_STREAM_NO_ERROR &&
+      quic_stream_error_ != QUIC_STREAM_CONNECTION_ERROR) {
+    return ERR_QUIC_PROTOCOL_ERROR;
+  }
+
+  DCHECK_NE(QUIC_HANDSHAKE_TIMEOUT, quic_connection_error_);
+
+  if (!mark_quic_broken_when_network_suspected_)
+    return ERR_QUIC_PROTOCOL_ERROR;
+
+  // For error codes which could have been generated by "the network", mark
+  // QUIC as broken and return ERR_QUIC_BROKEN_ERROR to permit
+  // HttpNetworkTransaction to retry the request over TCP.
+  if (quic_connection_error_ == QUIC_NETWORK_IDLE_TIMEOUT ||
+      quic_connection_error_ == QUIC_TIMEOUTS_WITH_OPEN_STREAMS ||
+      quic_connection_error_ == QUIC_TOO_MANY_RTOS) {
+    HistogramBrokenAlternateProtocolLocation(
+        BROKEN_ALTERNATE_PROTOCOL_LOCATION_QUIC_HTTP_STREAM);
+    http_server_properties_->MarkAlternativeServiceBroken(
+        AlternativeService(kProtoQUIC, server_id_.host(), server_id_.port()));
+    return ERR_QUIC_BROKEN_ERROR;
+  }
+
+  // All other errors are fatal.
   return ERR_QUIC_PROTOCOL_ERROR;
 }
 
 }  // namespace net