Respect QuicAllowed policy for new streams

net/url_request/url_request_quic_unittest.cc

 // Copyright 2016 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 <memory>
 
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
@@ skipping 43 matching lines @@
     cert_verifier_.AddResultForCertAndHost(verify_result.verified_cert.get(),
                                            "test.example.com", verify_result,
                                            OK);
     verify_result.verified_cert = ImportCertFromFile(
         GetTestCertsDirectory(), "quic_test_ecc.example.com.crt");
     cert_verifier_.AddResultForCertAndHost(verify_result.verified_cert.get(),
                                            "test.example.com", verify_result,
                                            OK);
     // To simplify the test, and avoid the race with the HTTP request, we force
     // QUIC for these requests.
+    dynamic_shared_params_.reset(new HttpNetworkSession::DynamicSharedParams);

[Bence, 2016/12/20 14:58:07]

= MakeUnique

[pmarko, 2016/12/20 18:00:37]

Done.

+    params->dynamic_shared_params = dynamic_shared_params_.get();
     params->origins_to_force_quic_on.insert(
         HostPortPair::FromString(kTestServerHost));
     params->cert_verifier = &cert_verifier_;
-    params->enable_quic = true;
+    dynamic_shared_params_->enable_quic = true;
     params->host_resolver = host_resolver_.get();
     context_->set_http_network_session_params(std::move(params));
     context_->set_cert_verifier(&cert_verifier_);
   }
 
   void TearDown() override {
     if (server_)
       server_->Shutdown();
   }
 
@@ skipping 41 matching lines @@
     std::string map_rule = "MAP test.example.com test.example.com:" +
                            base::IntToString(server_->server_address().port());
     EXPECT_TRUE(host_resolver_->AddRuleFromString(map_rule));
   }
 
   std::unique_ptr<MappedHostResolver> host_resolver_;
   std::unique_ptr<QuicSimpleServer> server_;
   std::unique_ptr<TestURLRequestContext> context_;
   QuicHttpResponseCache response_cache_;
   MockCertVerifier cert_verifier_;
+  std::unique_ptr<HttpNetworkSession::DynamicSharedParams>
+      dynamic_shared_params_;
 };
 
 // A URLRequest::Delegate that checks LoadTimingInfo when response headers are
 // received.
 class CheckLoadTimingDelegate : public TestDelegate {
  public:
   CheckLoadTimingDelegate(bool session_reused)
       : session_reused_(session_reused) {}
   void OnResponseStarted(URLRequest* request, int error) override {
     TestDelegate::OnResponseStarted(request, error);
@@ skipping 98 matching lines @@
   ASSERT_TRUE(request2->is_pending());
   run_loop.Run();
 
   EXPECT_TRUE(request->status().is_success());
   EXPECT_TRUE(request2->status().is_success());
   EXPECT_EQ(kHelloBodyValue, delegate.data_received());
   EXPECT_EQ(kHelloBodyValue, delegate2.data_received());
 }
 
 }  // namespace net