Remove multipath_enabled from quic_config and quic_connection. No functional change expected.

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 190 matching lines @@
   MockQuicConnection* connection2() {
     return reinterpret_cast<MockQuicConnection*>(session2_->connection());
   }
 
   // Process a packet with an 8 byte connection id,
   // 6 byte packet number, default path id, and packet number 1,
   // using the first supported version.
   void ProcessPacket(QuicSocketAddress client_address,
                      QuicConnectionId connection_id,
                      bool has_version_flag,
-                     bool has_multipath_flag,
                      const string& data) {
-    ProcessPacket(client_address, connection_id, has_version_flag,
-                  has_multipath_flag, data, PACKET_8BYTE_CONNECTION_ID,
-                  PACKET_6BYTE_PACKET_NUMBER);
+    ProcessPacket(client_address, connection_id, has_version_flag, data,
+                  PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER);
   }
 
   // Process a packet with a default path id, and packet number 1,
   // using the first supported version.
   void ProcessPacket(QuicSocketAddress client_address,
                      QuicConnectionId connection_id,
                      bool has_version_flag,
-                     bool has_multipath_flag,
                      const string& data,
                      QuicConnectionIdLength connection_id_length,
                      QuicPacketNumberLength packet_number_length) {
-    ProcessPacket(client_address, connection_id, has_version_flag,
-                  has_multipath_flag, data, connection_id_length,
-                  packet_number_length, 1);
+    ProcessPacket(client_address, connection_id, has_version_flag, data,
+                  connection_id_length, packet_number_length, 1);
   }
 
   // Process a packet using the first supported version.
   void ProcessPacket(QuicSocketAddress client_address,
                      QuicConnectionId connection_id,
                      bool has_version_flag,
-                     bool has_multipath_flag,
                      const string& data,
                      QuicConnectionIdLength connection_id_length,
                      QuicPacketNumberLength packet_number_length,
                      QuicPacketNumber packet_number) {
     ProcessPacket(client_address, connection_id, has_version_flag,
                   CurrentSupportedVersions().front(), data,
                   connection_id_length, packet_number_length, packet_number);
   }
 
   // Processes a packet.
   void ProcessPacket(QuicSocketAddress client_address,
                      QuicConnectionId connection_id,
                      bool has_version_flag,
                      QuicVersion version,
                      const string& data,
                      QuicConnectionIdLength connection_id_length,
                      QuicPacketNumberLength packet_number_length,
                      QuicPacketNumber packet_number) {
     QuicVersionVector versions(SupportedVersions(version));
     std::unique_ptr<QuicEncryptedPacket> packet(ConstructEncryptedPacket(
-        connection_id, has_version_flag, false, false, packet_number, data,
+        connection_id, has_version_flag, false, packet_number, data,
         connection_id_length, packet_number_length, &versions));
     std::unique_ptr<QuicReceivedPacket> received_packet(
         ConstructReceivedPacket(*packet, helper_.GetClock()->Now()));
 
     if (ChloExtractor::Extract(*packet, versions, nullptr)) {
       // Add CHLO packet to the beginning to be verified first, because it is
       // also processed first by new session.
       data_connection_map_[connection_id].push_front(
           string(packet->data(), packet->length()));
     } else {
       // For non-CHLO, always append to last.
       data_connection_map_[connection_id].push_back(
           string(packet->data(), packet->length()));
     }
     dispatcher_->ProcessPacket(server_address_, client_address,
                                *received_packet);
   }
 
   void ValidatePacket(QuicConnectionId conn_id,
                       const QuicEncryptedPacket& packet) {
     EXPECT_EQ(data_connection_map_[conn_id].front().length(),
               packet.AsStringPiece().length());
-    EXPECT_EQ(data_connection_map_[conn_id].front(), packet.AsStringPiece());
+    EXPECT_EQ(data_connection_map_[conn_id].front(),
+              packet.AsStringPiece().as_string());
     data_connection_map_[conn_id].pop_front();
   }
 
   QuicServerSessionBase* CreateSession(
       QuicDispatcher* dispatcher,
       const QuicConfig& config,
       QuicConnectionId connection_id,
       const QuicSocketAddress& client_address,
       MockQuicConnectionHelper* helper,
       MockAlarmFactory* alarm_factory,
@@ skipping 50 matching lines @@
 
   EXPECT_CALL(*dispatcher_, CreateQuicSession(1, client_address))
       .WillOnce(testing::Return(CreateSession(
           dispatcher_.get(), config_, 1, client_address, &mock_helper_,
           &mock_alarm_factory_, &crypto_config_,
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .WillOnce(testing::WithArgs<2>(Invoke(CreateFunctor(
           &QuicDispatcherTest::ValidatePacket, base::Unretained(this), 1))));
-  ProcessPacket(client_address, 1, true, false, SerializeCHLO());
+  ProcessPacket(client_address, 1, true, SerializeCHLO());
   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_.get(), config_, 2, client_address, &mock_helper_,
           &mock_alarm_factory_, &crypto_config_,
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session2_)));
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session2_->connection()),
               ProcessUdpPacket(_, _, _))
       .WillOnce(testing::WithArgs<2>(Invoke(CreateFunctor(
           &QuicDispatcherTest::ValidatePacket, base::Unretained(this), 2))));
