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

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 "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_flags.h"
@@ skipping 66 matching lines @@
 
   static SpdyHeaderBlock& headers(QuicSimpleServerStream* stream) {
     return stream->request_headers_;
   }
 };
 
 class MockQuicSimpleServerSession : public QuicSimpleServerSession {
  public:
   const size_t kMaxStreamsForTest = 100;
 
-  explicit MockQuicSimpleServerSession(QuicConnection* connection,
-                                       MockQuicServerSessionVisitor* owner,
-                                       QuicCryptoServerConfig* crypto_config)
-      : QuicSimpleServerSession(::net::test::DefaultQuicConfig(),
+  explicit MockQuicSimpleServerSession(
+      QuicConnection* connection,
+      MockQuicServerSessionVisitor* owner,
+      QuicCryptoServerConfig* crypto_config,
+      QuicCompressedCertsCache* compressed_certs_cache)
+      : QuicSimpleServerSession(DefaultQuicConfig(),
                                 connection,
                                 owner,
-                                crypto_config) {
+                                crypto_config,
+                                compressed_certs_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_METHOD2(OnConnectionClosed,
                void(QuicErrorCode error, ConnectionCloseSource source));
@@ skipping 41 matching lines @@
   QuicSimpleServerStreamTest()
       : connection_(
             new StrictMock<MockConnection>(&helper_,
                                            Perspective::IS_SERVER,
                                            SupportedVersions(GetParam()))),
         session_owner_(new StrictMock<MockQuicServerSessionVisitor>()),
         crypto_config_(new QuicCryptoServerConfig(
             QuicCryptoServerConfig::TESTING,
             QuicRandom::GetInstance(),
             ::net::test::CryptoTestUtils::ProofSourceForTesting())),
-        session_(connection_, session_owner_, crypto_config_.get()),
+        compressed_certs_cache_(
+            QuicCompressedCertsCache::kQuicCompressedCertsCacheSize),
+        session_(connection_,
+                 session_owner_,
+                 crypto_config_.get(),
+                 &compressed_certs_cache_),
         body_("hello world") {
     FLAGS_quic_always_log_bugs_for_tests = true;
     SpdyHeaderBlock request_headers;
     request_headers[":host"] = "";
     request_headers[":authority"] = "www.google.com";
     request_headers[":path"] = "/";
     request_headers[":method"] = "POST";
     request_headers[":version"] = "HTTP/1.1";
     request_headers["content-length"] = "11";
 
@@ skipping 24 matching lines @@
 
   StringPiece StreamHeadersValue(const string& key) {
     return (*stream_->mutable_headers())[key];
   }
 
   SpdyHeaderBlock response_headers_;
   MockConnectionHelper helper_;
   StrictMock<MockConnection>* connection_;
   StrictMock<MockQuicServerSessionVisitor>* session_owner_;
   std::unique_ptr<QuicCryptoServerConfig> crypto_config_;
+  QuicCompressedCertsCache compressed_certs_cache_;
   StrictMock<MockQuicSimpleServerSession> session_;
   QuicSimpleServerStreamPeer* stream_;  // Owned by session_.
   string headers_string_;
   string body_;
 };
 
 INSTANTIATE_TEST_CASE_P(Tests,
                         QuicSimpleServerStreamTest,
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
@@ skipping 384 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