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

net/quic/chromium/quic_stream_factory.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_stream_factory.h"
 
 #include <algorithm>
 #include <tuple>
 #include <utility>
 
@@ skipping 645 matching lines @@
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     session_ = nullptr;
     return OK;
   }
 
   factory_->ActivateSession(key_, session_);
 
   return OK;
 }
 
-QuicStreamRequest::QuicStreamRequest(QuicStreamFactory* factory)
-    : factory_(factory) {}
+QuicStreamRequest::QuicStreamRequest(
+    QuicStreamFactory* factory,
+    HttpServerProperties* http_server_properties)
+    : factory_(factory), http_server_properties_(http_server_properties) {}
 
 QuicStreamRequest::~QuicStreamRequest() {
   if (factory_ && !callback_.is_null())
     factory_->CancelRequest(this);
 }
 
 int QuicStreamRequest::Request(const HostPortPair& destination,
                                PrivacyMode privacy_mode,
                                int cert_verify_flags,
                                const GURL& url,
@@ skipping 29 matching lines @@
 
 base::TimeDelta QuicStreamRequest::GetTimeDelayForWaitingJob() const {
   if (!factory_)
     return base::TimeDelta();
   return factory_->GetTimeDelayForWaitingJob(server_id_);
 }
 
 std::unique_ptr<QuicHttpStream> QuicStreamRequest::CreateStream() {
   if (!session_)
     return nullptr;
-  return base::MakeUnique<QuicHttpStream>(session_);
+  return base::MakeUnique<QuicHttpStream>(session_, http_server_properties_);
 }
 
 std::unique_ptr<BidirectionalStreamImpl>
 QuicStreamRequest::CreateBidirectionalStreamImpl() {
   if (!session_)
     return nullptr;
   return base::MakeUnique<BidirectionalStreamQuicImpl>(session_);
 }
 
 QuicStreamFactory::QuicStreamFactory(
@@ skipping 455 matching lines @@
   job_requests_map_.erase(server_id);
 }
 
 void QuicStreamFactory::OnCertVerifyJobComplete(CertVerifierJob* job, int rv) {
   active_cert_verifier_jobs_.erase(job->server_id());
 }
 
 std::unique_ptr<QuicHttpStream> QuicStreamFactory::CreateFromSession(
     QuicChromiumClientSession* session) {
   return std::unique_ptr<QuicHttpStream>(
-      new QuicHttpStream(session->GetWeakPtr()));
+      new QuicHttpStream(session->GetWeakPtr(), http_server_properties_));
 }
 
 bool QuicStreamFactory::IsQuicDisabled() const {
   return status_ != OPEN;
 }
 
 bool QuicStreamFactory::OnHandshakeConfirmed(
     QuicChromiumClientSession* session) {
   if (!IsQuicDisabled())
     return false;
@@ skipping 781 matching lines @@
 void QuicStreamFactory::OpenFactory() {
   status_ = OPEN;
 }
 
 void QuicStreamFactory::MaybeClearConsecutiveDisabledCount() {
   if (status_ == OPEN)
     consecutive_disabled_count_ = 0;
 }
 
 }  // namespace net