-  ProcessPacket(client_address, 2, true, false, SerializeCHLO());
+  ProcessPacket(client_address, 2, true, SerializeCHLO());
 
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .Times(1)
       .WillOnce(testing::WithArgs<2>(Invoke(CreateFunctor(
           &QuicDispatcherTest::ValidatePacket, base::Unretained(this), 1))));
-  ProcessPacket(client_address, 1, false, false, "data");
+  ProcessPacket(client_address, 1, false, "data");
 }
 
 TEST_F(QuicDispatcherTest, StatelessVersionNegotiation) {
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
   server_address_ = QuicSocketAddress(QuicIpAddress::Any4(), 5);
 
   EXPECT_CALL(*dispatcher_, CreateQuicSession(1, client_address)).Times(0);
   QuicVersion version = static_cast<QuicVersion>(QuicVersionMin() - 1);
   ProcessPacket(client_address, 1, true, version, SerializeCHLO(),
                 PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER, 1);
 }
 
 TEST_F(QuicDispatcherTest, Shutdown) {
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
 
   EXPECT_CALL(*dispatcher_, CreateQuicSession(_, client_address))
       .WillOnce(testing::Return(CreateSession(
           dispatcher_.get(), config_, 1, client_address, &mock_helper_,
           &mock_alarm_factory_, &crypto_config_,
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .WillOnce(testing::WithArgs<2>(Invoke(CreateFunctor(
           &QuicDispatcherTest::ValidatePacket, base::Unretained(this), 1))));
 
-  ProcessPacket(client_address, 1, true, false, SerializeCHLO());
+  ProcessPacket(client_address, 1, true, SerializeCHLO());
 
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               CloseConnection(QUIC_PEER_GOING_AWAY, _, _));
 
   dispatcher_->Shutdown();
 }
 
 TEST_F(QuicDispatcherTest, TimeWaitListManager) {
   CreateTimeWaitListManager();
 
   // Create a new session.
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
   QuicConnectionId connection_id = 1;
   EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address))
       .WillOnce(testing::Return(CreateSession(
           dispatcher_.get(), config_, connection_id, client_address,
           &mock_helper_, &mock_alarm_factory_, &crypto_config_,
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .WillOnce(testing::WithArgs<2>(Invoke(CreateFunctor(
           &QuicDispatcherTest::ValidatePacket, base::Unretained(this), 1))));
 
-  ProcessPacket(client_address, connection_id, true, false, SerializeCHLO());
+  ProcessPacket(client_address, connection_id, true, SerializeCHLO());
 
   // 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;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       QuicFramer::BuildPublicResetPacket(packet));
@@ skipping 13 matching lines @@
   dispatcher_->ProcessPacket(QuicSocketAddress(), client_address, *received);
   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);
-  ProcessPacket(client_address, connection_id, true, false, "data");
+  ProcessPacket(client_address, connection_id, true, "data");
 }
 
 TEST_F(QuicDispatcherTest, NoVersionPacketToTimeWaitListManager) {
   CreateTimeWaitListManager();
 
   QuicSocketAddress client_address(QuicIpAddress::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);
-  ProcessPacket(client_address, connection_id, false, false, SerializeCHLO());
+  ProcessPacket(client_address, connection_id, false, SerializeCHLO());
 }
 
 TEST_F(QuicDispatcherTest, ProcessPacketWithZeroPort) {
   CreateTimeWaitListManager();
 
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 0);
   server_address_ = QuicSocketAddress(QuicIpAddress::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);
-  ProcessPacket(client_address, 1, true, false, SerializeCHLO());
+  ProcessPacket(client_address, 1, true, SerializeCHLO());
 }
 
 TEST_F(QuicDispatcherTest, OKSeqNoPacketProcessed) {
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
   QuicConnectionId connection_id = 1;
   server_address_ = QuicSocketAddress(QuicIpAddress::Any4(), 5);
 
   EXPECT_CALL(*dispatcher_, CreateQuicSession(1, client_address))
       .WillOnce(testing::Return(CreateSession(
           dispatcher_.get(), config_, 1, client_address, &mock_helper_,
           &mock_alarm_factory_, &crypto_config_,
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .WillOnce(testing::WithArgs<2>(Invoke(CreateFunctor(
           &QuicDispatcherTest::ValidatePacket, base::Unretained(this), 1))));
   // A packet whose packet number is the largest that is allowed to start a
   // connection.
-  ProcessPacket(client_address, connection_id, true, false, SerializeCHLO(),
+  ProcessPacket(client_address, connection_id, true, SerializeCHLO(),
                 PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER,
                 QuicDispatcher::kMaxReasonableInitialPacketNumber);
   EXPECT_EQ(client_address, dispatcher_->current_client_address());
   EXPECT_EQ(server_address_, dispatcher_->current_server_address());
 }
 
 TEST_F(QuicDispatcherTest, TooBigSeqNoPacketToTimeWaitListManager) {
   CreateTimeWaitListManager();
 
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
   QuicConnectionId connection_id = 1;
   // Dispatcher forwards this packet 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);
   // A packet whose packet number is one to large to be allowed to start a
   // connection.
-  ProcessPacket(client_address, connection_id, true, false, SerializeCHLO(),
+  ProcessPacket(client_address, connection_id, true, SerializeCHLO(),
                 PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER,
                 QuicDispatcher::kMaxReasonableInitialPacketNumber + 1);
 }
 
 TEST_F(QuicDispatcherTest, SupportedVersionsChangeInFlight) {
   static_assert(arraysize(kSupportedQuicVersions) == 5u,
                 "Supported versions out of sync");
   FLAGS_quic_reloadable_flag_quic_disable_version_34 = false;
   FLAGS_quic_reloadable_flag_quic_enable_version_36_v3 = true;
   FLAGS_quic_reloadable_flag_quic_enable_version_37 = true;
@@ skipping 218 matching lines @@
   QuicConnectionId connection_id = 1;
   EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address))
       .WillOnce(testing::Return(
           CreateSessionBasedOnTestParams(connection_id, client_address)));
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .WillOnce(testing::WithArgs<2>(
           Invoke(CreateFunctor(&QuicDispatcherTest::ValidatePacket,
                                base::Unretained(this), connection_id))));
   // Process the first packet for the connection.
-  ProcessPacket(client_address, connection_id, true, false, SerializeCHLO());
+  ProcessPacket(client_address, connection_id, true, SerializeCHLO());
   if (ExpectStatelessReject()) {
     // If this is a stateless reject, the crypto stream will close the
     // connection.
     session1_->connection()->CloseConnection(
         QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT, "stateless reject",
         ConnectionCloseBehavior::SILENT_CLOSE);
   }
 
   // Send a second packet and check the results.  If this is a stateless reject,
   // the existing connection_id will go on the time-wait list.
   EXPECT_EQ(ExpectStatelessReject(),
             time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id));
   if (ExpectStatelessReject()) {
     // The second packet will be processed on the time-wait list.
     EXPECT_CALL(*time_wait_list_manager_,
                 ProcessPacket(_, _, connection_id, _, _))
         .Times(1);
   } else {
     // The second packet will trigger a packet-validation
     EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
                 ProcessUdpPacket(_, _, _))
         .Times(1)
         .WillOnce(testing::WithArgs<2>(
             Invoke(CreateFunctor(&QuicDispatcherTest::ValidatePacket,
                                  base::Unretained(this), connection_id))));
   }
-  ProcessPacket(client_address, connection_id, true, false, "data");
+  ProcessPacket(client_address, connection_id, true, "data");
 }
 
 TEST_P(QuicDispatcherStatelessRejectTest, CheapRejects) {
   FLAGS_quic_reloadable_flag_quic_use_cheap_stateless_rejects = true;
   CreateTimeWaitListManager();
 
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
   QuicConnectionId connection_id = 1;
   if (GetParam().enable_stateless_rejects_via_flag) {
     EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address))
@@ skipping 12 matching lines @@
   QUIC_LOG(INFO) << "Params: " << GetParam();
   // Process the first packet for the connection.
   CryptoHandshakeMessage client_hello =
       crypto_test_utils::CreateCHLO({{"AEAD", "AESG"},
                                      {"KEXS", "C255"},
                                      {"COPT", "SREJ"},
                                      {"NONC", "1234567890123456789012"},
                                      {"VER\0", "Q025"}},
                                     kClientHelloMinimumSize);
 
-  ProcessPacket(client_address, connection_id, true, false,
+  ProcessPacket(client_address, connection_id, true,
                 client_hello.GetSerialized().AsStringPiece().as_string());
 
   if (GetParam().enable_stateless_rejects_via_flag) {
     EXPECT_EQ(true,
               time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id));
   }
 }
 
 TEST_P(QuicDispatcherStatelessRejectTest, BufferNonChlo) {
   FLAGS_quic_reloadable_flag_quic_use_cheap_stateless_rejects = true;
   CreateTimeWaitListManager();
 
   const QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
   const QuicConnectionId connection_id = 1;
 
-    ProcessPacket(client_address, connection_id, true, false,
-                  "NOT DATA FOR A CHLO");
+  ProcessPacket(client_address, connection_id, true, "NOT DATA FOR A CHLO");
 
   // Process the first packet for the connection.
     CryptoHandshakeMessage client_hello =
         crypto_test_utils::CreateCHLO({{"AEAD", "AESG"},
                                        {"KEXS", "C255"},
                                        {"NONC", "1234567890123456789012"},
                                        {"VER\0", "Q025"}},
                                       kClientHelloMinimumSize);
 
     // If stateless rejects are enabled then a connection will be created now
     // and the buffered packet will be processed
     EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address))
         .WillOnce(testing::Return(
             CreateSessionBasedOnTestParams(connection_id, client_address)));
     EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
                 ProcessUdpPacket(_, client_address, _))
         .WillOnce(testing::WithArg<2>(
             Invoke(CreateFunctor(&QuicDispatcherTest::ValidatePacket,
                                  base::Unretained(this), connection_id))));
     // Expect both packets to be passed to ProcessUdpPacket(). And one of them
     // is already expected in CreateSessionBasedOnTestParams().
     EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
                 ProcessUdpPacket(_, client_address, _))
         .WillOnce(testing::WithArg<2>(
             Invoke(CreateFunctor(&QuicDispatcherTest::ValidatePacket,
                                  base::Unretained(this), connection_id))))
         .RetiresOnSaturation();
