Landing Recent QUIC changes until 9:41 AM, Oct 10, 2016 UTC-7

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 <memory>
 #include <ostream>
 #include <string>
 
@@ skipping 30 matching lines @@
 using net::test::CryptoTestUtils;
 using net::test::MockQuicConnection;
 using net::test::MockQuicConnectionHelper;
 using std::ostream;
 using std::string;
 using std::vector;
 using testing::CreateFunctor;
 using testing::DoAll;
 using testing::InSequence;
 using testing::Invoke;
+using testing::Return;
 using testing::WithoutArgs;
 using testing::_;
 
 static const size_t kDefaultMaxConnectionsInStore = 100;
 static const size_t kMaxConnectionsWithoutCHLO =
     kDefaultMaxConnectionsInStore / 2;
 static const int16_t kMaxNumSessionsToCreate = 16;
 
 namespace net {
 namespace test {
@@ skipping 64 matching lines @@
             std::unique_ptr<QuicCryptoServerStream::Helper>(
                 new QuicSimpleCryptoServerStreamHelper(
                     QuicRandom::GetInstance())),
             std::unique_ptr<QuicEpollAlarmFactory>(
                 new QuicEpollAlarmFactory(eps))) {}
 
   MOCK_METHOD2(CreateQuicSession,
                QuicServerSessionBase*(QuicConnectionId connection_id,
                                       const IPEndPoint& client_address));
 
-  MOCK_METHOD1(OnNewConnectionAdded, void(QuicConnectionId connection_id));
+  MOCK_METHOD1(ShouldCreateOrBufferPacketForConnection,
+               bool(QuicConnectionId connection_id));
 
   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 MockQuicConnection {
@@ skipping 34 matching lines @@
         time_wait_list_manager_(nullptr),
         session1_(nullptr),
         session2_(nullptr),
         store_(nullptr) {}
 
   void SetUp() override {
     dispatcher_->InitializeWithWriter(new QuicDefaultPacketWriter(1));
     // Set the counter to some value to start with.
     QuicDispatcherPeer::set_new_sessions_allowed_per_event_loop(
         dispatcher_.get(), kMaxNumSessionsToCreate);
+    ON_CALL(*dispatcher_, ShouldCreateOrBufferPacketForConnection(_))
+        .WillByDefault(Return(true));
   }
 
   ~QuicDispatcherTest() override {}
 
   MockQuicConnection* connection1() {
     return reinterpret_cast<MockQuicConnection*>(session1_->connection());
   }
 
   MockQuicConnection* connection2() {
     return reinterpret_cast<MockQuicConnection*>(session2_->connection());
@@ skipping 928 matching lines @@
     BufferedPacketStoreTests,
     BufferedPacketStoreTest,
     ::testing::ValuesIn(GetBufferedPacketStoreTestParams()));
 
 TEST_P(BufferedPacketStoreTest, ProcessNonChloPacketsUptoLimitAndProcessChlo) {
   InSequence s;
   IPEndPoint client_address(Loopback4(), 1);
   server_address_ = IPEndPoint(Any4(), 5);
   QuicConnectionId conn_id = 1;
   // A bunch of non-CHLO should be buffered upon arrival, and the first one
-  // should trigger OnNewConnectionAdded().
-  EXPECT_CALL(*dispatcher_, OnNewConnectionAdded(conn_id)).Times(1);
+  // should trigger ShouldCreateOrBufferPacketForConnection().
+  EXPECT_CALL(*dispatcher_, ShouldCreateOrBufferPacketForConnection(conn_id))
+      .Times(1);
   for (size_t i = 1; i <= kDefaultMaxUndecryptablePackets + 1; ++i) {
     ProcessPacket(client_address, conn_id, true, false,
                   "data packet " + IntToString(i + 1),
                   PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER,
                   kDefaultPathId,
                   /*packet_number=*/i + 1);
   }
   EXPECT_EQ(0u, dispatcher_->session_map().size())
       << "No session should be created before CHLO arrives.";
 
@@ skipping 23 matching lines @@
   InSequence s;
   server_address_ = IPEndPoint(Any4(), 5);
   // A bunch of non-CHLO should be buffered upon arrival.
   size_t kNumConnections = (FLAGS_quic_limit_num_new_sessions_per_epoll_loop
                                 ? kMaxConnectionsWithoutCHLO
                                 : kDefaultMaxConnectionsInStore) +
                            1;
   for (size_t i = 1; i <= kNumConnections; ++i) {
     IPEndPoint client_address(Loopback4(), i);
     QuicConnectionId conn_id = i;
-    if (i <= kNumConnections - 1) {
-      // As they are on different connection, they should trigger
-      // OnNewConnectionAdded(). The last packet should be dropped.
-      EXPECT_CALL(*dispatcher_, OnNewConnectionAdded(conn_id));
+    if (FLAGS_quic_create_session_after_insertion) {
+      EXPECT_CALL(*dispatcher_,
+                  ShouldCreateOrBufferPacketForConnection(conn_id));
+    } else {
+      if (i <= kNumConnections - 1) {
+        // As they are on different connection, they should trigger
+        // ShouldCreateOrBufferPacketForConnection(). The last packet should be
+        // dropped.
+        EXPECT_CALL(*dispatcher_,
+                    ShouldCreateOrBufferPacketForConnection(conn_id));
+      }
     }
     ProcessPacket(client_address, conn_id, true, false,
                   "data packet on connection " + IntToString(i),
                   PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER,
                   kDefaultPathId,
                   /*packet_number=*/2);
   }
 
   // Pop out the packet on last connection as it shouldn't be enqueued in store
   // as well.
   data_connection_map_[kNumConnections].pop_front();
 
   // Reset session creation counter to ensure processing CHLO can always
   // create session.
   QuicDispatcherPeer::set_new_sessions_allowed_per_event_loop(dispatcher_.get(),
                                                               kNumConnections);
   // Process CHLOs to create session for these connections.
   for (size_t i = 1; i <= kNumConnections; ++i) {
     IPEndPoint client_address(Loopback4(), i);
     QuicConnectionId conn_id = i;
+    if (FLAGS_quic_create_session_after_insertion &&
+        conn_id == kNumConnections) {
+      EXPECT_CALL(*dispatcher_,
+                  ShouldCreateOrBufferPacketForConnection(conn_id));
+    }
     EXPECT_CALL(*dispatcher_, CreateQuicSession(conn_id, client_address))
         .WillOnce(testing::Return(CreateSession(
             dispatcher_.get(), config_, conn_id, client_address, &mock_helper_,
             &mock_alarm_factory_, &crypto_config_,
             QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
-    if (conn_id == kNumConnections) {
-      // The last CHLO should trigger OnNewConnectionAdded() since it's the
-      // first packet arrives on that connection.
-      EXPECT_CALL(*dispatcher_, OnNewConnectionAdded(conn_id));
+    if (!FLAGS_quic_create_session_after_insertion &&
+        conn_id == kNumConnections) {
+      // The last CHLO should trigger ShouldCreateOrBufferPacketForConnection()
+      // since it's the first packet arrives on that connection.
+      EXPECT_CALL(*dispatcher_,
+                  ShouldCreateOrBufferPacketForConnection(conn_id));
     }
     // First |kNumConnections| - 1 connections should have buffered
     // a packet in store. The rest should have been dropped.
     size_t upper_limit = FLAGS_quic_limit_num_new_sessions_per_epoll_loop
                              ? kMaxConnectionsWithoutCHLO
                              : kDefaultMaxConnectionsInStore;
     size_t num_packet_to_process = i <= upper_limit ? 2u : 1u;
     EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
                 ProcessUdpPacket(_, client_address, _))
         .Times(num_packet_to_process)
         .WillRepeatedly(testing::WithArg<2>(
             Invoke(CreateFunctor(&QuicDispatcherTest::ValidatePacket,
                                  base::Unretained(this), conn_id))));
     ProcessPacket(client_address, conn_id, true, false, SerializeFullCHLO());
   }
 }
 
 // Tests that store delivers empty packet list if CHLO arrives firstly.
 TEST_P(BufferedPacketStoreTest, DeliverEmptyPackets) {
   QuicConnectionId conn_id = 1;
   IPEndPoint client_address(Loopback4(), 1);
-  EXPECT_CALL(*dispatcher_, OnNewConnectionAdded(conn_id));
+  EXPECT_CALL(*dispatcher_, ShouldCreateOrBufferPacketForConnection(conn_id));
   EXPECT_CALL(*dispatcher_, CreateQuicSession(conn_id, client_address))
       .WillOnce(testing::Return(CreateSession(
           dispatcher_.get(), config_, conn_id, client_address, &mock_helper_,
           &mock_alarm_factory_, &crypto_config_,
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
   ProcessPacket(client_address, conn_id, true, false, SerializeFullCHLO());
 }
 
 // Tests that a retransmitted CHLO arrives after a connection for the
 // CHLO has been created.
@@ skipping 60 matching lines @@
   // Process more than (|kMaxNumSessionsToCreate| +
   // |kDefaultMaxConnectionsInStore|) CHLOs,
   // the first |kMaxNumSessionsToCreate| should create connections immediately,
   // the next |kDefaultMaxConnectionsInStore| should be buffered,
   // the rest should be dropped.
   QuicBufferedPacketStore* store =
       QuicDispatcherPeer::GetBufferedPackets(dispatcher_.get());
   const size_t kNumCHLOs =
       kMaxNumSessionsToCreate + kDefaultMaxConnectionsInStore + 1;
   for (size_t conn_id = 1; conn_id <= kNumCHLOs; ++conn_id) {
-    if (conn_id < kNumCHLOs) {
+    if (FLAGS_quic_create_session_after_insertion) {
+      EXPECT_CALL(*dispatcher_,
+                  ShouldCreateOrBufferPacketForConnection(conn_id));
+    }
+    if (!FLAGS_quic_create_session_after_insertion && conn_id < kNumCHLOs) {
       // Except the last connection, all connections for previous CHLOs should
       // be regarded as newly added.
-      EXPECT_CALL(*dispatcher_, OnNewConnectionAdded(conn_id));
+      EXPECT_CALL(*dispatcher_,
+                  ShouldCreateOrBufferPacketForConnection(conn_id));
     }
     if (conn_id <= kMaxNumSessionsToCreate) {
       EXPECT_CALL(*dispatcher_, CreateQuicSession(conn_id, client_addr_))
           .WillOnce(testing::Return(CreateSession(
               dispatcher_.get(), config_, conn_id, client_addr_, &mock_helper_,
               &mock_alarm_factory_, &crypto_config_,
               QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
       EXPECT_CALL(
           *reinterpret_cast<MockQuicConnection*>(session1_->connection()),
           ProcessUdpPacket(_, _, _))
@@ skipping 171 matching lines @@
 
   // CHLO on connection 1 should still be buffered.
   ProcessPacket(client_addr_, /*connection_id=*/1, true, false,
                 SerializeFullCHLO());
   EXPECT_TRUE(store->HasChloForConnection(/*connection_id=*/1));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net