Remove max_packet_length from QuicPacketGenerator, because it is no longer necessary with FEC gone.…

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 372 matching lines @@
   QuicConsumedData consumed = generator_.ConsumeData(
       kCryptoStreamId, MakeIOVector("foo"), 0, false, nullptr);
   EXPECT_EQ(3u, consumed.bytes_consumed);
   EXPECT_FALSE(generator_.HasQueuedFrames());
 
   PacketContents contents;
   contents.num_stream_frames = 1;
   CheckPacketContains(contents, 0);
 
   ASSERT_EQ(1u, packets_.size());
-  ASSERT_EQ(kDefaultMaxPacketSize, generator_.GetMaxPacketLength());
+  ASSERT_EQ(kDefaultMaxPacketSize, generator_.GetCurrentMaxPacketLength());
   EXPECT_EQ(kDefaultMaxPacketSize, packets_[0].encrypted_length);
 }
 
 TEST_F(QuicPacketGeneratorTest, ConsumeData_EmptyData) {
   EXPECT_DFATAL(generator_.ConsumeData(kHeadersStreamId, MakeIOVector(""), 0,
                                        false, nullptr),
                 "Attempt to consume empty data without FIN.");
 }
 
 TEST_F(QuicPacketGeneratorTest,
@@ skipping 257 matching lines @@
   EXPECT_FALSE(generator_.HasQueuedFrames());
 
   // We expect first data chunk to get fragmented, but the second one to fit
   // into a single packet.
   ASSERT_EQ(3u, packets_.size());
   EXPECT_EQ(kDefaultMaxPacketSize, packets_[0].encrypted_length);
   EXPECT_LE(kDefaultMaxPacketSize, packets_[2].encrypted_length);
   CheckAllPacketsHaveSingleStreamFrame();
 }
 
-// Test whether SetMaxPacketLength() works correctly when we change the packet
-// size in the middle of the batched packet.
-TEST_F(QuicPacketGeneratorTest, SetMaxPacketLength_Midpacket) {
-  delegate_.SetCanWriteAnything();
-  generator_.StartBatchOperations();
-
-  size_t first_write_len = kDefaultMaxPacketSize / 2;
-  size_t second_write_len = kDefaultMaxPacketSize;
-  size_t packet_len = kDefaultMaxPacketSize + 100;
-  ASSERT_LE(packet_len, kMaxPacketSize);
-
-  // First send half of the packet worth of data.  We are in the batch mode, so
-  // should not cause packet serialization.
-  QuicConsumedData consumed =
-      generator_.ConsumeData(kHeadersStreamId, CreateData(first_write_len),
-                             /*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);
-  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.
-  consumed =
-      generator_.ConsumeData(kHeadersStreamId, CreateData(second_write_len),
-                             /*offset=*/2 + first_write_len,
-                             /*fin=*/true, nullptr);
-  EXPECT_EQ(second_write_len, consumed.bytes_consumed);
-  EXPECT_TRUE(consumed.fin_consumed);
-  EXPECT_TRUE(generator_.HasQueuedFrames());
-
-  // We expect the first packet to contain two frames, and to not reflect the
-  // packet size change.
-  ASSERT_EQ(1u, packets_.size());
-  EXPECT_EQ(kDefaultMaxPacketSize, packets_[0].encrypted_length);
-
-  PacketContents contents;
-  contents.num_stream_frames = 2;
-  CheckPacketContains(contents, 0);
-}
-
 // Test whether SetMaxPacketLength() works correctly when we force the change of
 // the packet size in the middle of the batched packet.
 TEST_F(QuicPacketGeneratorTest, SetMaxPacketLength_MidpacketFlush) {
   delegate_.SetCanWriteAnything();
   generator_.StartBatchOperations();
 
   size_t first_write_len = kDefaultMaxPacketSize / 2;
   size_t packet_len = kDefaultMaxPacketSize + 100;
   size_t second_write_len = packet_len + 1;
   ASSERT_LE(packet_len, kMaxPacketSize);
@@ skipping 12 matching lines @@
   ASSERT_EQ(0u, packets_.size());
 
   // Expect a packet to be flushed.
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 
   // 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));
 
   // Send a more than a packet worth of data to the same stream.  This should
@@ skipping 143 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