-    ProcessPacket(client_address, connection_id, true, false,
+    ProcessPacket(client_address, connection_id, true,
                   client_hello.GetSerialized().AsStringPiece().as_string());
     EXPECT_FALSE(
         time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id));
 }
 
 // Verify the stopgap test: Packets with truncated connection IDs should be
 // dropped.
 class QuicDispatcherTestStrayPacketConnectionId : public QuicDispatcherTest {};
 
 // Packets with truncated connection IDs should be dropped.
 TEST_F(QuicDispatcherTestStrayPacketConnectionId,
        StrayPacketTruncatedConnectionId) {
   CreateTimeWaitListManager();
 
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
   QuicConnectionId connection_id = 1;
   // Dispatcher drops this packet.
   EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _)).Times(0);
   EXPECT_CALL(*time_wait_list_manager_,
               ProcessPacket(_, _, connection_id, _, _))
       .Times(0);
   EXPECT_CALL(*time_wait_list_manager_, AddConnectionIdToTimeWait(_, _, _, _))
       .Times(0);
-  ProcessPacket(client_address, connection_id, true, false, "data",
+  ProcessPacket(client_address, connection_id, true, "data",
                 PACKET_0BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER);
 }
 
 class BlockingWriter : public QuicPacketWriterWrapper {
  public:
   BlockingWriter() : write_blocked_(false) {}
 
   bool IsWriteBlocked() const override { return write_blocked_; }
   void SetWritable() override { write_blocked_ = false; }
 
@@ skipping 23 matching lines @@
 
     EXPECT_CALL(*dispatcher_, CreateQuicSession(_, client_address))
         .WillOnce(testing::Return(CreateSession(
             dispatcher_.get(), config_, 1, client_address, &helper_,
             &alarm_factory_, &crypto_config_,
             QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
     EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
                 ProcessUdpPacket(_, _, _))
         .WillOnce(testing::WithArgs<2>(Invoke(CreateFunctor(
             &QuicDispatcherTest::ValidatePacket, base::Unretained(this), 1))));
-    ProcessPacket(client_address, 1, true, false, SerializeCHLO());
+    ProcessPacket(client_address, 1, true, SerializeCHLO());
 
     EXPECT_CALL(*dispatcher_, CreateQuicSession(_, client_address))
         .WillOnce(testing::Return(CreateSession(
             dispatcher_.get(), config_, 2, client_address, &helper_,
             &alarm_factory_, &crypto_config_,
             QuicDispatcherPeer::GetCache(dispatcher_.get()), &session2_)));
     EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session2_->connection()),
                 ProcessUdpPacket(_, _, _))
         .WillOnce(testing::WithArgs<2>(Invoke(CreateFunctor(
             &QuicDispatcherTest::ValidatePacket, base::Unretained(this), 2))));
-    ProcessPacket(client_address, 2, true, false, SerializeCHLO());
+    ProcessPacket(client_address, 2, true, SerializeCHLO());
 
     blocked_list_ = QuicDispatcherPeer::GetWriteBlockedList(dispatcher_.get());
   }
 
   void TearDown() override {
     EXPECT_CALL(*connection1(), CloseConnection(QUIC_PEER_GOING_AWAY, _, _));
     EXPECT_CALL(*connection2(), CloseConnection(QUIC_PEER_GOING_AWAY, _, _));
     dispatcher_->Shutdown();
   }
 
