Pass QuicInMemoryCache directly instead of using a singleton.

net/tools/quic/quic_simple_server_stream_test.cc

 // Copyright (c) 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 "net/tools/quic/quic_simple_server_stream.h"
 
 #include <list>
 #include <memory>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "net/quic/core/quic_connection.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_protocol.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/core/spdy_utils.h"
 #include "net/quic/platform/api/quic_socket_address.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/quic_stream_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/test/gtest_util.h"
 #include "net/tools/epoll_server/epoll_server.h"
 #include "net/tools/quic/quic_in_memory_cache.h"
 #include "net/tools/quic/quic_simple_server_session.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 "url/gurl.h"
 
 using base::StringPiece;
 using net::test::MockQuicConnection;
 using net::test::MockQuicConnectionHelper;
 using net::test::MockQuicSpdySession;
 using net::test::QuicStreamPeer;
 using net::test::SupportedVersions;
 using net::test::kInitialSessionFlowControlWindowForTest;
 using net::test::kInitialStreamFlowControlWindowForTest;
 using std::string;
 using testing::_;
 using testing::AnyNumber;
 using testing::Invoke;
 using testing::InvokeArgument;
 using testing::InSequence;
 using testing::Return;
 using testing::StrictMock;
 using testing::WithArgs;
 
 namespace net {
 namespace test {
 
 size_t kFakeFrameLen = 60;
 
 class QuicSimpleServerStreamPeer : public QuicSimpleServerStream {
  public:
-  QuicSimpleServerStreamPeer(QuicStreamId stream_id, QuicSpdySession* session)
-      : QuicSimpleServerStream(stream_id, session) {}
+  QuicSimpleServerStreamPeer(QuicStreamId stream_id,
+                             QuicSpdySession* session,
+                             QuicInMemoryCache* in_memory_cache)
+      : QuicSimpleServerStream(stream_id, session, in_memory_cache) {}
 
   ~QuicSimpleServerStreamPeer() override{};
 
   using QuicSimpleServerStream::SendResponse;
   using QuicSimpleServerStream::SendErrorResponse;
 
   SpdyHeaderBlock* mutable_headers() { return &request_headers_; }
 
   static void SendResponse(QuicSimpleServerStream* stream) {
     stream->SendResponse();
@@ skipping 18 matching lines @@
 
 class MockQuicSimpleServerSession : public QuicSimpleServerSession {
  public:
   const size_t kMaxStreamsForTest = 100;
 
   explicit MockQuicSimpleServerSession(
       QuicConnection* connection,
       MockQuicSessionVisitor* owner,
       MockQuicCryptoServerStreamHelper* helper,
       QuicCryptoServerConfig* crypto_config,
-      QuicCompressedCertsCache* compressed_certs_cache)
+      QuicCompressedCertsCache* compressed_certs_cache,
+      QuicInMemoryCache* in_memory_cache)
       : QuicSimpleServerSession(DefaultQuicConfig(),
                                 connection,
                                 owner,
                                 helper,
                                 crypto_config,
-                                compressed_certs_cache) {
+                                compressed_certs_cache,
+                                in_memory_cache) {
     set_max_open_incoming_streams(kMaxStreamsForTest);
     set_max_open_outgoing_streams(kMaxStreamsForTest);
     ON_CALL(*this, WritevData(_, _, _, _, _, _))
         .WillByDefault(testing::Return(QuicConsumedData(0, false)));
   }
 
   ~MockQuicSimpleServerSession() override {}
 
   MOCK_METHOD3(OnConnectionClosed,
                void(QuicErrorCode error,
@@ skipping 73 matching lines @@
         crypto_config_(new QuicCryptoServerConfig(
             QuicCryptoServerConfig::TESTING,
             QuicRandom::GetInstance(),
             ::net::test::CryptoTestUtils::ProofSourceForTesting())),
         compressed_certs_cache_(
             QuicCompressedCertsCache::kQuicCompressedCertsCacheSize),
         session_(connection_,
                  &session_owner_,
                  &session_helper_,
                  crypto_config_.get(),
-                 &compressed_certs_cache_),
+                 &compressed_certs_cache_,
+                 &in_memory_cache_),
         body_("hello world") {
     header_list_.OnHeaderBlockStart();
     header_list_.OnHeader(":authority", "www.google.com");
     header_list_.OnHeader(":path", "/");
     header_list_.OnHeader(":method", "POST");
     header_list_.OnHeader(":version", "HTTP/1.1");
     header_list_.OnHeader("content-length", "11");
     header_list_.OnHeaderBlockEnd(128);
 
     // New streams rely on having the peer's flow control receive window
     // negotiated in the config.
     session_.config()->SetInitialStreamFlowControlWindowToSend(
         kInitialStreamFlowControlWindowForTest);
     session_.config()->SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
     stream_ = new QuicSimpleServerStreamPeer(::net::test::kClientDataStreamId1,
-                                             &session_);
+                                             &session_, &in_memory_cache_);
     // Register stream_ in dynamic_stream_map_ and pass ownership to session_.
     session_.ActivateStream(base::WrapUnique(stream_));
-
-    QuicInMemoryCachePeer::ResetForTests();
-  }
-
-  ~QuicSimpleServerStreamTest() override {
-    QuicInMemoryCachePeer::ResetForTests();
   }
 
   const string& StreamBody() {
     return QuicSimpleServerStreamPeer::body(stream_);
   }
 
   string StreamHeadersValue(const string& key) {
     return (*stream_->mutable_headers())[key].as_string();
   }
 
   SpdyHeaderBlock response_headers_;
   MockQuicConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
   StrictMock<MockQuicConnection>* connection_;
   StrictMock<MockQuicSessionVisitor> session_owner_;
   StrictMock<MockQuicCryptoServerStreamHelper> session_helper_;
   std::unique_ptr<QuicCryptoServerConfig> crypto_config_;
   QuicCompressedCertsCache compressed_certs_cache_;
+  QuicInMemoryCache in_memory_cache_;
   StrictMock<MockQuicSimpleServerSession> session_;
   QuicSimpleServerStreamPeer* stream_;  // Owned by session_.
   string headers_string_;
   string body_;
   QuicHeaderList header_list_;
 };
 
 INSTANTIATE_TEST_CASE_P(Tests,
                         QuicSimpleServerStreamTest,
                         ::testing::ValuesIn(AllSupportedVersions()));
@@ skipping 67 matching lines @@
   (*request_headers)[":path"] = "/bar";
   (*request_headers)[":authority"] = "www.google.com";
   (*request_headers)[":version"] = "HTTP/1.1";
   (*request_headers)[":method"] = "GET";
 
   response_headers_[":version"] = "HTTP/1.1";
   // HTTP/2 only supports integer responsecode, so "200 OK" is illegal.
   response_headers_[":status"] = "200 OK";
   response_headers_["content-length"] = "5";
   string body = "Yummm";
-  QuicInMemoryCache::GetInstance()->AddResponse(
-      "www.google.com", "/bar", std::move(response_headers_), body);
+  in_memory_cache_.AddResponse("www.google.com", "/bar",
+                               std::move(response_headers_), body);
 
   stream_->set_fin_received(true);
 
   InSequence s;
   EXPECT_CALL(session_, WriteHeadersMock(stream_->id(), _, false, _, nullptr));
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
       .Times(1)
       .WillOnce(Return(QuicConsumedData(
           strlen(QuicSimpleServerStream::kErrorResponseBody), true)));
 
   QuicSimpleServerStreamPeer::SendResponse(stream_);
   EXPECT_FALSE(QuicStreamPeer::read_side_closed(stream_));
   EXPECT_TRUE(stream_->reading_stopped());
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
 TEST_P(QuicSimpleServerStreamTest, SendResponseWithIllegalResponseStatus2) {
   // Send an illegal response with response status not supported by HTTP/2.
   SpdyHeaderBlock* request_headers = stream_->mutable_headers();
   (*request_headers)[":path"] = "/bar";
   (*request_headers)[":authority"] = "www.google.com";
   (*request_headers)[":version"] = "HTTP/1.1";
   (*request_headers)[":method"] = "GET";
 
   response_headers_[":version"] = "HTTP/1.1";
   // HTTP/2 only supports 3-digit-integer, so "+200" is illegal.
   response_headers_[":status"] = "+200";
   response_headers_["content-length"] = "5";
   string body = "Yummm";
-  QuicInMemoryCache::GetInstance()->AddResponse(
-      "www.google.com", "/bar", std::move(response_headers_), body);
+  in_memory_cache_.AddResponse("www.google.com", "/bar",
+                               std::move(response_headers_), body);
 
   stream_->set_fin_received(true);
 
   InSequence s;
   EXPECT_CALL(session_, WriteHeadersMock(stream_->id(), _, false, _, nullptr));
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
       .Times(1)
       .WillOnce(Return(QuicConsumedData(
           strlen(QuicSimpleServerStream::kErrorResponseBody), true)));
 
   QuicSimpleServerStreamPeer::SendResponse(stream_);
   EXPECT_FALSE(QuicStreamPeer::read_side_closed(stream_));
   EXPECT_TRUE(stream_->reading_stopped());
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
 TEST_P(QuicSimpleServerStreamTest, SendPushResponseWith404Response) {
   // Create a new promised stream with even id().
   QuicSimpleServerStreamPeer* promised_stream =
-      new QuicSimpleServerStreamPeer(2, &session_);
+      new QuicSimpleServerStreamPeer(2, &session_, &in_memory_cache_);
   session_.ActivateStream(base::WrapUnique(promised_stream));
 
   // Send a push response with response status 404, which will be regarded as
   // invalid server push response.
   SpdyHeaderBlock* request_headers = promised_stream->mutable_headers();
   (*request_headers)[":path"] = "/bar";
   (*request_headers)[":authority"] = "www.google.com";
   (*request_headers)[":version"] = "HTTP/1.1";
   (*request_headers)[":method"] = "GET";
 
   response_headers_[":version"] = "HTTP/1.1";
   response_headers_[":status"] = "404";
   response_headers_["content-length"] = "8";
   string body = "NotFound";
-  QuicInMemoryCache::GetInstance()->AddResponse(
-      "www.google.com", "/bar", std::move(response_headers_), body);
+  in_memory_cache_.AddResponse("www.google.com", "/bar",
+                               std::move(response_headers_), body);
 
   InSequence s;
   EXPECT_CALL(session_,
               SendRstStream(promised_stream->id(), QUIC_STREAM_CANCELLED, 0));
 
   QuicSimpleServerStreamPeer::SendResponse(promised_stream);
 }
 
 TEST_P(QuicSimpleServerStreamTest, SendResponseWithValidHeaders) {
   // Add a request and response with valid headers.
   SpdyHeaderBlock* request_headers = stream_->mutable_headers();
   (*request_headers)[":path"] = "/bar";
   (*request_headers)[":authority"] = "www.google.com";
   (*request_headers)[":version"] = "HTTP/1.1";
   (*request_headers)[":method"] = "GET";
 
   response_headers_[":version"] = "HTTP/1.1";
   response_headers_[":status"] = "200";
   response_headers_["content-length"] = "5";
   string body = "Yummm";
-  QuicInMemoryCache::GetInstance()->AddResponse(
-      "www.google.com", "/bar", std::move(response_headers_), body);
+  in_memory_cache_.AddResponse("www.google.com", "/bar",
+                               std::move(response_headers_), body);
   stream_->set_fin_received(true);
 
   InSequence s;
   EXPECT_CALL(session_, WriteHeadersMock(stream_->id(), _, false, _, nullptr));
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
       .Times(1)
       .WillOnce(Return(QuicConsumedData(body.length(), true)));
 
   QuicSimpleServerStreamPeer::SendResponse(stream_);
   EXPECT_FALSE(QuicStreamPeer::read_side_closed(stream_));
   EXPECT_TRUE(stream_->reading_stopped());
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
 TEST_P(QuicSimpleServerStreamTest, SendReponseWithPushResources) {
   // Tests that if a reponse has push resources to be send, SendResponse() will
   // call PromisePushResources() to handle these resources.
 
   // Add a request and response with valid headers into cache.
   string host = "www.google.com";
   string request_path = "/foo";
   string body = "Yummm";
   string url = host + "/bar";
   QuicInMemoryCache::ServerPushInfo push_info(GURL(url), SpdyHeaderBlock(),
                                               kDefaultPriority, "Push body");
   std::list<QuicInMemoryCache::ServerPushInfo> push_resources;
   push_resources.push_back(push_info);
-  QuicInMemoryCache::GetInstance()->AddSimpleResponseWithServerPushResources(
+  in_memory_cache_.AddSimpleResponseWithServerPushResources(
       host, request_path, 200, body, push_resources);
 
   SpdyHeaderBlock* request_headers = stream_->mutable_headers();
   (*request_headers)[":path"] = request_path;
   (*request_headers)[":authority"] = host;
   (*request_headers)[":version"] = "HTTP/1.1";
   (*request_headers)[":method"] = "GET";
 
   stream_->set_fin_received(true);
   InSequence s;
@@ skipping 17 matching lines @@
 }
 
 TEST_P(QuicSimpleServerStreamTest, PushResponseOnServerInitiatedStream) {
   // Tests that PushResponse() should take the given headers as request headers
   // and fetch response from cache, and send it out.
 
   // Create a stream with even stream id and test against this stream.
   const QuicStreamId kServerInitiatedStreamId = 2;
   // Create a server initiated stream and pass it to session_.
   QuicSimpleServerStreamPeer* server_initiated_stream =
-      new QuicSimpleServerStreamPeer(kServerInitiatedStreamId, &session_);
+      new QuicSimpleServerStreamPeer(kServerInitiatedStreamId, &session_,
+                                     &in_memory_cache_);
   session_.ActivateStream(base::WrapUnique(server_initiated_stream));
 
   const string kHost = "www.foo.com";
   const string kPath = "/bar";
   SpdyHeaderBlock headers;
   headers[":path"] = kPath;
   headers[":authority"] = kHost;
   headers[":version"] = "HTTP/1.1";
   headers[":method"] = "GET";
 
   response_headers_[":version"] = "HTTP/1.1";
   response_headers_[":status"] = "200";
   response_headers_["content-length"] = "5";
   const string kBody = "Hello";
-  QuicInMemoryCache::GetInstance()->AddResponse(
-      kHost, kPath, std::move(response_headers_), kBody);
+  in_memory_cache_.AddResponse(kHost, kPath, std::move(response_headers_),
+                               kBody);
 
   // Call PushResponse() should trigger stream to fetch response from cache
   // and send it back.
   EXPECT_CALL(session_,
               WriteHeadersMock(kServerInitiatedStreamId, _, false,
                                server_initiated_stream->priority(), nullptr));
   EXPECT_CALL(session_, WritevData(_, kServerInitiatedStreamId, _, _, _, _))
       .Times(1)
       .WillOnce(Return(QuicConsumedData(kBody.size(), true)));
   server_initiated_stream->PushResponse(std::move(headers));
@@ skipping 130 matching lines @@
   };
   StringPiece data(arr, arraysize(arr));
   QuicStreamFrame frame(stream_->id(), true, 0, data);
   // Verify that we don't crash when we get a invalid headers in stream frame.
   stream_->OnStreamFrame(frame);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net