Landing Recent QUIC changes until Fri Nov 18 23:21:04 2016 +0000

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"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/network_delegate.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/dns/mapped_host_resolver.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/quic/chromium/crypto/proof_source_chromium.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/gtest_util.h"
 #include "net/test/test_data_directory.h"
-#include "net/tools/quic/quic_in_memory_cache.h"
+#include "net/tools/quic/quic_http_response_cache.h"
 #include "net/tools/quic/quic_simple_server.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
@@ skipping 51 matching lines @@
 
   std::unique_ptr<URLRequest> CreateRequest(const GURL& url,
                                             RequestPriority priority,
                                             URLRequest::Delegate* delegate) {
     return context_->CreateRequest(url, priority, delegate);
   }
 
  private:
   void StartQuicServer() {
     // Set up in-memory cache.
-    in_memory_cache_.AddSimpleResponse(kTestServerHost, kHelloPath,
-                                       kHelloStatus, kHelloBodyValue);
+    response_cache_.AddSimpleResponse(kTestServerHost, kHelloPath, kHelloStatus,
+                                      kHelloBodyValue);
     net::QuicConfig config;
     // Set up server certs.
     std::unique_ptr<net::ProofSourceChromium> proof_source(
         new net::ProofSourceChromium());
     base::FilePath directory = GetTestCertsDirectory();
     CHECK(proof_source->Initialize(
         directory.Append(FILE_PATH_LITERAL("quic_test.example.com.crt")),
         directory.Append(FILE_PATH_LITERAL("quic_test.example.com.key.pkcs8")),
         directory.Append(FILE_PATH_LITERAL("quic_test.example.com.key.sct"))));
     server_.reset(new QuicSimpleServer(
         test::CryptoTestUtils::ProofSourceForTesting(), config,
         net::QuicCryptoServerConfig::ConfigOptions(), AllSupportedVersions(),
-        &in_memory_cache_));
+        &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)
     // 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_;
-  QuicInMemoryCache in_memory_cache_;
+  QuicHttpResponseCache response_cache_;
   MockCertVerifier cert_verifier_;
 };
 
 // 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 {
@@ skipping 99 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