@@ skipping 228 matching lines @@
 TEST_P(BufferedPacketStoreTest, ProcessNonChloPacketsUptoLimitAndProcessChlo) {
   InSequence s;
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
   server_address_ = QuicSocketAddress(QuicIpAddress::Any4(), 5);
   QuicConnectionId conn_id = 1;
   // A bunch of non-CHLO should be buffered upon arrival, and the first one
   // 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,
+    ProcessPacket(client_address, conn_id, true,
                   QuicStrCat("data packet ", i + 1), PACKET_8BYTE_CONNECTION_ID,
                   PACKET_6BYTE_PACKET_NUMBER, /*packet_number=*/i + 1);
   }
   EXPECT_EQ(0u, dispatcher_->session_map().size())
       << "No session should be created before CHLO arrives.";
 
   // Pop out the last packet as it is also be dropped by the store.
   data_connection_map_[conn_id].pop_back();
   // When CHLO arrives, a new session should be created, and all packets
   // buffered should be delivered to the session.
   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_)));
 
   // Only |kDefaultMaxUndecryptablePackets| packets were buffered, and they
   // should be delivered in arrival order.
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .Times(kDefaultMaxUndecryptablePackets + 1)  // + 1 for CHLO.
       .WillRepeatedly(testing::WithArg<2>(
           Invoke(CreateFunctor(&QuicDispatcherTest::ValidatePacket,
                                base::Unretained(this), conn_id))));
