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

net/tools/quic/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/tools/quic/quic_server_session_base.h"
 
 #include "base/macros.h"
 #include "net/quic/crypto/quic_crypto_server_config.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/proto/cached_network_parameters.pb.h"
@@ skipping 55 matching lines @@
   }
 };
 
 namespace {
 
 class TestServerSession : public QuicServerSessionBase {
  public:
   TestServerSession(const QuicConfig& config,
                     QuicConnection* connection,
                     QuicServerSessionVisitor* visitor,
-                    const QuicCryptoServerConfig* crypto_config)
-      : QuicServerSessionBase(config, connection, visitor, crypto_config) {}
+                    const QuicCryptoServerConfig* crypto_config,
+                    QuicCompressedCertsCache* compressed_certs_cache)
+      : QuicServerSessionBase(config,
+                              connection,
+                              visitor,
+                              crypto_config,
+                              compressed_certs_cache) {}
 
   ~TestServerSession() override{};
 
  protected:
   QuicSpdyStream* CreateIncomingDynamicStream(QuicStreamId id) override {
     if (!ShouldCreateIncomingDynamicStream(id)) {
       return nullptr;
     }
     QuicSpdyStream* stream = new QuicSimpleServerStream(id, this);
     ActivateStream(stream);
@@ skipping 19 matching lines @@
   }
 };
 
 const size_t kMaxStreamsForTest = 10;
 
 class QuicServerSessionBaseTest : public ::testing::TestWithParam<QuicVersion> {
  protected:
   QuicServerSessionBaseTest()
       : crypto_config_(QuicCryptoServerConfig::TESTING,
                        QuicRandom::GetInstance(),
-                       CryptoTestUtils::ProofSourceForTesting()) {
+                       CryptoTestUtils::ProofSourceForTesting()),
+        compressed_certs_cache_(
+            QuicCompressedCertsCache::kQuicCompressedCertsCacheSize) {
+    FLAGS_quic_always_log_bugs_for_tests = true;
     config_.SetMaxStreamsPerConnection(kMaxStreamsForTest, kMaxStreamsForTest);
     config_.SetInitialStreamFlowControlWindowToSend(
         kInitialStreamFlowControlWindowForTest);
     config_.SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
 
     connection_ = new StrictMock<MockConnection>(
         &helper_, Perspective::IS_SERVER, SupportedVersions(GetParam()));
-    session_.reset(
-        new TestServerSession(config_, connection_, &owner_, &crypto_config_));
+    session_.reset(new TestServerSession(config_, connection_, &owner_,
+                                         &crypto_config_,
+                                         &compressed_certs_cache_));
     MockClock clock;
     handshake_message_.reset(crypto_config_.AddDefaultConfig(
         QuicRandom::GetInstance(), &clock,
         QuicCryptoServerConfig::ConfigOptions()));
     session_->Initialize();
     visitor_ = QuicConnectionPeer::GetVisitor(connection_);
   }
 
   StrictMock<MockQuicServerSessionVisitor> owner_;
   MockConnectionHelper helper_;
   StrictMock<MockConnection>* connection_;
   QuicConfig config_;
   QuicCryptoServerConfig crypto_config_;
+  QuicCompressedCertsCache compressed_certs_cache_;
   scoped_ptr<TestServerSession> session_;
   scoped_ptr<CryptoHandshakeMessage> handshake_message_;
   QuicConnectionVisitorInterface* visitor_;
 };
 
 // Compares CachedNetworkParameters.
 MATCHER_P(EqualsProto, network_params, "") {
   CachedNetworkParameters reference(network_params);
   return (arg->bandwidth_estimate_bytes_per_second() ==
               reference.bandwidth_estimate_bytes_per_second() &&
@@ skipping 361 matching lines @@
   EXPECT_FALSE(
       QuicServerSessionBasePeer::IsBandwidthResumptionEnabled(session_.get()));
   session_->OnConfigNegotiated();
   EXPECT_FALSE(
       QuicServerSessionBasePeer::IsBandwidthResumptionEnabled(session_.get()));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net