Remove the force param from QuicPacketGenerator::SetMaxPacketLength because path MTU packets should…

net/quic/quic_packet_generator_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/quic/quic_packet_generator.h"
 
 #include <string>
 
 #include "base/macros.h"
 #include "net/quic/crypto/crypto_protocol.h"
@@ skipping 431 matching lines @@
   // but not enough for a stream frame of 0 offset and one with non-zero offset.
   size_t length =
       NullEncrypter().GetCiphertextSize(0) +
       GetPacketHeaderSize(
           creator_->connection_id_length(), kIncludeVersion, !kIncludePathId,
           QuicPacketCreatorPeer::NextPacketNumberLength(creator_)) +
       // Add an extra 3 bytes for the payload and 1 byte so BytesFree is larger
       // than the GetMinStreamFrameSize.
       QuicFramer::GetMinStreamFrameSize(1, 0, false) + 3 +
       QuicFramer::GetMinStreamFrameSize(1, 0, true) + 1;
-  generator_.SetMaxPacketLength(length, /*force=*/false);
+  generator_.SetMaxPacketLength(length);
   delegate_.SetCanWriteAnything();
   {
     InSequence dummy;
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
   }
   generator_.StartBatchOperations();
   // Queue enough data to prevent a stream frame with a non-zero offset from
@@ skipping 126 matching lines @@
 
 // Test whether SetMaxPacketLength() works in the situation when the queue is
 // empty, and we send three packets worth of data.
 TEST_F(QuicPacketGeneratorTest, SetMaxPacketLength_Initial) {
   delegate_.SetCanWriteAnything();
 
   // Send enough data for three packets.
   size_t data_len = 3 * kDefaultMaxPacketSize + 1;
   size_t packet_len = kDefaultMaxPacketSize + 100;
   ASSERT_LE(packet_len, kMaxPacketSize);
-  generator_.SetMaxPacketLength(packet_len, /*force=*/false);
+  generator_.SetMaxPacketLength(packet_len);
   EXPECT_EQ(packet_len, generator_.GetCurrentMaxPacketLength());
 
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .Times(3)
       .WillRepeatedly(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
   QuicConsumedData consumed =
       generator_.ConsumeData(kHeadersStreamId, CreateData(data_len),
                              /*offset=*/2,
                              /*fin=*/true, nullptr);
   EXPECT_EQ(data_len, consumed.bytes_consumed);
@@ skipping 32 matching lines @@
                              /*offset=*/2,
                              /*fin=*/false, nullptr);
   EXPECT_EQ(data_len, consumed.bytes_consumed);
   EXPECT_FALSE(consumed.fin_consumed);
   EXPECT_FALSE(generator_.HasQueuedFrames());
 
   // Make sure we already have two packets.
   ASSERT_EQ(2u, packets_.size());
 
   // Increase packet size.
-  generator_.SetMaxPacketLength(packet_len, /*force=*/false);
+  generator_.SetMaxPacketLength(packet_len);
   EXPECT_EQ(packet_len, generator_.GetCurrentMaxPacketLength());
 
   // Send a packet after packet size change.
   consumed = generator_.ConsumeData(kHeadersStreamId, CreateData(data_len),
                                     2 + data_len,
                                     /*fin=*/true, nullptr);
   EXPECT_EQ(data_len, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
   EXPECT_FALSE(generator_.HasQueuedFrames());
 
@@ skipping 23 matching lines @@
                              /*offset=*/2,
                              /*fin=*/false, nullptr);
   EXPECT_EQ(first_write_len, consumed.bytes_consumed);
   EXPECT_FALSE(consumed.fin_consumed);
   EXPECT_TRUE(generator_.HasQueuedFrames());
 
   // Make sure we have no packets so far.
   ASSERT_EQ(0u, packets_.size());
 
   // Increase packet size.  Ensure it's not immediately enacted.
-  generator_.SetMaxPacketLength(packet_len, /*force=*/false);
+  generator_.SetMaxPacketLength(packet_len);
   EXPECT_EQ(packet_len, generator_.GetMaxPacketLength());
   EXPECT_EQ(kDefaultMaxPacketSize, generator_.GetCurrentMaxPacketLength());
 
   // We expect to see exactly one packet serialized after that, since we are in
   // batch mode and we have sent approximately 3/2 of our MTU.
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 
   // Send a packet worth of data to the same stream.  This should trigger
   // serialization of other packet.
@@ skipping 36 matching lines @@
   EXPECT_FALSE(consumed.fin_consumed);
   EXPECT_TRUE(generator_.HasQueuedFrames());
 
   // Make sure we have no packets so far.
   ASSERT_EQ(0u, packets_.size());
 
   // Expect a packet to be flushed.
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 
-  // Increase packet size.  Ensure it's immediately enacted.
-  generator_.SetMaxPacketLength(packet_len, /*force=*/true);
+  // Increase packet size after flushing all frames.
+  // Ensure it's immediately enacted.
+  generator_.FlushAllQueuedFrames();
+  generator_.SetMaxPacketLength(packet_len);
   EXPECT_EQ(packet_len, generator_.GetMaxPacketLength());
   EXPECT_EQ(packet_len, generator_.GetCurrentMaxPacketLength());
   EXPECT_FALSE(generator_.HasQueuedFrames());
 
   // We expect to see exactly one packet serialized after that, because we send
   // a value somewhat exceeding new max packet size, and the tail data does not
   // get serialized because we are still in the batch mode.
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 
@@ skipping 144 matching lines @@
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
   generator_.FlushAllQueuedFrames();
   EXPECT_FALSE(generator_.HasQueuedFrames());
   generator_.SetCurrentPath(kTestPathId1, 1, 0);
   EXPECT_EQ(kTestPathId1, QuicPacketCreatorPeer::GetCurrentPath(creator_));
 }
 
 }  // namespace test
 }  // namespace net