-  ProcessPacket(client_address, conn_id, true, false, SerializeFullCHLO());
+  ProcessPacket(client_address, conn_id, true, SerializeFullCHLO());
 }
 
 TEST_P(BufferedPacketStoreTest,
        ProcessNonChloPacketsForDifferentConnectionsUptoLimit) {
   InSequence s;
   server_address_ = QuicSocketAddress(QuicIpAddress::Any4(), 5);
   // A bunch of non-CHLO should be buffered upon arrival.
   size_t kNumConnections =
       (FLAGS_quic_reloadable_flag_quic_limit_num_new_sessions_per_epoll_loop
            ? kMaxConnectionsWithoutCHLO
            : kDefaultMaxConnectionsInStore) +
       1;
   for (size_t i = 1; i <= kNumConnections; ++i) {
     QuicSocketAddress client_address(QuicIpAddress::Loopback4(), i);
     QuicConnectionId conn_id = i;
     if (FLAGS_quic_reloadable_flag_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,
+    ProcessPacket(client_address, conn_id, true,
                   QuicStrCat("data packet on connection ", i),
                   PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER,
                   /*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
@@ skipping 30 matching lines @@
         FLAGS_quic_reloadable_flag_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());
+    ProcessPacket(client_address, conn_id, true, SerializeFullCHLO());
   }
 }
 
 // Tests that store delivers empty packet list if CHLO arrives firstly.
 TEST_P(BufferedPacketStoreTest, DeliverEmptyPackets) {
   QuicConnectionId conn_id = 1;
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
   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());
+  ProcessPacket(client_address, conn_id, true, SerializeFullCHLO());
 }
 
 // Tests that a retransmitted CHLO arrives after a connection for the
 // CHLO has been created.
 TEST_P(BufferedPacketStoreTest, ReceiveRetransmittedCHLO) {
   InSequence s;
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
   server_address_ = QuicSocketAddress(QuicIpAddress::Any4(), 5);
   QuicConnectionId conn_id = 1;
-  ProcessPacket(client_address, conn_id, true, false,
-                QuicStrCat("data packet ", 2), PACKET_8BYTE_CONNECTION_ID,
-                PACKET_6BYTE_PACKET_NUMBER, /*packet_number=*/2);
+  ProcessPacket(client_address, conn_id, true, QuicStrCat("data packet ", 2),
+                PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER,
+                /*packet_number=*/2);
 
   // When CHLO arrives, a new session should be created, and all packets
   // buffered should be delivered to the session.
   EXPECT_CALL(*dispatcher_, CreateQuicSession(conn_id, client_address))
       .Times(1)  // Only triggered by 1st CHLO.
       .WillOnce(testing::Return(CreateSession(
           dispatcher_.get(), config_, conn_id, client_address, &mock_helper_,
           &mock_alarm_factory_, &crypto_config_,
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .Times(3)  // Triggered by 1 data packet and 2 CHLOs.
       .WillRepeatedly(testing::WithArg<2>(
           Invoke(CreateFunctor(&QuicDispatcherTest::ValidatePacket,
                                base::Unretained(this), conn_id))));
-  ProcessPacket(client_address, conn_id, true, false, SerializeFullCHLO());
+  ProcessPacket(client_address, conn_id, true, SerializeFullCHLO());
 
-  ProcessPacket(client_address, conn_id, true, false, SerializeFullCHLO());
+  ProcessPacket(client_address, conn_id, true, SerializeFullCHLO());
 }
 
 // Tests that expiration of a connection add connection id to time wait list.
 TEST_P(BufferedPacketStoreTest, ReceiveCHLOAfterExpiration) {
   InSequence s;
   CreateTimeWaitListManager();
   QuicBufferedPacketStore* store =
       QuicDispatcherPeer::GetBufferedPackets(dispatcher_.get());
   QuicBufferedPacketStorePeer::set_clock(store, mock_helper_.GetClock());
 
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
   server_address_ = QuicSocketAddress(QuicIpAddress::Any4(), 5);
   QuicConnectionId conn_id = 1;
-  ProcessPacket(client_address, conn_id, true, false,
-                QuicStrCat("data packet ", 2), PACKET_8BYTE_CONNECTION_ID,
-                PACKET_6BYTE_PACKET_NUMBER, /*packet_number=*/2);
+  ProcessPacket(client_address, conn_id, true, QuicStrCat("data packet ", 2),
+                PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER,
+                /*packet_number=*/2);
 
   mock_helper_.AdvanceTime(
       QuicTime::Delta::FromSeconds(kInitialIdleTimeoutSecs));
   QuicAlarm* alarm = QuicBufferedPacketStorePeer::expiration_alarm(store);
   // Cancel alarm as if it had been fired.
   alarm->Cancel();
   store->OnExpirationTimeout();
   // New arrived CHLO will be dropped because this connection is in time wait
   // list.
   ASSERT_TRUE(time_wait_list_manager_->IsConnectionIdInTimeWait(conn_id));
   EXPECT_CALL(*time_wait_list_manager_, ProcessPacket(_, _, conn_id, _, _));
-  ProcessPacket(client_address, conn_id, true, false, SerializeFullCHLO());
+  ProcessPacket(client_address, conn_id, true, SerializeFullCHLO());
 }
 
 TEST_P(BufferedPacketStoreTest, ProcessCHLOsUptoLimitAndBufferTheRest) {
   FLAGS_quic_reloadable_flag_quic_limit_num_new_sessions_per_epoll_loop = true;
   // 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 =
@@ skipping 18 matching lines @@
               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());
+    ProcessPacket(client_addr_, conn_id, true, SerializeFullCHLO());
     if (conn_id <= kMaxNumSessionsToCreate + kDefaultMaxConnectionsInStore &&
         conn_id > kMaxNumSessionsToCreate) {
       EXPECT_TRUE(store->HasChloForConnection(conn_id));
     } else {
       // First |kMaxNumSessionsToCreate| CHLOs should be passed to new
       // connections immediately, and the last CHLO should be dropped as the
       // store is full.
       EXPECT_FALSE(store->HasChloForConnection(conn_id));
     }
   }
@@ skipping 38 matching lines @@
               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());
+    ProcessPacket(client_addr_, conn_id, true, SerializeFullCHLO());
   }
   // Retransmit CHLO on last connection should be dropped.
   QuicConnectionId last_connection = kMaxNumSessionsToCreate + 1;
-  ProcessPacket(client_addr_, last_connection, true, false,
-                SerializeFullCHLO());
+  ProcessPacket(client_addr_, last_connection, true, SerializeFullCHLO());
 
   size_t packets_buffered = 2;
   if (!FLAGS_quic_reloadable_flag_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(
@@ skipping 21 matching lines @@
               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());
+    ProcessPacket(client_addr_, conn_id, true, SerializeFullCHLO());
   }
 
   // Process another |kDefaultMaxUndecryptablePackets| + 1 data packets. The
   // last one should be dropped.
   for (QuicPacketNumber packet_number = 2;
        packet_number <= kDefaultMaxUndecryptablePackets + 2; ++packet_number) {
-    ProcessPacket(client_addr_, last_connection_id, true, false, "data packet");
+    ProcessPacket(client_addr_, last_connection_id, true, "data packet");
   }
 
   // Reset counter and process buffered CHLO.
   EXPECT_CALL(*dispatcher_, CreateQuicSession(last_connection_id, client_addr_))
       .WillOnce(testing::Return(CreateSession(
           dispatcher_.get(), config_, last_connection_id, client_addr_,
           &mock_helper_, &mock_alarm_factory_, &crypto_config_,
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
   // Only CHLO and following |kDefaultMaxUndecryptablePackets| data packets
   // should be process.
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .Times(kDefaultMaxUndecryptablePackets + 1)
       .WillRepeatedly(testing::WithArg<2>(
           Invoke(CreateFunctor(&QuicDispatcherTest::ValidatePacket,
                                base::Unretained(this), last_connection_id))));
   dispatcher_->ProcessBufferedChlos(kMaxNumSessionsToCreate);
 }
 
 // Tests that when dispatcher's packet buffer is full, a CHLO on connection
 // which doesn't have buffered CHLO should be buffered.
 TEST_P(BufferedPacketStoreTest, ReceiveCHLOForBufferedConnection) {
   FLAGS_quic_reloadable_flag_quic_limit_num_new_sessions_per_epoll_loop = true;
   QuicBufferedPacketStore* store =
       QuicDispatcherPeer::GetBufferedPackets(dispatcher_.get());
 
   QuicConnectionId conn_id = 1;
-  ProcessPacket(client_addr_, conn_id, true, false, "data packet",
+  ProcessPacket(client_addr_, conn_id, true, "data packet",
                 PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER,
                 /*packet_number=*/1);
   // Fill packet buffer to full with CHLOs on other connections. Need to feed
   // extra CHLOs because the first |kMaxNumSessionsToCreate| are going to create
   // session directly.
   for (conn_id = 2;
        conn_id <= kDefaultMaxConnectionsInStore + kMaxNumSessionsToCreate;
        ++conn_id) {
     if (conn_id <= kMaxNumSessionsToCreate + 1) {
       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());
+    ProcessPacket(client_addr_, conn_id, true, SerializeFullCHLO());
   }
   EXPECT_FALSE(store->HasChloForConnection(/*connection_id=*/1));
 
   // CHLO on connection 1 should still be buffered.
-  ProcessPacket(client_addr_, /*connection_id=*/1, true, false,
-                SerializeFullCHLO());
+  ProcessPacket(client_addr_, /*connection_id=*/1, true, SerializeFullCHLO());
   EXPECT_TRUE(store->HasChloForConnection(/*connection_id=*/1));
 }
 
 // Test which exercises the async GetProof codepaths, especially in the context
 // of stateless rejection.
 class AsyncGetProofTest : public QuicDispatcherTest {
  public:
   AsyncGetProofTest()
       : QuicDispatcherTest(
             std::unique_ptr<FakeProofSource>(new FakeProofSource())),
@@ skipping 102 matching lines @@
     EXPECT_CALL(check, Call(2));
     EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(
                     GetSession(conn_id)->connection()),
                 ProcessUdpPacket(_, _, _))
         .WillOnce(testing::WithArg<2>(
             Invoke(CreateFunctor(&QuicDispatcherTest::ValidatePacket,
                                  base::Unretained(this), conn_id))));
   }
 
   // Send a CHLO that the StatelessRejector will accept.
-  ProcessPacket(client_addr_, conn_id, true, false, SerializeFullCHLO());
+  ProcessPacket(client_addr_, conn_id, true, SerializeFullCHLO());
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
 
   check.Call(1);
   // Complete the ProofSource::GetProof call and verify that a session is
   // created.
   GetFakeProofSource()->InvokePendingCallback(0);
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 0);
 
   check.Call(2);
   // Verify that a data packet gets processed immediately.
-  ProcessPacket(client_addr_, conn_id, true, false, "My name is Data");
+  ProcessPacket(client_addr_, conn_id, true, "My name is Data");
 }
 
 // Test a simple situation of connections which the StatelessRejector will
 // reject.
 TEST_F(AsyncGetProofTest, BasicReject) {
   CreateTimeWaitListManager();
 
   QuicConnectionId conn_id = 1;
 
   testing::MockFunction<void(int check_point)> check;
   {
     InSequence s;
     EXPECT_CALL(check, Call(1));
     EXPECT_CALL(*time_wait_list_manager_,
                 AddConnectionIdToTimeWait(conn_id, _, true, _));
     EXPECT_CALL(*time_wait_list_manager_,
                 ProcessPacket(_, client_addr_, conn_id, _, _));
 
     EXPECT_CALL(check, Call(2));
     EXPECT_CALL(*dispatcher_, CreateQuicSession(conn_id, client_addr_))
         .Times(0);
     EXPECT_CALL(*time_wait_list_manager_,
                 ProcessPacket(_, client_addr_, conn_id, _, _));
   }
 
   // Send a CHLO that the StatelessRejector will reject.
-  ProcessPacket(client_addr_, conn_id, true, false, SerializeCHLO());
+  ProcessPacket(client_addr_, conn_id, true, SerializeCHLO());
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
 
   // Complete the ProofSource::GetProof call and verify that the connection and
   // packet are processed by the time wait list manager.
   check.Call(1);
   GetFakeProofSource()->InvokePendingCallback(0);
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 0);
 
   // Verify that a data packet is passed to the time wait list manager.
   check.Call(2);
-  ProcessPacket(client_addr_, conn_id, true, false, "My name is Data");
+  ProcessPacket(client_addr_, conn_id, true, "My name is Data");
 }
 
 // Test a situation with multiple interleaved connections which the
 // StatelessRejector will accept.
 TEST_F(AsyncGetProofTest, MultipleAccept) {
   QuicConnectionId conn_id_1 = 1;
   QuicConnectionId conn_id_2 = 2;
   QuicBufferedPacketStore* store =
       QuicDispatcherPeer::GetBufferedPackets(dispatcher_.get());
 
@@ skipping 29 matching lines @@
         .WillOnce(testing::Return(GetSession(conn_id_1)));
     EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(
                     GetSession(conn_id_1)->connection()),
                 ProcessUdpPacket(_, _, _))
         .WillRepeatedly(testing::WithArg<2>(
             Invoke(CreateFunctor(&QuicDispatcherTest::ValidatePacket,
                                  base::Unretained(this), conn_id_1))));
   }
 
   // Send a CHLO that the StatelessRejector will accept.
