Land Recent QUIC Changes until 03/22/2015.

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 <string>
 
 #include "base/strings/string_piece.h"
 #include "net/quic/crypto/crypto_handshake.h"
@@ skipping 24 matching lines @@
 using testing::InSequence;
 using testing::Invoke;
 using testing::WithoutArgs;
 using testing::_;
 
 namespace net {
 namespace tools {
 namespace test {
 namespace {
 
+class TestServerSession : public QuicServerSession {
+ public:
+  TestServerSession(const QuicConfig& config, QuicConnection* connection)
+      : QuicServerSession(config, connection, nullptr) {}
+  ~TestServerSession() override{};
+
+  MOCK_METHOD2(OnConnectionClosed, void(QuicErrorCode error, bool from_peer));
+  MOCK_METHOD1(CreateIncomingDataStream, QuicDataStream*(QuicStreamId id));
+  MOCK_METHOD0(CreateOutgoingDataStream, QuicDataStream*());
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestServerSession);
+};
+
 class TestDispatcher : public QuicDispatcher {
  public:
   explicit TestDispatcher(const QuicConfig& config,
                           const QuicCryptoServerConfig& crypto_config,
                           EpollServer* eps)
       : QuicDispatcher(config,
                        crypto_config,
                        QuicSupportedVersions(),
                        new QuicDispatcher::DefaultPacketWriterFactory(),
                        new QuicEpollConnectionHelper(eps)) {
   }
 
-  MOCK_METHOD3(CreateQuicSession, QuicSession*(
-      QuicConnectionId connection_id,
-      const IPEndPoint& server_address,
-      const IPEndPoint& client_address));
+  MOCK_METHOD3(CreateQuicSession,
+               QuicServerSession*(QuicConnectionId connection_id,
+                                  const IPEndPoint& server_address,
+                                  const IPEndPoint& client_address));
 
   using QuicDispatcher::current_server_address;
   using QuicDispatcher::current_client_address;
 };
 
 // A Connection class which unregisters the session from the dispatcher
 // when sending connection close.
 // It'd be slightly more realistic to do this from the Session but it would
 // involve a lot more mocking.
 class MockServerConnection : public MockConnection {
  public:
   MockServerConnection(QuicConnectionId connection_id,
                        QuicDispatcher* dispatcher)
       : MockConnection(connection_id, Perspective::IS_SERVER),
         dispatcher_(dispatcher) {}
 
   void UnregisterOnConnectionClosed() {
     LOG(ERROR) << "Unregistering " << connection_id();
     dispatcher_->OnConnectionClosed(connection_id(), QUIC_NO_ERROR);
   }
+
  private:
   QuicDispatcher* dispatcher_;
 };
 
-QuicSession* CreateSession(QuicDispatcher* dispatcher,
-                           QuicConnectionId connection_id,
-                           const IPEndPoint& client_address,
-                           MockSession** session) {
+QuicServerSession* CreateSession(QuicDispatcher* dispatcher,
+                                 const QuicConfig& config,
+                                 QuicConnectionId connection_id,
+                                 const IPEndPoint& client_address,
+                                 TestServerSession** session) {
   MockServerConnection* connection =
       new MockServerConnection(connection_id, dispatcher);
-  *session = new MockSession(connection);
+  *session = new TestServerSession(config, connection);
+  connection->set_visitor(*session);
   ON_CALL(*connection, SendConnectionClose(_)).WillByDefault(
       WithoutArgs(Invoke(
           connection, &MockServerConnection::UnregisterOnConnectionClosed)));
   EXPECT_CALL(*reinterpret_cast<MockConnection*>((*session)->connection()),
               ProcessUdpPacket(_, client_address, _));
 
   return *session;
 }
 
 class QuicDispatcherTest : public ::testing::Test {
@@ skipping 53 matching lines @@
                                                time_wait_list_manager_);
   }
 
   EpollServer eps_;
   QuicEpollConnectionHelper helper_;
   QuicConfig config_;
   QuicCryptoServerConfig crypto_config_;
   IPEndPoint server_address_;
   TestDispatcher dispatcher_;
   MockTimeWaitListManager* time_wait_list_manager_;
-  MockSession* session1_;
-  MockSession* session2_;
+  TestServerSession* session1_;
+  TestServerSession* session2_;
   string data_;
 };
 
 TEST_F(QuicDispatcherTest, ProcessPackets) {
   IPEndPoint client_address(net::test::Loopback4(), 1);
   IPAddressNumber any4;
   CHECK(net::ParseIPLiteralToNumber("0.0.0.0", &any4));
   server_address_ = IPEndPoint(any4, 5);
 
   EXPECT_CALL(dispatcher_, CreateQuicSession(1, _, client_address))
-      .WillOnce(testing::Return(CreateSession(
-          &dispatcher_, 1, client_address, &session1_)));
+      .WillOnce(testing::Return(
+          CreateSession(&dispatcher_, config_, 1, client_address, &session1_)));
   ProcessPacket(client_address, 1, true, "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_, 2, client_address, &session2_)));
+      .WillOnce(testing::Return(
+          CreateSession(&dispatcher_, config_, 2, client_address, &session2_)));
   ProcessPacket(client_address, 2, true, "bar");
 
   EXPECT_CALL(*reinterpret_cast<MockConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _)).Times(1).
       WillOnce(testing::WithArgs<2>(Invoke(
           this, &QuicDispatcherTest::ValidatePacket)));
   ProcessPacket(client_address, 1, false, "eep");
 }
 
 TEST_F(QuicDispatcherTest, Shutdown) {
   IPEndPoint client_address(net::test::Loopback4(), 1);
 
   EXPECT_CALL(dispatcher_, CreateQuicSession(_, _, client_address))
-      .WillOnce(testing::Return(CreateSession(
-                    &dispatcher_, 1, client_address, &session1_)));
+      .WillOnce(testing::Return(
+          CreateSession(&dispatcher_, config_, 1, client_address, &session1_)));
 
   ProcessPacket(client_address, 1, true, "foo");
 
   EXPECT_CALL(*reinterpret_cast<MockConnection*>(session1_->connection()),
               SendConnectionClose(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_, connection_id, client_address, &session1_)));
+          &dispatcher_, config_, connection_id, client_address, &session1_)));
   ProcessPacket(client_address, connection_id, true, "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_sequence_number = 19191;
   packet.nonce_proof = 132232;
   scoped_ptr<QuicEncryptedPacket> encrypted(
       QuicFramer::BuildPublicResetPacket(packet));
   EXPECT_CALL(*session1_, OnConnectionClosed(QUIC_PUBLIC_RESET, true)).Times(1)
       .WillOnce(WithoutArgs(Invoke(
           reinterpret_cast<MockServerConnection*>(session1_->connection()),
           &MockServerConnection::UnregisterOnConnectionClosed)));
   EXPECT_CALL(*reinterpret_cast<MockConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .WillOnce(Invoke(
           reinterpret_cast<MockConnection*>(session1_->connection()),
           &MockConnection::ReallyProcessUdpPacket));
   dispatcher_.ProcessPacket(IPEndPoint(), client_address, *encrypted);
   EXPECT_TRUE(time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id));
 
   // Dispatcher forwards subsequent packets for this connection_id to the time
   // wait list manager.
   EXPECT_CALL(*time_wait_list_manager_,
               ProcessPacket(_, _, connection_id, _, _)).Times(1);
-  EXPECT_CALL(*time_wait_list_manager_,
-              AddConnectionIdToTimeWait(_, _, _)).Times(0);
+  EXPECT_CALL(*time_wait_list_manager_, AddConnectionIdToTimeWait(_, _, _))
+      .Times(0);
   ProcessPacket(client_address, connection_id, true, "foo");
 }
 
 TEST_F(QuicDispatcherTest, StrayPacketToTimeWaitListManager) {
   CreateTimeWaitListManager();
 
   IPEndPoint client_address(net::test::Loopback4(), 1);
   QuicConnectionId connection_id = 1;
   // Dispatcher forwards all packets for this connection_id to the time wait
   // list manager.
   EXPECT_CALL(dispatcher_, CreateQuicSession(_, _, _)).Times(0);
   EXPECT_CALL(*time_wait_list_manager_,
               ProcessPacket(_, _, connection_id, _, _)).Times(1);
-  EXPECT_CALL(*time_wait_list_manager_,
-              AddConnectionIdToTimeWait(_, _, _)).Times(1);
+  EXPECT_CALL(*time_wait_list_manager_, AddConnectionIdToTimeWait(_, _, _))
+      .Times(1);
   ProcessPacket(client_address, connection_id, false, "data");
 }
 
 TEST_F(QuicDispatcherTest, ProcessPacketWithBogusPort) {
   CreateTimeWaitListManager();
 
   IPEndPoint client_address(net::test::Loopback4(), 0);
   IPAddressNumber any4;
   CHECK(net::ParseIPLiteralToNumber("0.0.0.0", &any4));
   server_address_ = IPEndPoint(any4, 5);
 
   // dispatcher_ should drop this packet.
   EXPECT_CALL(dispatcher_, CreateQuicSession(1, _, client_address)).Times(0);
   EXPECT_CALL(*time_wait_list_manager_, ProcessPacket(_, _, _, _, _)).Times(0);
-  EXPECT_CALL(*time_wait_list_manager_,
-              AddConnectionIdToTimeWait(_, _, _)).Times(0);
+  EXPECT_CALL(*time_wait_list_manager_, AddConnectionIdToTimeWait(_, _, _))
+      .Times(0);
   ProcessPacket(client_address, 1, true, "foo");
   EXPECT_EQ(client_address, dispatcher_.current_client_address());
   EXPECT_EQ(server_address_, dispatcher_.current_server_address());
 }
 
 class BlockingWriter : public QuicPacketWriterWrapper {
  public:
   BlockingWriter() : write_blocked_(false) {}
 
   bool IsWriteBlocked() const override { return write_blocked_; }
@@ skipping 17 matching lines @@
  public:
   void SetUp() override {
     writer_ = new BlockingWriter;
     QuicDispatcherPeer::SetPacketWriterFactory(&dispatcher_,
                                                new TestWriterFactory());
     QuicDispatcherPeer::UseWriter(&dispatcher_, writer_);
 
     IPEndPoint client_address(net::test::Loopback4(), 1);
 
     EXPECT_CALL(dispatcher_, CreateQuicSession(_, _, client_address))
-        .WillOnce(testing::Return(CreateSession(
-                      &dispatcher_, 1, client_address, &session1_)));
+        .WillOnce(testing::Return(CreateSession(&dispatcher_, config_, 1,
+                                                client_address, &session1_)));
     ProcessPacket(client_address, 1, true, "foo");
 
     EXPECT_CALL(dispatcher_, CreateQuicSession(_, _, client_address))
-        .WillOnce(testing::Return(CreateSession(
-                      &dispatcher_, 2, client_address, &session2_)));
+        .WillOnce(testing::Return(CreateSession(&dispatcher_, config_, 2,
+                                                client_address, &session2_)));
     ProcessPacket(client_address, 2, true, "bar");
 
     blocked_list_ = QuicDispatcherPeer::GetWriteBlockedList(&dispatcher_);
   }
 
   void TearDown() override {
     EXPECT_CALL(*connection1(), SendConnectionClose(QUIC_PEER_GOING_AWAY));
     EXPECT_CALL(*connection2(), SendConnectionClose(QUIC_PEER_GOING_AWAY));
     dispatcher_.Shutdown();
   }
@@ skipping 139 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 tools
 }  // namespace net