short circuit QUIC packets to packet buffer if there is already a CHLO on same connection buffered …

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 1356 matching lines @@
   while (store->HasChlosBuffered()) {
     dispatcher_->ProcessBufferedChlos(kMaxNumSessionsToCreate);
   }
 
   EXPECT_EQ(static_cast<size_t>(kMaxNumSessionsToCreate) +
                 kDefaultMaxConnectionsInStore,
             session1_->connection_id());
 }
 
 // Duplicated CHLO shouldn't be buffered.
-TEST_P(BufferedPacketStoreTest, DropDuplicatedCHLO) {
+TEST_P(BufferedPacketStoreTest, BufferDuplicatedCHLO) {
   FLAGS_quic_limit_num_new_sessions_per_epoll_loop = true;
   for (QuicConnectionId conn_id = 1; conn_id <= kMaxNumSessionsToCreate + 1;
        ++conn_id) {
     // Last CHLO will be buffered. Others will create connection right away.
     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(_, _, _))
           .WillOnce(testing::WithArg<2>(
               Invoke(CreateFunctor(&QuicDispatcherTest::ValidatePacket,
                                    base::Unretained(this), conn_id))));
     }
     ProcessPacket(client_addr_, conn_id, true, false, SerializeFullCHLO());
   }
   // Retransmit CHLO on last connection should be dropped.
   QuicConnectionId last_connection = kMaxNumSessionsToCreate + 1;
   ProcessPacket(client_addr_, last_connection, true, false,
                 SerializeFullCHLO());
 
+  size_t packets_buffered = 2;
+  if (!FLAGS_quic_buffer_packets_after_chlo) {
+    // The packet sent above is dropped when flag is off.
+    packets_buffered = 1;
+  }
+
   // Reset counter and process buffered CHLO.
   EXPECT_CALL(*dispatcher_, CreateQuicSession(last_connection, client_addr_))
       .WillOnce(testing::Return(CreateSession(
           dispatcher_.get(), config_, last_connection, client_addr_,
           &mock_helper_, &mock_alarm_factory_, &crypto_config_,
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
   // Only one packet(CHLO) should be process.
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
-      .WillOnce(testing::WithArg<2>(
+      .Times(packets_buffered)
+      .WillRepeatedly(testing::WithArg<2>(
           Invoke(CreateFunctor(&QuicDispatcherTest::ValidatePacket,
                                base::Unretained(this), last_connection))));
   dispatcher_->ProcessBufferedChlos(kMaxNumSessionsToCreate);
 }
 
 TEST_P(BufferedPacketStoreTest, BufferNonChloPacketsUptoLimitWithChloBuffered) {
   FLAGS_quic_limit_num_new_sessions_per_epoll_loop = true;
   QuicConnectionId last_connection_id = kMaxNumSessionsToCreate + 1;
   for (QuicConnectionId conn_id = 1; conn_id <= last_connection_id; ++conn_id) {
     // Last CHLO will be buffered. Others will create connection right away.
@@ skipping 74 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