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

net/tools/quic/quic_dispatcher_test.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_dispatcher.h"
 
 #include <ostream>
 #include <string>
 
 #include "base/macros.h"
@@ skipping 32 matching lines @@
 using testing::_;
 
 namespace net {
 namespace test {
 namespace {
 
 class TestQuicSpdyServerSession : public QuicServerSessionBase {
  public:
   TestQuicSpdyServerSession(const QuicConfig& config,
                             QuicConnection* connection,
-                            const QuicCryptoServerConfig* crypto_config)
-      : QuicServerSessionBase(config, connection, nullptr, crypto_config),
+                            const QuicCryptoServerConfig* crypto_config,
+                            QuicCompressedCertsCache* compressed_certs_cache)
+      : QuicServerSessionBase(config,
+                              connection,
+                              nullptr,
+                              crypto_config,
+                              compressed_certs_cache),
         crypto_stream_(QuicServerSessionBase::GetCryptoStream()) {}
   ~TestQuicSpdyServerSession() override{};
 
   MOCK_METHOD2(OnConnectionClosed,
                void(QuicErrorCode error, ConnectionCloseSource source));
   MOCK_METHOD1(CreateIncomingDynamicStream, QuicSpdyStream*(QuicStreamId id));
   MOCK_METHOD1(CreateOutgoingDynamicStream,
                QuicSpdyStream*(SpdyPriority priority));
 
   QuicCryptoServerStreamBase* CreateQuicCryptoServerStream(
@@ skipping 55 matching lines @@
   QuicDispatcher* dispatcher_;
 };
 
 QuicServerSessionBase* CreateSession(
     QuicDispatcher* dispatcher,
     const QuicConfig& config,
     QuicConnectionId connection_id,
     const IPEndPoint& client_address,
     MockConnectionHelper* helper,
     const QuicCryptoServerConfig* crypto_config,
+    QuicCompressedCertsCache* compressed_certs_cache,
     TestQuicSpdyServerSession** session) {
   MockServerConnection* connection =
       new MockServerConnection(connection_id, helper, dispatcher);
-  *session = new TestQuicSpdyServerSession(config, connection, crypto_config);
+  *session = new TestQuicSpdyServerSession(config, connection, crypto_config,
+                                           compressed_certs_cache);
   connection->set_visitor(*session);
   ON_CALL(*connection, SendConnectionCloseWithDetails(_, _))
       .WillByDefault(WithoutArgs(Invoke(
           connection, &MockServerConnection::UnregisterOnConnectionClosed)));
   EXPECT_CALL(*reinterpret_cast<MockConnection*>((*session)->connection()),
               ProcessUdpPacket(_, client_address, _));
 
   return *session;
 }
 
@@ skipping 105 matching lines @@
   TestQuicSpdyServerSession* session1_;
   TestQuicSpdyServerSession* session2_;
   string data_;
 };
 
 TEST_F(QuicDispatcherTest, ProcessPackets) {
   IPEndPoint client_address(net::test::Loopback4(), 1);
   server_address_ = IPEndPoint(net::test::Any4(), 5);
 
   EXPECT_CALL(dispatcher_, CreateQuicSession(1, client_address))
-      .WillOnce(testing::Return(CreateSession(&dispatcher_, config_, 1,
-                                              client_address, &mock_helper_,
-                                              &crypto_config_, &session1_)));
+      .WillOnce(testing::Return(CreateSession(
+          &dispatcher_, config_, 1, client_address, &mock_helper_,
+          &crypto_config_, QuicDispatcherPeer::GetCache(&dispatcher_),
+          &session1_)));
   ProcessPacket(client_address, 1, true, false, "foo");
   EXPECT_EQ(client_address, dispatcher_.current_client_address());
   EXPECT_EQ(server_address_, dispatcher_.current_server_address());
 
   EXPECT_CALL(dispatcher_, CreateQuicSession(2, client_address))
-      .WillOnce(testing::Return(CreateSession(&dispatcher_, config_, 2,
-                                              client_address, &mock_helper_,
-                                              &crypto_config_, &session2_)));
+      .WillOnce(testing::Return(CreateSession(
+          &dispatcher_, config_, 2, client_address, &mock_helper_,
+          &crypto_config_, QuicDispatcherPeer::GetCache(&dispatcher_),
+          &session2_)));
   ProcessPacket(client_address, 2, true, false, "bar");
 
   EXPECT_CALL(*reinterpret_cast<MockConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .Times(1)
       .WillOnce(testing::WithArgs<2>(
           Invoke(this, &QuicDispatcherTest::ValidatePacket)));
   ProcessPacket(client_address, 1, false, false, "eep");
 }
 
 TEST_F(QuicDispatcherTest, StatelessVersionNegotiation) {
   ValueRestore<bool> old_flag(&FLAGS_quic_stateless_version_negotiation, true);
   IPEndPoint client_address(net::test::Loopback4(), 1);
   server_address_ = IPEndPoint(net::test::Any4(), 5);
 
   EXPECT_CALL(dispatcher_, CreateQuicSession(1, client_address)).Times(0);
   QuicVersion version = static_cast<QuicVersion>(QuicVersionMin() - 1);
   ProcessPacket(client_address, 1, true, version, "foo",
                 PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER, 1);
 }
 
 TEST_F(QuicDispatcherTest, StatefulVersionNegotiation) {
   ValueRestore<bool> old_flag(&FLAGS_quic_stateless_version_negotiation, false);
   IPEndPoint client_address(net::test::Loopback4(), 1);
   server_address_ = IPEndPoint(net::test::Any4(), 5);
 
   EXPECT_CALL(dispatcher_, CreateQuicSession(1, client_address))
-      .WillOnce(testing::Return(CreateSession(&dispatcher_, config_, 1,
-                                              client_address, &mock_helper_,
-                                              &crypto_config_, &session1_)));
+      .WillOnce(testing::Return(CreateSession(
+          &dispatcher_, config_, 1, client_address, &mock_helper_,
+          &crypto_config_, QuicDispatcherPeer::GetCache(&dispatcher_),
+          &session1_)));
   QuicVersion version = static_cast<QuicVersion>(QuicVersionMin() - 1);
   ProcessPacket(client_address, 1, true, version, "foo",
                 PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER, 1);
 }
 
 TEST_F(QuicDispatcherTest, Shutdown) {
   IPEndPoint client_address(net::test::Loopback4(), 1);
 
   EXPECT_CALL(dispatcher_, CreateQuicSession(_, client_address))
-      .WillOnce(testing::Return(CreateSession(&dispatcher_, config_, 1,
-                                              client_address, &mock_helper_,
-                                              &crypto_config_, &session1_)));
+      .WillOnce(testing::Return(CreateSession(
+          &dispatcher_, config_, 1, client_address, &mock_helper_,
+          &crypto_config_, QuicDispatcherPeer::GetCache(&dispatcher_),
+          &session1_)));
 
   ProcessPacket(client_address, 1, true, false, "foo");
 
   EXPECT_CALL(*reinterpret_cast<MockConnection*>(session1_->connection()),
               SendConnectionCloseWithDetails(QUIC_PEER_GOING_AWAY, _));
 
   dispatcher_.Shutdown();
 }
 
 TEST_F(QuicDispatcherTest, TimeWaitListManager) {
   CreateTimeWaitListManager();
 
   // Create a new session.
   IPEndPoint client_address(net::test::Loopback4(), 1);
   QuicConnectionId connection_id = 1;
   EXPECT_CALL(dispatcher_, CreateQuicSession(connection_id, client_address))
-      .WillOnce(testing::Return(
-          CreateSession(&dispatcher_, config_, connection_id, client_address,
-                        &mock_helper_, &crypto_config_, &session1_)));
+      .WillOnce(testing::Return(CreateSession(
+          &dispatcher_, config_, connection_id, client_address, &mock_helper_,
+          &crypto_config_, QuicDispatcherPeer::GetCache(&dispatcher_),
+          &session1_)));
   ProcessPacket(client_address, connection_id, true, false, "foo");
 
   // Close the connection by sending public reset packet.
   QuicPublicResetPacket packet;
   packet.public_header.connection_id = connection_id;
   packet.public_header.reset_flag = true;
   packet.public_header.version_flag = false;
   packet.rejected_packet_number = 19191;
   packet.nonce_proof = 132232;
   scoped_ptr<QuicEncryptedPacket> encrypted(
@@ skipping 123 matching lines @@
            !GetParam().crypto_handshake_successful &&
            GetParam().client_supports_statelesss_rejects;
   }
 
   // Sets up dispatcher_, sesession1_, and crypto_stream1_ based on
   // the test parameters.
   QuicServerSessionBase* CreateSessionBasedOnTestParams(
       QuicConnectionId connection_id,
       const IPEndPoint& client_address) {
     CreateSession(&dispatcher_, config_, connection_id, client_address,
-                  &mock_helper_, &crypto_config_, &session1_);
+                  &mock_helper_, &crypto_config_,
+                  QuicDispatcherPeer::GetCache(&dispatcher_), &session1_);
 
     crypto_stream1_ = new MockQuicCryptoServerStream(crypto_config_, session1_);
     session1_->SetCryptoStream(crypto_stream1_);
     crypto_stream1_->set_handshake_confirmed_for_testing(
         GetParam().crypto_handshake_successful);
     crypto_stream1_->SetPeerSupportsStatelessRejects(
         GetParam().client_supports_statelesss_rejects);
     return session1_;
   }
 
@@ skipping 13 matching lines @@
       .Times(0);
   ProcessPacket(client_address, 1, true, false, "foo");
 }
 
 TEST_F(QuicDispatcherTest, OKSeqNoPacketProcessed) {
   IPEndPoint client_address(net::test::Loopback4(), 1);
   QuicConnectionId connection_id = 1;
   server_address_ = IPEndPoint(net::test::Any4(), 5);
 
   EXPECT_CALL(dispatcher_, CreateQuicSession(1, client_address))
-      .WillOnce(testing::Return(CreateSession(&dispatcher_, config_, 1,
-                                              client_address, &mock_helper_,
-                                              &crypto_config_, &session1_)));
+      .WillOnce(testing::Return(CreateSession(
+          &dispatcher_, config_, 1, client_address, &mock_helper_,
+          &crypto_config_, QuicDispatcherPeer::GetCache(&dispatcher_),
+          &session1_)));
   // A packet whose packet number is the largest that is allowed to start a
   // connection.
   ProcessPacket(client_address, connection_id, true, false, "data",
                 PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER,
                 kDefaultPathId,
                 QuicDispatcher::kMaxReasonableInitialPacketNumber);
   EXPECT_EQ(client_address, dispatcher_.current_client_address());
   EXPECT_EQ(server_address_, dispatcher_.current_server_address());
 }
 
@@ skipping 125 matching lines @@
 
 class QuicDispatcherWriteBlockedListTest : public QuicDispatcherTest {
  public:
   void SetUp() override {
     writer_ = new BlockingWriter;
     QuicDispatcherPeer::UseWriter(&dispatcher_, writer_);
 
     IPEndPoint client_address(net::test::Loopback4(), 1);
 
     EXPECT_CALL(dispatcher_, CreateQuicSession(_, client_address))
-        .WillOnce(testing::Return(CreateSession(&dispatcher_, config_, 1,
-                                                client_address, &helper_,
-                                                &crypto_config_, &session1_)));
+        .WillOnce(testing::Return(CreateSession(
+            &dispatcher_, config_, 1, client_address, &helper_, &crypto_config_,
+            QuicDispatcherPeer::GetCache(&dispatcher_), &session1_)));
     ProcessPacket(client_address, 1, true, false, "foo");
 
     EXPECT_CALL(dispatcher_, CreateQuicSession(_, client_address))
-        .WillOnce(testing::Return(CreateSession(&dispatcher_, config_, 2,
-                                                client_address, &helper_,
-                                                &crypto_config_, &session2_)));
+        .WillOnce(testing::Return(CreateSession(
+            &dispatcher_, config_, 2, client_address, &helper_, &crypto_config_,
+            QuicDispatcherPeer::GetCache(&dispatcher_), &session2_)));
     ProcessPacket(client_address, 2, true, false, "bar");
 
     blocked_list_ = QuicDispatcherPeer::GetWriteBlockedList(&dispatcher_);
   }
 
   void TearDown() override {
     EXPECT_CALL(*connection1(),
                 SendConnectionCloseWithDetails(QUIC_PEER_GOING_AWAY, _));
     EXPECT_CALL(*connection2(),
                 SendConnectionCloseWithDetails(QUIC_PEER_GOING_AWAY, _));
@@ skipping 140 matching lines @@
 
   // And we'll resume where we left off when we get another call.
   EXPECT_CALL(*connection2(), OnCanWrite());
   dispatcher_.OnCanWrite();
   EXPECT_FALSE(dispatcher_.HasPendingWrites());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net