-  ProcessPacket(client_addr_, conn_id_1, true, false, SerializeFullCHLO());
+  ProcessPacket(client_addr_, conn_id_1, true, SerializeFullCHLO());
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
 
   // Send another CHLO that the StatelessRejector will accept.
-  ProcessPacket(client_addr_, conn_id_2, true, false, SerializeFullCHLO());
+  ProcessPacket(client_addr_, conn_id_2, true, SerializeFullCHLO());
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 2);
 
   // Complete the second ProofSource::GetProof call and verify that a session is
   // created.
   check.Call(1);
   GetFakeProofSource()->InvokePendingCallback(1);
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
 
   // Verify that a data packet on that connection gets processed immediately.
   check.Call(2);
-  ProcessPacket(client_addr_, conn_id_2, true, false, "My name is Data");
+  ProcessPacket(client_addr_, conn_id_2, true, "My name is Data");
 
   // Verify that a data packet on the other connection does not get processed
   // yet.
   check.Call(3);
-  ProcessPacket(client_addr_, conn_id_1, true, false, "My name is Data");
+  ProcessPacket(client_addr_, conn_id_1, true, "My name is Data");
   EXPECT_TRUE(store->HasBufferedPackets(conn_id_1));
   EXPECT_FALSE(store->HasBufferedPackets(conn_id_2));
 
   // Complete the first ProofSource::GetProof call and verify that a session is
   // created and the buffered packet is processed.
   check.Call(4);
   GetFakeProofSource()->InvokePendingCallback(0);
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 0);
 }
 
