Pass QuicInMemoryCache directly instead of using a singleton.

net/tools/quic/quic_server.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 "net/tools/quic/quic_server.h"
 
 #include <errno.h>
 #include <features.h>
 #include <netinet/in.h>
 #include <string.h>
@@ skipping 31 matching lines @@
 // generated using `wget -p --save-headers <url>`
 std::string FLAGS_quic_in_memory_cache_dir = "";
 
 const int kEpollFlags = EPOLLIN | EPOLLOUT | EPOLLET;
 const char kSourceAddressTokenSecret[] = "secret";
 
 }  // namespace
 
 const size_t kNumSessionsToCreatePerSocketEvent = 16;
 
-QuicServer::QuicServer(std::unique_ptr<ProofSource> proof_source)
+QuicServer::QuicServer(std::unique_ptr<ProofSource> proof_source,
+                       QuicInMemoryCache* in_memory_cache)
     : QuicServer(std::move(proof_source),
                  QuicConfig(),
                  QuicCryptoServerConfig::ConfigOptions(),
-                 AllSupportedVersions()) {}
+                 AllSupportedVersions(),
+                 in_memory_cache) {}
 
 QuicServer::QuicServer(
     std::unique_ptr<ProofSource> proof_source,
     const QuicConfig& config,
     const QuicCryptoServerConfig::ConfigOptions& crypto_config_options,
-    const QuicVersionVector& supported_versions)
+    const QuicVersionVector& supported_versions,
+    QuicInMemoryCache* in_memory_cache)
     : port_(0),
       fd_(-1),
       packets_dropped_(0),
       overflow_supported_(false),
       config_(config),
       crypto_config_(kSourceAddressTokenSecret,
                      QuicRandom::GetInstance(),
                      std::move(proof_source)),
       crypto_config_options_(crypto_config_options),
       version_manager_(supported_versions),
-      packet_reader_(new QuicPacketReader()) {
+      packet_reader_(new QuicPacketReader()),
+      in_memory_cache_(in_memory_cache) {
   Initialize();
 }
 
 void QuicServer::Initialize() {
   // If an initial flow control window has not explicitly been set, then use a
   // sensible value for a server: 1 MB for session, 64 KB for each stream.
   const uint32_t kInitialSessionFlowControlWindow = 1 * 1024 * 1024;  // 1 MB
   const uint32_t kInitialStreamFlowControlWindow = 64 * 1024;         // 64 KB
   if (config_.GetInitialStreamFlowControlWindowToSend() ==
       kMinimumFlowControlSendWindow) {
     config_.SetInitialStreamFlowControlWindowToSend(
         kInitialStreamFlowControlWindow);
   }
   if (config_.GetInitialSessionFlowControlWindowToSend() ==
       kMinimumFlowControlSendWindow) {
     config_.SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindow);
   }
 
   epoll_server_.set_timeout_in_us(50 * 1000);
 
   if (!FLAGS_quic_in_memory_cache_dir.empty()) {
-    QuicInMemoryCache::GetInstance()->InitializeFromDirectory(
-        FLAGS_quic_in_memory_cache_dir);
+    in_memory_cache_->InitializeFromDirectory(FLAGS_quic_in_memory_cache_dir);
   }
 
   QuicEpollClock clock(&epoll_server_);
 
   std::unique_ptr<CryptoHandshakeMessage> scfg(crypto_config_.AddDefaultConfig(
       QuicRandom::GetInstance(), &clock, crypto_config_options_));
 }
 
 QuicServer::~QuicServer() {}
 
@@ skipping 33 matching lines @@
 
 QuicDispatcher* QuicServer::CreateQuicDispatcher() {
   QuicEpollAlarmFactory alarm_factory(&epoll_server_);
   return new QuicSimpleDispatcher(
       config_, &crypto_config_, &version_manager_,
       std::unique_ptr<QuicEpollConnectionHelper>(new QuicEpollConnectionHelper(
           &epoll_server_, QuicAllocator::BUFFER_POOL)),
       std::unique_ptr<QuicCryptoServerStream::Helper>(
           new QuicSimpleCryptoServerStreamHelper(QuicRandom::GetInstance())),
       std::unique_ptr<QuicEpollAlarmFactory>(
-          new QuicEpollAlarmFactory(&epoll_server_)));
+          new QuicEpollAlarmFactory(&epoll_server_)),
+      in_memory_cache_);
 }
 
 void QuicServer::WaitForEvents() {
   epoll_server_.WaitForEventsAndExecuteCallbacks();
 }
 
 void QuicServer::Shutdown() {
   // Before we shut down the epoll server, give all active sessions a chance to
   // notify clients that they're closing.
   dispatcher_->Shutdown();
@@ skipping 30 matching lines @@
     dispatcher_->OnCanWrite();
     if (dispatcher_->HasPendingWrites()) {
       event->out_ready_mask |= EPOLLOUT;
     }
   }
   if (event->in_events & EPOLLERR) {
   }
 }
 
 }  // namespace net