Pass QuicInMemoryCache directly instead of using a singleton.

net/tools/quic/end_to_end_test.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 <stddef.h>
 #include <sys/epoll.h>
 
 #include <cstdint>
 #include <list>
 #include <memory>
@@ skipping 36 matching lines @@
 #include "net/tools/quic/quic_in_memory_cache.h"
 #include "net/tools/quic/quic_packet_writer_wrapper.h"
 #include "net/tools/quic/quic_server.h"
 #include "net/tools/quic/quic_simple_server_stream.h"
 #include "net/tools/quic/quic_socket_utils.h"
 #include "net/tools/quic/quic_spdy_client_stream.h"
 #include "net/tools/quic/test_tools/packet_dropping_test_writer.h"
 #include "net/tools/quic/test_tools/packet_reordering_writer.h"
 #include "net/tools/quic/test_tools/quic_client_peer.h"
 #include "net/tools/quic/test_tools/quic_dispatcher_peer.h"
-#include "net/tools/quic/test_tools/quic_in_memory_cache_peer.h"
 #include "net/tools/quic/test_tools/quic_server_peer.h"
 #include "net/tools/quic/test_tools/quic_test_client.h"
 #include "net/tools/quic/test_tools/quic_test_server.h"
 #include "net/tools/quic/test_tools/server_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::IntToString;
 using base::StringPiece;
 using base::WaitableEvent;
 using net::EpollServer;
@@ skipping 230 matching lines @@
         3 * kInitialSessionFlowControlWindowForTest);
 
     // The default idle timeouts can be too strict when running on a busy
     // machine.
     const QuicTime::Delta timeout = QuicTime::Delta::FromSeconds(30);
     client_config_.set_max_time_before_crypto_handshake(timeout);
     client_config_.set_max_idle_time_before_crypto_handshake(timeout);
     server_config_.set_max_time_before_crypto_handshake(timeout);
     server_config_.set_max_idle_time_before_crypto_handshake(timeout);
 
