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 32 matching lines @@
 }
 
 }  // namespace
 
 QuicHttpStream::QuicHttpStream(
     const base::WeakPtr<QuicChromiumClientSession>& session,
     HttpServerProperties* http_server_properties)
     : MultiplexedHttpStream(MultiplexedSessionHandle(session)),
       next_state_(STATE_NONE),
       session_(session),
+      server_id_(session->server_id()),
       http_server_properties_(http_server_properties),
       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),
@@ skipping 252 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 472 matching lines @@
 void QuicHttpStream::SaveResponseStatus() {
   if (!has_response_status_)
     SetResponseStatus(ComputeResponseStatus());
 }
 
 void QuicHttpStream::SetResponseStatus(int response_status) {
   has_response_status_ = true;
   response_status_ = response_status;
 }
 
+// Returns true if |error| is possibly caused by the network
+bool IsPossiblyNetworkError(QuicErrorCode error) {

[Jana, 2017/04/07 21:59:29]

You don't need this function anymore, do you?

[Ryan Hamilton, 2017/04/07 22:37:20]

Right! Good point. I should move this comment to the session though.

Thanks. DOne.

+  // QUIC connections should not timeout while there are open streams,
+  // since PING frames are sent to prevent timeouts. If, however, the
+  // connection timed out while this stream was open then QUIC traffic
+  // has become blackholed.
+  return error == QUIC_NETWORK_IDLE_TIMEOUT || error == QUIC_TOO_MANY_RTOS;
+}
+
 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 the headers have not been received and QUIC is now broken, return
+  // ERR_QUIC_BROKEN_ERROR to permit HttpNetworkTransaction to retry the request
+  // over TCP.
+  if (!response_headers_received_ &&
+      http_server_properties_->IsAlternativeServiceBroken(AlternativeService(
+          kProtoQUIC, server_id_.host(), server_id_.port()))) {
+    return ERR_QUIC_BROKEN_ERROR;
+  }
+
   return ERR_QUIC_PROTOCOL_ERROR;
 }
 
 }  // namespace net