Update from https://crrev.com/316786

net/quic/quic_packet_creator_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_creator.h"
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/null_encrypter.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
@@ skipping 71 matching lines @@
         data_("foo"),
         creator_(connection_id_, &client_framer_, &mock_random_) {
     creator_.set_connection_id_length(GetParam().connection_id_length);
     client_framer_.set_visitor(&framer_visitor_);
     client_framer_.set_received_entropy_calculator(&entropy_calculator_);
     server_framer_.set_visitor(&framer_visitor_);
   }
 
   ~QuicPacketCreatorTest() override {}
 
-  void ProcessPacket(QuicPacket* packet) {
-    scoped_ptr<QuicEncryptedPacket> encrypted(
-        server_framer_.EncryptPacket(ENCRYPTION_NONE, sequence_number_,
-                                     *packet));
+  void ProcessPacket(QuicEncryptedPacket* encrypted) {
     server_framer_.ProcessPacket(*encrypted);
   }
 
   void CheckStreamFrame(const QuicFrame& frame,
                         QuicStreamId stream_id,
                         const string& data,
                         QuicStreamOffset offset,
                         bool fin) {
     EXPECT_EQ(STREAM_FRAME, frame.type);
     ASSERT_TRUE(frame.stream_frame);
@@ skipping 328 matching lines @@
   delete serialized.packet;
 }
 
 TEST_P(QuicPacketCreatorTest, ReserializeFramesWithSequenceNumberLength) {
   // If the original packet sequence number length, the current sequence number
   // length, and the configured send sequence number length are different, the
   // retransmit must sent with the original length and the others do not change.
   creator_.set_next_sequence_number_length(PACKET_4BYTE_SEQUENCE_NUMBER);
   QuicPacketCreatorPeer::SetSequenceNumberLength(&creator_,
                                                  PACKET_2BYTE_SEQUENCE_NUMBER);
-  frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
+  QuicStreamFrame* stream_frame =
+      new QuicStreamFrame(kCryptoStreamId, /*fin=*/false, 0u, IOVector());
+  RetransmittableFrames frames;
+  frames.set_encryption_level(ENCRYPTION_NONE);
+  frames.AddStreamFrame(stream_frame);
   SerializedPacket serialized =
-      creator_.ReserializeAllFrames(frames_, PACKET_1BYTE_SEQUENCE_NUMBER);
+      creator_.ReserializeAllFrames(frames, PACKET_1BYTE_SEQUENCE_NUMBER);
   EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER,
             creator_.next_sequence_number_length());
   EXPECT_EQ(PACKET_2BYTE_SEQUENCE_NUMBER,
             QuicPacketCreatorPeer::GetSequenceNumberLength(&creator_));
   EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
-  delete frames_[0].stream_frame;
 
   {
     InSequence s;
     EXPECT_CALL(framer_visitor_, OnPacket());
     EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
     EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
     EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
     EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
   }
   ProcessPacket(serialized.packet);
   delete serialized.packet;
 }
 
 TEST_P(QuicPacketCreatorTest, ReserializeFramesWithPadding) {
-  scoped_ptr<QuicStreamFrame> stream_frame(
-      new QuicStreamFrame(kCryptoStreamId, /*fin=*/ false, /*offset=*/ 0,
-                          MakeIOVector("fake handshake message data")));
-  frames_.push_back(QuicFrame(stream_frame.get()));
-  SerializedPacket serialized =
-      creator_.ReserializeAllFrames(frames_,
-                                    creator_.next_sequence_number_length());
-
-  EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize),
-            serialized.packet->length());
+  QuicStreamFrame* stream_frame =
+      new QuicStreamFrame(kCryptoStreamId, /*fin=*/false, /*offset=*/0,
+                          MakeIOVector("fake handshake message data"));
+  RetransmittableFrames frames;
+  frames.set_encryption_level(ENCRYPTION_NONE);
+  frames.AddStreamFrame(stream_frame);
+  SerializedPacket serialized = creator_.ReserializeAllFrames(
+      frames, creator_.next_sequence_number_length());
+  EXPECT_EQ(kDefaultMaxPacketSize, serialized.packet->length());
   delete serialized.packet;
 }
 
 TEST_P(QuicPacketCreatorTest, ReserializeFramesWithFullPacketAndPadding) {
   const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP)
       + GetEncryptionOverhead() + GetStreamFrameOverhead(NOT_IN_FEC_GROUP);
   size_t capacity = kDefaultMaxPacketSize - overhead;
   for (int delta = -5; delta <= 0; ++delta) {
     string data(capacity + delta, 'A');
     size_t bytes_free = 0 - delta;
 
-    scoped_ptr<QuicStreamFrame> stream_frame(
-        new QuicStreamFrame(kCryptoStreamId, /*fin=*/ false, kOffset,
-                            MakeIOVector(data)));
-    frames_.push_back(QuicFrame(stream_frame.get()));
-    SerializedPacket serialized =
-        creator_.ReserializeAllFrames(frames_,
-                                      creator_.next_sequence_number_length());
+    QuicStreamFrame* stream_frame = new QuicStreamFrame(
+        kCryptoStreamId, /*fin=*/false, kOffset, MakeIOVector(data));
+    RetransmittableFrames frames;
+    frames.set_encryption_level(ENCRYPTION_NONE);
+    frames.AddStreamFrame(stream_frame);
+    SerializedPacket serialized = creator_.ReserializeAllFrames(
+        frames, creator_.next_sequence_number_length());
 
     // If there is not enough space in the packet to fit a padding frame
     // (1 byte) and to expand the stream frame (another 2 bytes) the packet
     // will not be padded.
     if (bytes_free < 3) {
-      EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize)
-                - bytes_free, serialized.packet->length());
+      EXPECT_EQ(kDefaultMaxPacketSize - bytes_free,
+                serialized.packet->length());
     } else {
-      EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize),
-                serialized.packet->length());
+      EXPECT_EQ(kDefaultMaxPacketSize, serialized.packet->length());
     }
 
     delete serialized.packet;
     frames_.clear();
   }
 }
 
 TEST_P(QuicPacketCreatorTest, SerializeConnectionClose) {
   QuicConnectionCloseFrame frame;
   frame.error_code = QUIC_NO_ERROR;
@@ skipping 216 matching lines @@
     size_t bytes_consumed = creator_.CreateStreamFrame(
         kCryptoStreamId, MakeIOVector(data), kOffset, false, &frame);
     EXPECT_LT(0u, bytes_consumed);
     ASSERT_TRUE(creator_.AddSavedFrame(frame));
     SerializedPacket serialized_packet = creator_.SerializePacket();
     ASSERT_TRUE(serialized_packet.packet);
     // If there is not enough space in the packet to fit a padding frame
     // (1 byte) and to expand the stream frame (another 2 bytes) the packet
     // will not be padded.
     if (bytes_free < 3) {
-      EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize)
-                - bytes_free, serialized_packet.packet->length());
+      EXPECT_EQ(kDefaultMaxPacketSize - bytes_free,
+                serialized_packet.packet->length());
     } else {
-      EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize),
-                serialized_packet.packet->length());
+      EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet.packet->length());
     }
     delete serialized_packet.packet;
     delete serialized_packet.retransmittable_frames;
   }
 }
 
 TEST_P(QuicPacketCreatorTest, NonCryptoStreamFramePacketNonPadding) {
   // Compute the total overhead for a single frame in packet.
   const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP)
       + GetEncryptionOverhead() + GetStreamFrameOverhead(NOT_IN_FEC_GROUP);
   ASSERT_GT(kDefaultMaxPacketSize, overhead);
   size_t capacity = kDefaultMaxPacketSize - overhead;
   // Now, test various sizes around this size.
   for (int delta = -5; delta <= 5; ++delta) {
     string data(capacity + delta, 'A');
     size_t bytes_free = delta > 0 ? 0 : 0 - delta;
 
     QuicFrame frame;
     size_t bytes_consumed = creator_.CreateStreamFrame(
         kClientDataStreamId1, MakeIOVector(data), kOffset, false, &frame);
     EXPECT_LT(0u, bytes_consumed);
     ASSERT_TRUE(creator_.AddSavedFrame(frame));
     SerializedPacket serialized_packet = creator_.SerializePacket();
     ASSERT_TRUE(serialized_packet.packet);
     if (bytes_free > 0) {
-      EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize)
-                - bytes_free, serialized_packet.packet->length());
+      EXPECT_EQ(kDefaultMaxPacketSize - bytes_free,
+                serialized_packet.packet->length());
     } else {
-      EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize),
-                serialized_packet.packet->length());
+      EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet.packet->length());
     }
     delete serialized_packet.packet;
     delete serialized_packet.retransmittable_frames;
   }
 }
 
 TEST_P(QuicPacketCreatorTest, SerializeVersionNegotiationPacket) {
   QuicFramerPeer::SetIsServer(&client_framer_, true);
   QuicVersionVector versions;
   versions.push_back(test::QuicVersionMax());
@@ skipping 161 matching lines @@
                 PACKET_1BYTE_SEQUENCE_NUMBER,
                 NOT_IN_FEC_GROUP),
             creator_.BytesFree());
 }
 
 TEST_P(QuicPacketCreatorTest, SerializeTruncatedAckFrameWithLargePacketSize) {
   if (!GetParam().version_serialization) {
     creator_.StopSendingVersion();
   }
   creator_.set_max_packet_length(kMaxPacketSize);
-  const size_t max_plaintext_size =
-      client_framer_.GetMaxPlaintextSize(creator_.max_packet_length());
 
   // Serialized length of ack frame with 2000 nack ranges should be limited by
   // the number of nack ranges that can be fit in an ack frame.
   QuicAckFrame ack_frame = MakeAckFrameWithNackRanges(2000u, 0u);
   size_t frame_len = client_framer_.GetSerializedFrameLength(
       QuicFrame(&ack_frame), creator_.BytesFree(), true, true,
       NOT_IN_FEC_GROUP, PACKET_1BYTE_SEQUENCE_NUMBER);
   EXPECT_GT(creator_.BytesFree(), frame_len);
-  EXPECT_GT(max_plaintext_size, creator_.PacketSize());
+  EXPECT_GT(creator_.max_packet_length(), creator_.PacketSize());
 
   // Add ack frame to creator.
   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
   EXPECT_TRUE(creator_.HasPendingFrames());
-  EXPECT_GT(max_plaintext_size, creator_.PacketSize());
+  EXPECT_GT(creator_.max_packet_length(), creator_.PacketSize());
   EXPECT_LT(0u, creator_.BytesFree());
 
   // Make sure that an additional stream frame can be added to the packet.
   QuicFrame stream_frame;
   size_t consumed = creator_.CreateStreamFrame(
       2u, MakeIOVector("test"), 0u, false, &stream_frame);
   EXPECT_EQ(4u, consumed);
   ASSERT_TRUE(stream_frame.stream_frame);
   EXPECT_TRUE(creator_.AddSavedFrame(stream_frame));
   EXPECT_TRUE(creator_.HasPendingFrames());
 
   // Ensure the packet is successfully created, and the packet size estimate
   // matches the serialized packet length.
   EXPECT_CALL(entropy_calculator_,
              EntropyHash(_)).WillOnce(testing::Return(0));
   size_t est_packet_size = creator_.PacketSize();
   SerializedPacket serialized = creator_.SerializePacket();
   ASSERT_TRUE(serialized.packet);
-  EXPECT_EQ(est_packet_size, serialized.packet->length());
+  EXPECT_EQ(est_packet_size,
+            client_framer_.GetMaxPlaintextSize(serialized.packet->length()));
   delete serialized.retransmittable_frames;
   delete serialized.packet;
 }
 
 TEST_P(QuicPacketCreatorTest, SerializeTruncatedAckFrameWithSmallPacketSize) {
   if (!GetParam().version_serialization) {
     creator_.StopSendingVersion();
   }
   creator_.set_max_packet_length(500u);
 
   const size_t max_plaintext_size =
       client_framer_.GetMaxPlaintextSize(creator_.max_packet_length());
   EXPECT_EQ(max_plaintext_size - creator_.PacketSize(), creator_.BytesFree());
 
   // Serialized length of ack frame with 2000 nack ranges should be limited by
   // the packet size.
   QuicAckFrame ack_frame = MakeAckFrameWithNackRanges(2000u, 0u);
   size_t frame_len = client_framer_.GetSerializedFrameLength(
       QuicFrame(&ack_frame), creator_.BytesFree(), true, true,
       NOT_IN_FEC_GROUP, PACKET_1BYTE_SEQUENCE_NUMBER);
   EXPECT_EQ(creator_.BytesFree(), frame_len);
 
   // Add ack frame to creator.
   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
   EXPECT_TRUE(creator_.HasPendingFrames());
-  EXPECT_EQ(max_plaintext_size, creator_.PacketSize());
+  EXPECT_EQ(client_framer_.GetMaxPlaintextSize(creator_.max_packet_length()),
+            creator_.PacketSize());
   EXPECT_EQ(0u, creator_.BytesFree());
 
   // Ensure the packet is successfully created, and the packet size estimate
   // may not match the serialized packet length.
   EXPECT_CALL(entropy_calculator_,
              EntropyHash(_)).WillOnce(Return(0));
   size_t est_packet_size = creator_.PacketSize();
   SerializedPacket serialized = creator_.SerializePacket();
   ASSERT_TRUE(serialized.packet);
-  EXPECT_GE(est_packet_size, serialized.packet->length());
+  EXPECT_GE(est_packet_size,
+            client_framer_.GetMaxPlaintextSize(serialized.packet->length()));
   delete serialized.packet;
 }
 
 
 TEST_P(QuicPacketCreatorTest, EntropyFlag) {
   frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
 
   for (int i = 0; i < 2; ++i) {
     for (int j = 0; j < 64; ++j) {
       SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
@@ skipping 10 matching lines @@
     // After 64 calls, BoolSource will refresh the bucket - make sure it does.
     mock_random_.ChangeValue();
   }
 
   delete frames_[0].stream_frame;
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net