Pass QuicInMemoryCache directly instead of using a singleton.

net/quic/core/quic_server_session_base_test.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 "net/quic/core/quic_server_session_base.h"
 
 #include <cstdint>
 #include <memory>
 
 #include "base/macros.h"
@@ skipping 65 matching lines @@
 
 namespace {
 
 class TestServerSession : public QuicServerSessionBase {
  public:
   TestServerSession(const QuicConfig& config,
                     QuicConnection* connection,
                     QuicSession::Visitor* visitor,
                     QuicCryptoServerStream::Helper* helper,
                     const QuicCryptoServerConfig* crypto_config,
-                    QuicCompressedCertsCache* compressed_certs_cache)
+                    QuicCompressedCertsCache* compressed_certs_cache,
+                    QuicInMemoryCache* in_memory_cache)
       : QuicServerSessionBase(config,
                               connection,
                               visitor,
                               helper,
                               crypto_config,
-                              compressed_certs_cache) {}
+                              compressed_certs_cache),
+        in_memory_cache_(in_memory_cache) {}
 
   ~TestServerSession() override { delete connection(); };
 
  protected:
   QuicSpdyStream* CreateIncomingDynamicStream(QuicStreamId id) override {
     if (!ShouldCreateIncomingDynamicStream(id)) {
       return nullptr;
     }
-    QuicSpdyStream* stream = new QuicSimpleServerStream(id, this);
+    QuicSpdyStream* stream =
+        new QuicSimpleServerStream(id, this, in_memory_cache_);
     ActivateStream(base::WrapUnique(stream));
     return stream;
   }
 
   QuicSpdyStream* CreateOutgoingDynamicStream(SpdyPriority priority) override {
     if (!ShouldCreateOutgoingDynamicStream()) {
       return nullptr;
     }
 
-    QuicSpdyStream* stream =
-        new QuicSimpleServerStream(GetNextOutgoingStreamId(), this);
+    QuicSpdyStream* stream = new QuicSimpleServerStream(
+        GetNextOutgoingStreamId(), this, in_memory_cache_);
     stream->SetPriority(priority);
     ActivateStream(base::WrapUnique(stream));
     return stream;
   }
 
   QuicCryptoServerStreamBase* CreateQuicCryptoServerStream(
       const QuicCryptoServerConfig* crypto_config,
       QuicCompressedCertsCache* compressed_certs_cache) override {
     return new QuicCryptoServerStream(
         crypto_config, compressed_certs_cache,
         FLAGS_enable_quic_stateless_reject_support, this, stream_helper());
   }
+
+ private:
+  QuicInMemoryCache* in_memory_cache_;  // Owned by QuicServerSessionBaseTest.
 };
 
 const size_t kMaxStreamsForTest = 10;
 
 class QuicServerSessionBaseTest : public ::testing::TestWithParam<QuicVersion> {
  protected:
   QuicServerSessionBaseTest()
       : QuicServerSessionBaseTest(CryptoTestUtils::ProofSourceForTesting()) {}
 
   explicit QuicServerSessionBaseTest(std::unique_ptr<ProofSource> proof_source)
       : crypto_config_(QuicCryptoServerConfig::TESTING,
                        QuicRandom::GetInstance(),
                        std::move(proof_source)),
         compressed_certs_cache_(
             QuicCompressedCertsCache::kQuicCompressedCertsCacheSize) {
     config_.SetMaxStreamsPerConnection(kMaxStreamsForTest, kMaxStreamsForTest);
     config_.SetMaxIncomingDynamicStreamsToSend(kMaxStreamsForTest);
     QuicConfigPeer::SetReceivedMaxIncomingDynamicStreams(&config_,
                                                          kMaxStreamsForTest);
     config_.SetInitialStreamFlowControlWindowToSend(
         kInitialStreamFlowControlWindowForTest);
     config_.SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
 
     connection_ = new StrictMock<MockQuicConnection>(
         &helper_, &alarm_factory_, Perspective::IS_SERVER,
         SupportedVersions(GetParam()));
-    session_.reset(new TestServerSession(config_, connection_, &owner_,
-                                         &stream_helper_, &crypto_config_,
-                                         &compressed_certs_cache_));
+    session_.reset(new TestServerSession(
+        config_, connection_, &owner_, &stream_helper_, &crypto_config_,
+        &compressed_certs_cache_, &in_memory_cache_));
     MockClock clock;
     handshake_message_.reset(crypto_config_.AddDefaultConfig(
         QuicRandom::GetInstance(), &clock,
         QuicCryptoServerConfig::ConfigOptions()));
     session_->Initialize();
     visitor_ = QuicConnectionPeer::GetVisitor(connection_);
   }
 
   StrictMock<MockQuicSessionVisitor> owner_;
   StrictMock<MockQuicCryptoServerStreamHelper> stream_helper_;
   MockQuicConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
   StrictMock<MockQuicConnection>* connection_;
   QuicConfig config_;
   QuicCryptoServerConfig crypto_config_;
   QuicCompressedCertsCache compressed_certs_cache_;
+  QuicInMemoryCache in_memory_cache_;
   std::unique_ptr<TestServerSession> session_;
   std::unique_ptr<CryptoHandshakeMessage> handshake_message_;
   QuicConnectionVisitorInterface* visitor_;
   QuicFlagSaver flags_;  // Save/restore all QUIC flag values.
 };
 
 // Compares CachedNetworkParameters.
 MATCHER_P(EqualsProto, network_params, "") {
   CachedNetworkParameters reference(network_params);
   return (arg->bandwidth_estimate_bytes_per_second() ==
@@ skipping 467 matching lines @@
 
   // Allow the async ProofSource::GetProof call to complete.  Verify (under
   // asan) that this does not result in accesses to any freed memory from the
   // session or its subobjects.
   GetFakeProofSource()->InvokePendingCallback(0);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net