@@ skipping 28 matching lines @@
                 ShouldCreateOrBufferPacketForConnection(conn_id_1));
 
     EXPECT_CALL(check, Call(4));
     EXPECT_CALL(*time_wait_list_manager_,
                 AddConnectionIdToTimeWait(conn_id_1, _, true, _));
     EXPECT_CALL(*time_wait_list_manager_,
                 ProcessPacket(_, client_addr_, conn_id_1, _, _));
   }
 
   // Send a CHLO that the StatelessRejector will reject.
-  ProcessPacket(client_addr_, conn_id_1, true, false, SerializeCHLO());
+  ProcessPacket(client_addr_, conn_id_1, true, SerializeCHLO());
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
 
   // Send another CHLO that the StatelessRejector will reject.
-  ProcessPacket(client_addr_, conn_id_2, true, false, SerializeCHLO());
+  ProcessPacket(client_addr_, conn_id_2, true, SerializeCHLO());
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 2);
 
   // Complete the second ProofSource::GetProof call and verify that the
   // connection and packet are processed by the time wait manager.
   check.Call(1);
   GetFakeProofSource()->InvokePendingCallback(1);
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
 
   // Verify that a data packet on that connection gets processed immediately by
   // the time wait manager.
   check.Call(2);
-  ProcessPacket(client_addr_, conn_id_2, true, false, "My name is Data");
+  ProcessPacket(client_addr_, conn_id_2, true, "My name is Data");
 
   // Verify that a data packet on the first connection gets buffered.
   check.Call(3);