-    QuicInMemoryCachePeer::ResetForTests();
     AddToCache("/foo", 200, kFooResponseBody);
     AddToCache("/bar", 200, kBarResponseBody);
   }
 
   ~EndToEndTest() override {
     // TODO(rtenneti): port RecycleUnusedPort if needed.
     // RecycleUnusedPort(server_address_.port());
-    QuicInMemoryCachePeer::ResetForTests();
   }
 
   virtual void CreateClientWithWriter() {
     client_.reset(CreateQuicClient(client_writer_));
   }
 
   QuicTestClient* CreateQuicClient(QuicPacketWriterWrapper* writer) {
     QuicTestClient* client = new QuicTestClient(
         server_address_, server_hostname_, client_config_,
         client_supported_versions_, CryptoTestUtils::ProofVerifierForTesting());
@@ skipping 96 matching lines @@
   void TearDown() override {
     ASSERT_TRUE(initialized_) << "You must call Initialize() in every test "
                               << "case. Otherwise, your test will leak memory.";
     StopServer();
   }
 
   void StartServer() {
     FLAGS_quic_use_cheap_stateless_rejects =
         GetParam().use_cheap_stateless_reject;
 
-    auto test_server =
-        new QuicTestServer(CryptoTestUtils::ProofSourceForTesting(),
-                           server_config_, server_supported_versions_);
+    auto test_server = new QuicTestServer(
+        CryptoTestUtils::ProofSourceForTesting(), server_config_,
+        server_supported_versions_, &in_memory_cache_);
     server_thread_.reset(new ServerThread(test_server, server_address_));
     if (chlo_multiplier_ != 0) {
       server_thread_->server()->SetChloMultiplier(chlo_multiplier_);
     }
     server_thread_->Initialize();
     server_address_ =
         QuicSocketAddress(server_address_.host(), server_thread_->GetPort());
     QuicDispatcher* dispatcher =
         QuicServerPeer::GetDispatcher(server_thread_->server());
     QuicDispatcherPeer::UseWriter(dispatcher, server_writer_);
@@ skipping 16 matching lines @@
   void StopServer() {
     if (!server_started_)
       return;
     if (server_thread_.get()) {
       server_thread_->Quit();
       server_thread_->Join();
     }
   }
 
   void AddToCache(StringPiece path, int response_code, StringPiece body) {
-    QuicInMemoryCache::GetInstance()->AddSimpleResponse(server_hostname_, path,
-                                                        response_code, body);
+    in_memory_cache_.AddSimpleResponse(server_hostname_, path, response_code,
+                                       body);
   }
 
   void SetPacketLossPercentage(int32_t loss) {
     // TODO(rtenneti): enable when we can do random packet loss tests in
     // chrome's tree.
     if (loss != 0 && loss != 100)
       return;
     client_writer_->set_fake_packet_loss_percentage(loss);
     server_writer_->set_fake_packet_loss_percentage(loss);
   }
@@ skipping 69 matching lines @@
 
   // Must be called before Initialize to have effect.
   void SetSpdyStreamFactory(QuicTestServer::StreamFactory* factory) {
     stream_factory_ = factory;
   }
 
   QuicFlagSaver flags_;  // Save/restore all QUIC flag values.
   bool initialized_;
   QuicSocketAddress server_address_;
   string server_hostname_;
+  QuicInMemoryCache in_memory_cache_;
   std::unique_ptr<ServerThread> server_thread_;
   std::unique_ptr<QuicTestClient> client_;
   PacketDroppingTestWriter* client_writer_;
   PacketDroppingTestWriter* server_writer_;
   bool server_started_;
   QuicConfig client_config_;
   QuicConfig server_config_;
   QuicVersionVector client_supported_versions_;
   QuicVersionVector server_supported_versions_;
   QuicVersion negotiated_version_;
@@ skipping 1569 matching lines @@
   // The connection should not be terminated.
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
 }
 
 // A test stream that gives |response_body_| as an error response body.
 class ServerStreamWithErrorResponseBody : public QuicSimpleServerStream {
  public:
   ServerStreamWithErrorResponseBody(QuicStreamId id,
                                     QuicSpdySession* session,
+                                    QuicInMemoryCache* in_memory_cache,
                                     string response_body)
-      : QuicSimpleServerStream(id, session),
+      : QuicSimpleServerStream(id, session, in_memory_cache),
         response_body_(std::move(response_body)) {}
 
   ~ServerStreamWithErrorResponseBody() override {}
 
  protected:
   void SendErrorResponse() override {
     DVLOG(1) << "Sending error response for stream " << id();
     SpdyHeaderBlock headers;
     headers[":status"] = "500";
     headers["content-length"] = base::UintToString(response_body_.size());
     // This method must call CloseReadSide to cause the test case, StopReading
     // is not sufficient.
     QuicStreamPeer::CloseReadSide(this);
     SendHeadersAndBody(std::move(headers), response_body_);
   }
 
   string response_body_;
 };
 
 class StreamWithErrorFactory : public QuicTestServer::StreamFactory {
  public:
   explicit StreamWithErrorFactory(string response_body)
       : response_body_(std::move(response_body)) {}
 
   ~StreamWithErrorFactory() override {}
 
-  QuicSimpleServerStream* CreateStream(QuicStreamId id,
-                                       QuicSpdySession* session) override {
-    return new ServerStreamWithErrorResponseBody(id, session, response_body_);
+  QuicSimpleServerStream* CreateStream(
+      QuicStreamId id,
+      QuicSpdySession* session,
+      QuicInMemoryCache* in_memory_cache) override {
+    return new ServerStreamWithErrorResponseBody(id, session, in_memory_cache,
+                                                 response_body_);
   }
 
  private:
   string response_body_;
 };
 
 // A test server stream that drops all received body.
 class ServerStreamThatDropsBody : public QuicSimpleServerStream {
  public:
-  ServerStreamThatDropsBody(QuicStreamId id, QuicSpdySession* session)
-      : QuicSimpleServerStream(id, session) {}
+  ServerStreamThatDropsBody(QuicStreamId id,
+                            QuicSpdySession* session,
+                            QuicInMemoryCache* in_memory_cache)
+      : QuicSimpleServerStream(id, session, in_memory_cache) {}
 
   ~ServerStreamThatDropsBody() override {}
 
  protected:
   void OnDataAvailable() override {
     while (HasBytesToRead()) {
       struct iovec iov;
       if (GetReadableRegions(&iov, 1) == 0) {
         // No more data to read.
         break;
@@ skipping 18 matching lines @@
     SendResponse();
   }
 };
 
 class ServerStreamThatDropsBodyFactory : public QuicTestServer::StreamFactory {
  public:
   ServerStreamThatDropsBodyFactory() {}
 
   ~ServerStreamThatDropsBodyFactory() override{};
 
-  QuicSimpleServerStream* CreateStream(QuicStreamId id,
-                                       QuicSpdySession* session) override {
-    return new ServerStreamThatDropsBody(id, session);
+  QuicSimpleServerStream* CreateStream(
+      QuicStreamId id,
+      QuicSpdySession* session,
+      QuicInMemoryCache* in_memory_cache) override {
+    return new ServerStreamThatDropsBody(id, session, in_memory_cache);
   }
 };
 
 // A test server stream that sends response with body size greater than 4GB.
 class ServerStreamThatSendsHugeResponse : public QuicSimpleServerStream {
  public:
   ServerStreamThatSendsHugeResponse(QuicStreamId id,
                                     QuicSpdySession* session,
+                                    QuicInMemoryCache* in_memory_cache,
                                     int64_t body_bytes)
-      : QuicSimpleServerStream(id, session), body_bytes_(body_bytes) {}
+      : QuicSimpleServerStream(id, session, in_memory_cache),
+        body_bytes_(body_bytes) {}
 
   ~ServerStreamThatSendsHugeResponse() override {}
 
  protected:
   void SendResponse() override {
     QuicInMemoryCache::Response response;
     string body;
     GenerateBody(&body, body_bytes_);
     response.set_body(body);
     SendHeadersAndBodyAndTrailers(response.headers().Clone(), response.body(),
                                   response.trailers().Clone());
   }
 
  private:
   // Use a explicit int64_t rather than size_t to simulate a 64-bit server
   // talking to a 32-bit client.
   int64_t body_bytes_;
 };
 
 class ServerStreamThatSendsHugeResponseFactory
     : public QuicTestServer::StreamFactory {
  public:
   explicit ServerStreamThatSendsHugeResponseFactory(int64_t body_bytes)
       : body_bytes_(body_bytes) {}
 
   ~ServerStreamThatSendsHugeResponseFactory() override{};
 
-  QuicSimpleServerStream* CreateStream(QuicStreamId id,
-                                       QuicSpdySession* session) override {
-    return new ServerStreamThatSendsHugeResponse(id, session, body_bytes_);
+  QuicSimpleServerStream* CreateStream(
+      QuicStreamId id,
+      QuicSpdySession* session,
+      QuicInMemoryCache* in_memory_cache) override {
+    return new ServerStreamThatSendsHugeResponse(id, session, in_memory_cache,
+                                                 body_bytes_);
   }
 
   int64_t body_bytes_;
 };
 
 // A test client stream that drops all received body.
 class ClientStreamThatDropsBody : public QuicSpdyClientStream {
  public:
   ClientStreamThatDropsBody(QuicStreamId id, QuicClientSession* session)
       : QuicSpdyClientStream(id, session) {}
@@ skipping 197 matching lines @@
   const string kBody = "body content";
 
   SpdyHeaderBlock headers;
   headers[":status"] = "200";
   headers[":version"] = "HTTP/1.1";
   headers["content-length"] = IntToString(kBody.size());
 
   SpdyHeaderBlock trailers;
   trailers["some-trailing-header"] = "trailing-header-value";
 
-  QuicInMemoryCache::GetInstance()->AddResponse(
-      server_hostname_, "/trailer_url", std::move(headers), kBody,
-      trailers.Clone());
+  in_memory_cache_.AddResponse(server_hostname_, "/trailer_url",
+                               std::move(headers), kBody, trailers.Clone());
 
   EXPECT_EQ(kBody, client_->SendSynchronousRequest("/trailer_url"));
   EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
   EXPECT_EQ(trailers, client_->response_trailers());
 }
 
 class EndToEndTestServerPush : public EndToEndTest {
  protected:
   const size_t kNumMaxStreams = 10;
 
@@ skipping 31 matching lines @@
                         ? large_resource
                         : "This is server push response body for " + url;
       SpdyHeaderBlock response_headers;
       response_headers[":version"] = "HTTP/1.1";
       response_headers[":status"] = "200";
       response_headers["content-length"] = IntToString(body.size());
       push_resources.push_back(QuicInMemoryCache::ServerPushInfo(
           resource_url, std::move(response_headers), kV3LowestPriority, body));
     }
 
-    QuicInMemoryCache::GetInstance()->AddSimpleResponseWithServerPushResources(
+    in_memory_cache_.AddSimpleResponseWithServerPushResources(
         host, path, 200, response_body, push_resources);
   }
 };
 
 // Run all server push end to end tests with all supported versions.
 INSTANTIATE_TEST_CASE_P(EndToEndTestsServerPush,
                         EndToEndTestServerPush,
                         ::testing::ValuesIn(GetTestParams()));
 
 TEST_P(EndToEndTestServerPush, ServerPush) {
@@ skipping 390 matching lines @@
   client_->WaitForResponse();
   EXPECT_EQ(kBarResponseBody, client_->response_body());
   QuicConnectionStats client_stats =
       client_->client()->session()->connection()->GetStats();
   EXPECT_EQ(0u, client_stats.packets_lost);
   EXPECT_EQ(1, client_->client()->GetNumSentClientHellos());
 }
 }  // namespace
 }  // namespace test
 }  // namespace net