Server push cancellation: fix host resolver set up in URLRequestQuicTest

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 17 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
 // This must match the certificate used (quic_test.example.com.crt and
 // quic_test.example.com.key.pkcs8).
 const int kTestServerPort = 6121;
-const char kTestServerHost[] = "test.example.com:6121";
+const char kTestServerHost[] = "test.example.com";
 // Used as a simple response from the server.
 const char kHelloPath[] = "/hello.txt";
 const char kHelloBodyValue[] = "Hello from QUIC Server";
 const int kHelloStatus = 200;
 
 class URLRequestQuicTest : public ::testing::Test {
  protected:
   URLRequestQuicTest() : context_(new TestURLRequestContext(true)) {
     StartQuicServer();
 
     std::unique_ptr<HttpNetworkSession::Params> params(
         new HttpNetworkSession::Params);
     CertVerifyResult verify_result;
     verify_result.verified_cert = ImportCertFromFile(
         GetTestCertsDirectory(), "quic_test.example.com.crt");
     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.
-    params->origins_to_force_quic_on.insert(
-        HostPortPair::FromString(kTestServerHost));
+    params->origins_to_force_quic_on.insert(HostPortPair(kTestServerHost, 443));
     params->cert_verifier = &cert_verifier_;
     params->enable_quic = true;
-    params->host_resolver = host_resolver_.get();
+    context_->set_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();
   }
 
   // Sets a NetworkDelegate to use for |context_|. Must be done before Init().
@@ skipping 28 matching lines @@
         test::crypto_test_utils::ProofSourceForTesting(), config,
         net::QuicCryptoServerConfig::ConfigOptions(), AllSupportedVersions(),
         &response_cache_));
     int rv = server_->Listen(
         net::IPEndPoint(net::IPAddress::IPv4AllZeros(), kTestServerPort));
     EXPECT_GE(rv, 0) << "Quic server fails to start";
 
     std::unique_ptr<MockHostResolver> resolver(new MockHostResolver());
     resolver->rules()->AddRule("test.example.com", "127.0.0.1");
     host_resolver_.reset(new MappedHostResolver(std::move(resolver)));
-    // Use a mapped host resolver so that request for test.example.com (port 80)
+    // Use a mapped host resolver so that request for test.example.com
     // reach the server running on localhost.
     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_;
@@ skipping 109 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