Pass HttpServerProperties in to QuicHttpStream so that it can mark QUIC broken.

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 27 matching lines @@
     NetLogCaptureMode capture_mode) {
   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)
+    const base::WeakPtr<QuicChromiumClientSession>& session,
+    HttpServerProperties* http_server_properties)
     : MultiplexedHttpStream(MultiplexedSessionHandle(session)),
       next_state_(STATE_NONE),
       session_(session),
+      http_server_properties_(http_server_properties),
       quic_version_(session->GetQuicVersion()),
       session_error_(OK),
       was_handshake_confirmed_(session->IsCryptoHandshakeConfirmed()),
       stream_(nullptr),
       request_info_(nullptr),
       request_body_stream_(nullptr),
       priority_(MINIMUM_PRIORITY),
       response_info_(nullptr),
       response_status_(OK),
       response_headers_received_(false),
@@ skipping 88 matching lines @@
   NOTREACHED();
   return HttpResponseInfo::CONNECTION_INFO_QUIC_UNKNOWN_VERSION;
 }
 
 int QuicHttpStream::InitializeStream(const HttpRequestInfo* request_info,
                                      RequestPriority priority,
                                      const NetLogWithSource& stream_net_log,
                                      const CompletionCallback& callback) {
   CHECK(callback_.is_null());
   DCHECK(!stream_);
+
+  // HttpNetworkTransaction will retry any request that fails with
+  // ERR_QUIC_HANDSHAKE_FAILED. It will retry any request with
+  // ERR_CONNECTION_CLOSED so long as the connection has been used for other
+  // streams first and headers have not yet been received.
   if (!session_)
     return was_handshake_confirmed_ ? ERR_CONNECTION_CLOSED
                                     : ERR_QUIC_HANDSHAKE_FAILED;
 
   stream_net_log.AddEvent(
       NetLogEventType::HTTP_STREAM_REQUEST_BOUND_TO_QUIC_SESSION,
       session_->net_log().source().ToEventParametersCallback());
 
   stream_net_log_ = stream_net_log;
   request_info_ = request_info;
@@ skipping 73 matching lines @@
   // TODO(rch): remove this once we figure out why channel ID is not being
   // sent when it should be.
   HostPortPair origin = HostPortPair::FromURL(request_info_->url);
   if (origin.Equals(HostPortPair("accounts.google.com", 443)) &&
       request_headers.HasHeader(HttpRequestHeaders::kCookie)) {
     SSLInfo ssl_info;
     GetSSLInfo(&ssl_info);
     UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.CookieSentToAccountsOverChannelId",
                           ssl_info.channel_id_sent);
   }
+
+  // In order to rendezvous with a push stream, the session still needs to be
+  // available. Otherwise the stream needs to be available.
   if ((!found_promise_ && !stream_) || !session_) {
     return was_handshake_confirmed_ ? ERR_CONNECTION_CLOSED
                                     : ERR_QUIC_HANDSHAKE_FAILED;
   }
 
   // Store the serialized request headers.
   CreateSpdyHeadersFromHttpRequest(*request_info_, request_headers,
                                    /*direct=*/true, &request_headers_);
 
   // Store the request body.
@@ skipping 562 matching lines @@
   closed_is_first_stream_ = stream_->IsFirstStream();
   stream_ = nullptr;
 
   // If |request_body_stream_| is non-NULL, Reset it, to abort any in progress
   // read.
   if (request_body_stream_)
     request_body_stream_->Reset();
 }
 
 }  // namespace net