Pass QuicInMemoryCache directly instead of using a singleton.

net/quic/chromium/quic_end_to_end_unittest.cc

 // Copyright 2013 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 <ostream>
 #include <utility>
 #include <vector>
 
 #include "base/compiler_specific.h"
@@ skipping 20 matching lines @@
 #include "net/proxy/proxy_service.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/ssl/default_channel_id_store.h"
 #include "net/ssl/ssl_config_service_defaults.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_simple_server.h"
-#include "net/tools/quic/test_tools/quic_in_memory_cache_peer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 using base::StringPiece;
 
 namespace net {
 
 using test::IsOk;
-using test::QuicInMemoryCachePeer;
 
 namespace test {
 
 namespace {
 
 const char kResponseBody[] = "some arbitrary response body";
 
 // Factory for creating HttpTransactions, used by TestTransactionConsumer.
 class TestTransactionFactory : public HttpTransactionFactory {
  public:
@@ skipping 84 matching lines @@
 
   // Creates a mock host resolver in which test.example.com
   // resolves to localhost.
   static MockHostResolver* CreateResolverImpl() {
     MockHostResolver* resolver = new MockHostResolver();
     resolver->rules()->AddRule("test.example.com", "127.0.0.1");
     return resolver;
   }
 
   void SetUp() override {
-    QuicInMemoryCachePeer::ResetForTests();
     StartServer();
 
     // 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));
 
     // 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("test.example.com:443"));
 
     transaction_factory_.reset(new TestTransactionFactory(params_));
   }
 
-  void TearDown() override { QuicInMemoryCachePeer::ResetForTests(); }
+  void TearDown() override {}
 
   // Starts the QUIC server listening on a random port.
   void StartServer() {
     server_address_ = IPEndPoint(IPAddress(127, 0, 0, 1), 0);
     server_config_.SetInitialStreamFlowControlWindowToSend(
         kInitialStreamFlowControlWindowForTest);
     server_config_.SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
     server_config_options_.token_binding_params = QuicTagVector{kTB10, kP256};
-    server_.reset(new QuicSimpleServer(CryptoTestUtils::ProofSourceForTesting(),
-                                       server_config_, server_config_options_,
-                                       AllSupportedVersions()));
+    server_.reset(new QuicSimpleServer(
+        CryptoTestUtils::ProofSourceForTesting(), server_config_,
+        server_config_options_, AllSupportedVersions(), &in_memory_cache_));
     server_->Listen(server_address_);
     server_address_ = server_->server_address();
     server_->StartReading();
     server_started_ = true;
   }
 
   // Adds an entry to the cache used by the QUIC server to serve
   // responses.
   void AddToCache(StringPiece path,
                   int response_code,
                   StringPiece response_detail,
                   StringPiece body) {
-    QuicInMemoryCache::GetInstance()->AddSimpleResponse(
-        "test.example.com", path, response_code, body);
+    in_memory_cache_.AddSimpleResponse("test.example.com", path, response_code,
+                                       body);
   }
 
   // Populates |request_body_| with |length_| ASCII bytes.
   void GenerateBody(size_t length) {
     request_body_.clear();
     request_body_.reserve(length);
     for (size_t i = 0; i < length; ++i) {
       request_body_.append(1, static_cast<char>(32 + i % (126 - 32)));
     }
   }
@@ skipping 34 matching lines @@
   scoped_refptr<SSLConfigServiceDefaults> ssl_config_service_;
   std::unique_ptr<ProxyService> proxy_service_;
   std::unique_ptr<HttpAuthHandlerFactory> auth_handler_factory_;
   HttpServerPropertiesImpl http_server_properties_;
   HttpNetworkSession::Params params_;
   std::unique_ptr<TestTransactionFactory> transaction_factory_;
   HttpRequestInfo request_;
   std::string request_body_;
   std::unique_ptr<UploadDataStream> upload_data_stream_;
   std::unique_ptr<QuicSimpleServer> server_;
+  QuicInMemoryCache in_memory_cache_;
   IPEndPoint server_address_;
   std::string server_hostname_;
   QuicConfig server_config_;
   QuicCryptoServerConfig::ConfigOptions server_config_options_;
   bool server_started_;
   bool strike_register_no_startup_period_;
 };
 
 INSTANTIATE_TEST_CASE_P(Tests,
                         QuicEndToEndTest,
@@ skipping 97 matching lines @@
 
   // Will terminate when the last consumer completes.
   base::RunLoop().Run();
 
   for (const auto& consumer : consumers)
     CheckResponse(*consumer.get(), "HTTP/1.1 200", kResponseBody);
 }
 
 }  // namespace test
 }  // namespace net