Add a QuicCompressedCertsCache instance to QuicDispatcher, plumbing to QuicServerSessionBase but no…

net/tools/quic/test_tools/quic_test_server.cc

 // Copyright (c) 2015 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/test_tools/quic_test_server.h"
 
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 15 matching lines @@
 namespace net {
 namespace test {
 
 class CustomStreamSession : public QuicSimpleServerSession {
  public:
   CustomStreamSession(
       const QuicConfig& config,
       QuicConnection* connection,
       QuicServerSessionVisitor* visitor,
       const QuicCryptoServerConfig* crypto_config,
+      QuicCompressedCertsCache* compressed_certs_cache,
       QuicTestServer::StreamFactory* factory,
       QuicTestServer::CryptoStreamFactory* crypto_stream_factory)
-      : QuicSimpleServerSession(config, connection, visitor, crypto_config),
+      : QuicSimpleServerSession(config,
+                                connection,
+                                visitor,
+                                crypto_config,
+                                compressed_certs_cache),
         stream_factory_(factory),
         crypto_stream_factory_(crypto_stream_factory) {}
 
   QuicSpdyStream* CreateIncomingDynamicStream(QuicStreamId id) override {
     if (!ShouldCreateIncomingDynamicStream(id)) {
       return nullptr;
     }
     if (stream_factory_) {
       QuicSpdyStream* stream = stream_factory_->CreateStream(id, this);
       ActivateStream(stream);
@@ skipping 32 matching lines @@
     if (session_factory_ == nullptr && stream_factory_ == nullptr &&
         crypto_stream_factory_ == nullptr) {
       return QuicDispatcher::CreateQuicSession(id, client);
     }
     QuicConnection* connection = new QuicConnection(
         id, client, helper(), CreatePerConnectionWriter(),
         /* owns_writer= */ true, Perspective::IS_SERVER, supported_versions());
 
     QuicServerSessionBase* session = nullptr;
     if (stream_factory_ != nullptr || crypto_stream_factory_ != nullptr) {
-      session =
-          new CustomStreamSession(config(), connection, this, crypto_config(),
-                                  stream_factory_, crypto_stream_factory_);
+      session = new CustomStreamSession(
+          config(), connection, this, crypto_config(), compressed_certs_cache(),
+          stream_factory_, crypto_stream_factory_);
     } else {
       session = session_factory_->CreateSession(config(), connection, this,
-                                                crypto_config());
+                                                crypto_config(),
+                                                compressed_certs_cache());
     }
     session->Initialize();
     return session;
   }
 
   void SetSessionFactory(QuicTestServer::SessionFactory* factory) {
     base::AutoLock lock(factory_lock_);
     DCHECK(session_factory_ == nullptr);
     DCHECK(stream_factory_ == nullptr);
     DCHECK(crypto_stream_factory_ == nullptr);
@@ skipping 51 matching lines @@
   static_cast<QuicTestDispatcher*>(dispatcher())
       ->SetCryptoStreamFactory(factory);
 }
 
 ///////////////////////////   TEST SESSIONS ///////////////////////////////
 
 ImmediateGoAwaySession::ImmediateGoAwaySession(
     const QuicConfig& config,
     QuicConnection* connection,
     QuicServerSessionVisitor* visitor,
-    const QuicCryptoServerConfig* crypto_config)
-    : QuicSimpleServerSession(config, connection, visitor, crypto_config) {
+    const QuicCryptoServerConfig* crypto_config,
+    QuicCompressedCertsCache* compressed_certs_cache)
+    : QuicSimpleServerSession(config,
+                              connection,
+                              visitor,
+                              crypto_config,
+                              compressed_certs_cache) {
   SendGoAway(QUIC_PEER_GOING_AWAY, "");
 }
 
 }  // namespace test
 }  // namespace net