Mark QUIC broken when the network blackholes after the handshake

net/quic/chromium/quic_http_stream_test.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 <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 56 matching lines @@
 using testing::AnyNumber;
 using testing::Return;
 
 namespace net {
 namespace test {
 namespace {
 
 const char kUploadData[] = "Really nifty data!";
 const char kDefaultServerHostName[] = "www.example.org";
 const uint16_t kDefaultServerPort = 80;
+const bool kMarkQuicBrokenWhenNetworkSuspected = true;
 
 class TestQuicConnection : public QuicConnection {
  public:
   TestQuicConnection(const QuicVersionVector& versions,
                      QuicConnectionId connection_id,
                      IPEndPoint address,
                      QuicChromiumConnectionHelper* helper,
                      QuicChromiumAlarmFactory* alarm_factory,
                      QuicPacketWriter* writer)
       : QuicConnection(connection_id,
                        QuicSocketAddress(QuicSocketAddressImpl(address)),
                        helper,
                        alarm_factory,
                        writer,
                        true /* owns_writer */,
                        Perspective::IS_CLIENT,
                        versions) {}
 
   void SetSendAlgorithm(SendAlgorithmInterface* send_algorithm) {
     QuicConnectionPeer::SetSendAlgorithm(this, send_algorithm);
   }
 };
 
 // Subclass of QuicHttpStream that closes itself when the first piece of data
 // is received.
 class AutoClosingStream : public QuicHttpStream {
  public:
   explicit AutoClosingStream(
       const base::WeakPtr<QuicChromiumClientSession>& session,
-      HttpServerProperties* http_server_properties)
-      : QuicHttpStream(session, http_server_properties) {}
+      HttpServerProperties* http_server_properties,
+      bool mark_quic_broken_when_network_suspected)
+      : QuicHttpStream(session,
+                       http_server_properties,
+                       mark_quic_broken_when_network_suspected) {}
 
   void OnHeadersAvailable(const SpdyHeaderBlock& headers,
                           size_t frame_len) override {
     Close(false);
   }
 
   void OnDataAvailable() override { Close(false); }
 };
 
 // UploadDataStream that always returns errors on data read.
@@ skipping 207 matching lines @@
         QuicTime::Delta::FromMilliseconds(kQuicYieldAfterDurationMilliseconds),
         /*cert_verify_flags=*/0, DefaultQuicConfig(), &crypto_config_,
         "CONNECTION_UNKNOWN", dns_start, dns_end, &push_promise_index_, nullptr,
         base::ThreadTaskRunnerHandle::Get().get(),
         /*socket_performance_watcher=*/nullptr, net_log_.bound().net_log()));
     session_->Initialize();
     TestCompletionCallback callback;
     session_->CryptoConnect(callback.callback());
     EXPECT_TRUE(session_->IsCryptoHandshakeConfirmed());
     stream_.reset(use_closing_stream_
-                      ? new AutoClosingStream(session_->GetWeakPtr(),
-                                              &http_server_properties_)
-                      : new QuicHttpStream(session_->GetWeakPtr(),
-                                           &http_server_properties_));
+                      ? new AutoClosingStream(
+                            session_->GetWeakPtr(), &http_server_properties_,
+                            !kMarkQuicBrokenWhenNetworkSuspected)
+                      : new QuicHttpStream(
+                            session_->GetWeakPtr(), &http_server_properties_,
+                            !kMarkQuicBrokenWhenNetworkSuspected));
 
-    promised_stream_.reset(use_closing_stream_
-                               ? new AutoClosingStream(session_->GetWeakPtr(),
-                                                       &http_server_properties_)
-                               : new QuicHttpStream(session_->GetWeakPtr(),
-                                                    &http_server_properties_));
+    promised_stream_.reset(
+        use_closing_stream_
+            ? new AutoClosingStream(session_->GetWeakPtr(),
+                                    &http_server_properties_,
+                                    !kMarkQuicBrokenWhenNetworkSuspected)
+            : new QuicHttpStream(session_->GetWeakPtr(),
+                                 &http_server_properties_,
+                                 !kMarkQuicBrokenWhenNetworkSuspected));
 
     push_promise_[":path"] = "/bar";
     push_promise_[":authority"] = "www.example.org";
     push_promise_[":version"] = "HTTP/1.1";
     push_promise_[":method"] = "GET";
     push_promise_[":scheme"] = "https";
 
     promised_response_[":status"] = "200 OK";
     promised_response_[":version"] = "HTTP/1.1";
     promised_response_["content-type"] = "text/plain";
@@ skipping 363 matching lines @@
   request_.method = "GET";
   request_.url = GURL("http://www.example.org/");
   // Start first request.
   EXPECT_EQ(OK,
             stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                       net_log_.bound(), callback_.callback()));
   EXPECT_EQ(OK,
             stream_->SendRequest(headers_, &response_, callback_.callback()));
 
   // Start a second request.
-  QuicHttpStream stream2(session_->GetWeakPtr(), &http_server_properties_);
+  QuicHttpStream stream2(session_->GetWeakPtr(), &http_server_properties_,
+                         !kMarkQuicBrokenWhenNetworkSuspected);
   TestCompletionCallback callback2;
   EXPECT_EQ(OK,
             stream2.InitializeStream(&request_, DEFAULT_PRIORITY,
                                      net_log_.bound(), callback2.callback()));
   EXPECT_EQ(OK,
             stream2.SendRequest(headers_, &response_, callback2.callback()));
 
   // Ack both requests.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
@@ skipping 1430 matching lines @@
   EXPECT_TRUE(AtEof());
 
   // QuicHttpStream::GetTotalSent/ReceivedBytes includes only headers.
   EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
             stream_->GetTotalSentBytes());
   EXPECT_EQ(0, stream_->GetTotalReceivedBytes());
 }
 
 }  // namespace test
 }  // namespace net