-  ProcessPacket(client_addr_, conn_id_1, true, false, "My name is Data");
+  ProcessPacket(client_addr_, conn_id_1, true, "My name is Data");
   EXPECT_TRUE(store->HasBufferedPackets(conn_id_1));
   EXPECT_FALSE(store->HasBufferedPackets(conn_id_2));
 
   // Complete the first ProofSource::GetProof call and verify that the CHLO is
   // processed by the time wait manager and the remaining packets are discarded.
   check.Call(4);
   GetFakeProofSource()->InvokePendingCallback(0);
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 0);
   EXPECT_FALSE(store->HasBufferedPackets(conn_id_1));
   EXPECT_FALSE(store->HasBufferedPackets(conn_id_2));
@@ skipping 18 matching lines @@
     EXPECT_CALL(check, Call(2));
     EXPECT_CALL(*dispatcher_, CreateQuicSession(conn_id_1, client_addr_))
         .Times(0);
     EXPECT_CALL(*time_wait_list_manager_,
                 AddConnectionIdToTimeWait(conn_id_1, _, true, _));
     EXPECT_CALL(*time_wait_list_manager_,
                 ProcessPacket(_, client_addr_, conn_id_1, _, _));
   }
 
   // Send a CHLO that the StatelessRejector will reject.
-  ProcessPacket(client_addr_, conn_id_1, true, false, SerializeCHLO());
+  ProcessPacket(client_addr_, conn_id_1, true, SerializeCHLO());
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
   EXPECT_FALSE(store->HasBufferedPackets(conn_id_1));
 
   // Send an identical CHLO which should get buffered.
   check.Call(1);
-  ProcessPacket(client_addr_, conn_id_1, true, false, SerializeCHLO());
+  ProcessPacket(client_addr_, conn_id_1, true, SerializeCHLO());
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
   EXPECT_TRUE(store->HasBufferedPackets(conn_id_1));
 
   // Complete the ProofSource::GetProof call and verify that the CHLO is
   // rejected and the copy is discarded.
   check.Call(2);
   GetFakeProofSource()->InvokePendingCallback(0);
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 0);
   EXPECT_FALSE(store->HasBufferedPackets(conn_id_1));
 }
@@ skipping 15 matching lines @@
     EXPECT_CALL(*dispatcher_, ShouldCreateOrBufferPacketForConnection(conn_id));
 
     EXPECT_CALL(check, Call(2));
     EXPECT_CALL(*time_wait_list_manager_,
                 ProcessPacket(_, client_addr_, conn_id, _, _));
     EXPECT_CALL(*dispatcher_, CreateQuicSession(conn_id, client_addr_))
         .Times(0);
   }
 
   // Send a CHLO that the StatelessRejector will accept.
-  ProcessPacket(client_addr_, conn_id, true, false, SerializeFullCHLO());
+  ProcessPacket(client_addr_, conn_id, true, SerializeFullCHLO());
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
   EXPECT_FALSE(store->HasBufferedPackets(conn_id));
 
   // Send a data packet that will get buffered
   check.Call(1);
-  ProcessPacket(client_addr_, conn_id, true, false, "My name is Data");
+  ProcessPacket(client_addr_, conn_id, true, "My name is Data");
   EXPECT_TRUE(store->HasBufferedPackets(conn_id));
 
   // Pretend that enough time has gone by for the packets to get expired out of
   // the buffer
   mock_helper_.AdvanceTime(
       QuicTime::Delta::FromSeconds(kInitialIdleTimeoutSecs));
   QuicBufferedPacketStorePeer::expiration_alarm(store)->Cancel();
   store->OnExpirationTimeout();
   EXPECT_FALSE(store->HasBufferedPackets(conn_id));
   EXPECT_TRUE(time_wait_list_manager_->IsConnectionIdInTimeWait(conn_id));
@@ skipping 31 matching lines @@
         .WillOnce(testing::Return(GetSession(conn_id)));
     EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(
                     GetSession(conn_id)->connection()),
                 ProcessUdpPacket(_, _, _))
         .WillOnce(testing::WithArg<2>(
             Invoke(CreateFunctor(&QuicDispatcherTest::ValidatePacket,
                                  base::Unretained(this), conn_id))));
   }
 
   // Send a CHLO that the StatelessRejector will accept.
-  ProcessPacket(client_addr_, conn_id, true, false, SerializeFullCHLO());
+  ProcessPacket(client_addr_, conn_id, true, SerializeFullCHLO());
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
   EXPECT_FALSE(store->HasBufferedPackets(conn_id));
 
   // Send a data packet that will get buffered
   check.Call(1);
-  ProcessPacket(client_addr_, conn_id, true, false, "My name is Data");
+  ProcessPacket(client_addr_, conn_id, true, "My name is Data");
   EXPECT_TRUE(store->HasBufferedPackets(conn_id));
 
   // Pretend that enough time has gone by for the packets to get expired out of
   // the buffer
   mock_helper_.AdvanceTime(
       QuicTime::Delta::FromSeconds(kInitialIdleTimeoutSecs));
   QuicBufferedPacketStorePeer::expiration_alarm(store)->Cancel();
   store->OnExpirationTimeout();
   EXPECT_FALSE(store->HasBufferedPackets(conn_id));
   EXPECT_TRUE(time_wait_list_manager_->IsConnectionIdInTimeWait(conn_id));
@@ skipping 15 matching lines @@
   check.Call(2);
   GetFakeProofSource()->InvokePendingCallback(0);
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 0);
   EXPECT_FALSE(store->HasBufferedPackets(conn_id));
   EXPECT_FALSE(time_wait_list_manager_->IsConnectionIdInTimeWait(conn_id));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net