Landing Recent QUIC changes until 01/31/2016 05:22 UTC

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 <stdint.h>
 
 #include "base/macros.h"
 #include "base/stl_util.h"
@@ skipping 84 matching lines @@
     if (serialized_packet == nullptr) {
       return;
     }
     QuicUtils::ClearSerializedPacket(serialized_packet);
   }
 
   void SaveSerializedPacket(SerializedPacket* serialized_packet) {
     if (serialized_packet == nullptr) {
       return;
     }
+    delete[] serialized_packet_.encrypted_buffer;
+    serialized_packet_ = *serialized_packet;
+    serialized_packet_.encrypted_buffer =
+        QuicUtils::CopyBuffer(*serialized_packet);
+    serialized_packet->retransmittable_frames.clear();
+  }
 
-    serialized_packet_ = *serialized_packet;
-    serialized_packet_.packet = serialized_packet->packet->Clone();
-    delete serialized_packet->packet;
-    serialized_packet->retransmittable_frames.clear();
+  void DeleteSerializedPacket() {
+    delete[] serialized_packet_.encrypted_buffer;
+    serialized_packet_.encrypted_buffer = nullptr;
+    ClearSerializedPacket(&serialized_packet_);
   }
 
  protected:
   QuicPacketCreatorTest()
       : server_framer_(SupportedVersions(GetParam().version),
                        QuicTime::Zero(),
                        Perspective::IS_SERVER),
         client_framer_(SupportedVersions(GetParam().version),
                        QuicTime::Zero(),
                        Perspective::IS_CLIENT),
@@ skipping 11 matching lines @@
     creator_.SetEncrypter(ENCRYPTION_INITIAL, new NullEncrypter());
     creator_.SetEncrypter(ENCRYPTION_FORWARD_SECURE, new NullEncrypter());
     client_framer_.set_visitor(&framer_visitor_);
     client_framer_.set_received_entropy_calculator(&entropy_calculator_);
     server_framer_.set_visitor(&framer_visitor_);
     // TODO(ianswett): Fix this test so it uses a non-null encrypter.
     FLAGS_quic_never_write_unencrypted_data = false;
     FLAGS_quic_no_unencrypted_fec = false;
   }
 
-  ~QuicPacketCreatorTest() override {}
+  ~QuicPacketCreatorTest() override {
+    delete[] serialized_packet_.encrypted_buffer;
+    ClearSerializedPacket(&serialized_packet_);
+  }
 
   SerializedPacket SerializeAllFrames(const QuicFrames& frames) {
     SerializedPacket packet = QuicPacketCreatorPeer::SerializeAllFrames(
         &creator_, frames, buffer_, kMaxPacketSize);
     EXPECT_EQ(QuicPacketCreatorPeer::GetEncryptionLevel(&creator_),
               packet.encryption_level);
     return packet;
   }
 
-  void ProcessPacket(QuicEncryptedPacket* encrypted) {
-    server_framer_.ProcessPacket(*encrypted);
+  void ProcessPacket(const SerializedPacket& packet) {
+    QuicEncryptedPacket encrypted_packet(packet.encrypted_buffer,
+                                         packet.encrypted_length);
+    server_framer_.ProcessPacket(encrypted_packet);
   }
 
   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);
     EXPECT_EQ(stream_id, frame.stream_frame->stream_id);
@@ skipping 88 matching lines @@
       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_, OnAckFrame(_));
       EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
       EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
       EXPECT_CALL(framer_visitor_, OnPacketComplete());
     }
-    ProcessPacket(serialized.packet);
-    delete serialized.packet;
+    ProcessPacket(serialized);
   }
 }
 
 TEST_P(QuicPacketCreatorTest, SerializeWithFEC) {
   // Send FEC packet every 6 packets.
   creator_.set_max_packets_per_fec_group(6);
   // Should return false since we do not have enough packets in the FEC group to
   // trigger an FEC packet.
   ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
   // Turn on FEC protection.
@@ skipping 11 matching lines @@
     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_, OnFecProtectedPayload(_));
     EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
   }
-  ProcessPacket(serialized_packet_.packet);
-  ClearSerializedPacket(&serialized_packet_);
+  ProcessPacket(serialized_packet_);
+  DeleteSerializedPacket();
 
   // Should return false since we do not have enough packets in the FEC group to
   // trigger an FEC packet.
   ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
   // Should return true since there are packets in the FEC group.
   ASSERT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
 
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true,
                                            /*is_fec_timeout=*/false);
   ASSERT_EQ(2u, serialized_packet_.packet_number);
   {
     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_, OnFecData(_));
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
   }
-  ProcessPacket(serialized_packet_.packet);
-  ClearSerializedPacket(&serialized_packet_);
+  ProcessPacket(serialized_packet_);
+  DeleteSerializedPacket();
 }
 
 TEST_P(QuicPacketCreatorTest, SerializeChangingSequenceNumberLength) {
   frames_.push_back(QuicFrame(new QuicAckFrame(MakeAckFrame(0u))));
   creator_.AddSavedFrame(frames_[0]);
   QuicPacketCreatorPeer::SetNextPacketNumberLength(&creator_,
                                                    PACKET_4BYTE_PACKET_NUMBER);
 
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillRepeatedly(
           Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   creator_.Flush();
   // The packet number length will not change mid-packet.
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             serialized_packet_.packet_number_length);
 
   {
     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_, OnAckFrame(_));
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
   }
-  ProcessPacket(serialized_packet_.packet);
-  ClearSerializedPacket(&serialized_packet_);
+  ProcessPacket(serialized_packet_);
+  DeleteSerializedPacket();
 
   creator_.AddSavedFrame(frames_[0]);
   creator_.Flush();
   // Now the actual packet number length should have changed.
   EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
             serialized_packet_.packet_number_length);
   delete frames_[0].ack_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_, OnAckFrame(_));
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
   }
-  ProcessPacket(serialized_packet_.packet);
-  ClearSerializedPacket(&serialized_packet_);
+  ProcessPacket(serialized_packet_);
+  DeleteSerializedPacket();
 }
 
 TEST_P(QuicPacketCreatorTest, ChangeSequenceNumberLengthMidPacket) {
   // Changing the packet number length with queued frames in the creator
   // should hold the change until after any currently queued frames are
   // serialized.
 
   // Packet 1.
   // Queue a frame in the creator.
   EXPECT_FALSE(creator_.HasPendingFrames());
   QuicFrame ack_frame = QuicFrame(new QuicAckFrame(MakeAckFrame(0u)));
   creator_.AddSavedFrame(ack_frame);
 
   // Now change packet number length.
   QuicPacketCreatorPeer::SetNextPacketNumberLength(&creator_,
                                                    PACKET_4BYTE_PACKET_NUMBER);
 
   // Add a STOP_WAITING frame since it contains a packet number,
   // whose length should be 1.
   QuicStopWaitingFrame stop_waiting_frame;
   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&stop_waiting_frame)));
   EXPECT_TRUE(creator_.HasPendingFrames());
 
   // Ensure the packet is successfully created.
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillRepeatedly(
           Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   creator_.Flush();
-  ASSERT_TRUE(serialized_packet_.packet);
+  ASSERT_TRUE(serialized_packet_.encrypted_buffer);
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             serialized_packet_.packet_number_length);
 
   // Verify that header in transmitted packet has 1 byte sequence length.
   QuicPacketHeader header;
   {
     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(_))
         .WillOnce(DoAll(SaveArg<0>(&header), Return(true)));
     EXPECT_CALL(framer_visitor_, OnAckFrame(_));
     EXPECT_CALL(framer_visitor_, OnStopWaitingFrame(_));
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
   }
-  ProcessPacket(serialized_packet_.packet);
+  ProcessPacket(serialized_packet_);
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             header.public_header.packet_number_length);
-  ClearSerializedPacket(&serialized_packet_);
+  DeleteSerializedPacket();
 
   // Packet 2.
   EXPECT_FALSE(creator_.HasPendingFrames());
   // Generate Packet 2 with one frame -- packet number length should now
   // change to 4 bytes.
   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&stop_waiting_frame)));
   EXPECT_TRUE(creator_.HasPendingFrames());
 
   // Ensure the packet is successfully created.
   creator_.Flush();
-  ASSERT_TRUE(serialized_packet_.packet);
+  ASSERT_TRUE(serialized_packet_.encrypted_buffer);
   EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
             serialized_packet_.packet_number_length);
 
   // Verify that header in transmitted packet has 4 byte sequence length.
   {
     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(_))
         .WillOnce(DoAll(SaveArg<0>(&header), Return(true)));
     EXPECT_CALL(framer_visitor_, OnStopWaitingFrame(_));
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
   }
-  ProcessPacket(serialized_packet_.packet);
+  ProcessPacket(serialized_packet_);
   EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
             header.public_header.packet_number_length);
 
-  ClearSerializedPacket(&serialized_packet_);
+  DeleteSerializedPacket();
   delete ack_frame.ack_frame;
 }
 
 TEST_P(QuicPacketCreatorTest, SerializeWithFECChangingSequenceNumberLength) {
   // Test goal is to test the following sequence (P1 => generate Packet 1):
   // P1 <change seq num length> P2 FEC,
   // and we expect that packet number length should not change until the end
   // of the open FEC group.
 
   // Send FEC packet every 6 packets.
@@ skipping 21 matching lines @@
     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_, OnFecProtectedPayload(_));
     EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
   }
-  ProcessPacket(serialized_packet_.packet);
-  ClearSerializedPacket(&serialized_packet_);
+  ProcessPacket(serialized_packet_);
+  DeleteSerializedPacket();
 
   // Generate Packet 2.
   ASSERT_TRUE(creator_.ConsumeData(2u, io_vector, 0u, 0u, false, false, &frame,
                                    MUST_FEC_PROTECT));
   creator_.Flush();
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             serialized_packet_.packet_number_length);
 
   {
     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_, OnFecProtectedPayload(_));
     EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
   }
-  ProcessPacket(serialized_packet_.packet);
-  ClearSerializedPacket(&serialized_packet_);
+  ProcessPacket(serialized_packet_);
+  DeleteSerializedPacket();
 
   // Should return false since we do not have enough packets in the FEC group to
   // trigger an FEC packet.
   ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
   // Should return true since there are packets in the FEC group.
   ASSERT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
 
   // Force generation of FEC packet.
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   // Turn off FEC protection.
   creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true,
                                            /*is_fec_timeout=*/false);
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             serialized_packet_.packet_number_length);
   ASSERT_EQ(3u, serialized_packet_.packet_number);
 
   {
     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_, OnFecData(_));
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
   }
-  ProcessPacket(serialized_packet_.packet);
-  ClearSerializedPacket(&serialized_packet_);
+  ProcessPacket(serialized_packet_);
+  DeleteSerializedPacket();
 
   // Ensure the next FEC group starts using the new packet number length.
   ASSERT_TRUE(creator_.ConsumeData(3u, io_vector, 0u, 0u, false, false, &frame,
                                    MUST_FEC_PROTECT));
   EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   creator_.Flush();
   EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
             serialized_packet_.packet_number_length);
-  ClearSerializedPacket(&serialized_packet_);
+  DeleteSerializedPacket();
 }
 
 TEST_P(QuicPacketCreatorTest, ReserializeFramesWithSequenceNumberLength) {
   // If the original packet number length, the current packet number
   // length, and the configured send packet number length are different, the
   // retransmit must sent with the original length and the others do not change.
   QuicPacketCreatorPeer::SetNextPacketNumberLength(&creator_,
                                                    PACKET_4BYTE_PACKET_NUMBER);
   QuicPacketCreatorPeer::SetPacketNumberLength(&creator_,
                                                PACKET_2BYTE_PACKET_NUMBER);
@@ skipping 23 matching lines @@
   {
     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;
+  ProcessPacket(serialized);
   delete stream_frame;
 }
 
 TEST_P(QuicPacketCreatorTest, ReserializeCryptoFrameWithForwardSecurity) {
   QuicStreamFrame* stream_frame =
       new QuicStreamFrame(kCryptoStreamId, /*fin=*/false, 0u, StringPiece());
   QuicFrames frames;
   frames.push_back(QuicFrame(stream_frame));
   creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
   char buffer[kMaxPacketSize];
   PendingRetransmission retransmission(CreateRetransmission(
       frames, true /* has_crypto_handshake */, true /* needs padding */,
       ENCRYPTION_NONE,
       QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)));
   if (FLAGS_quic_retransmit_via_onserializedpacket) {
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   }
   SerializedPacket serialized =
       creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
   if (FLAGS_quic_retransmit_via_onserializedpacket) {
     serialized = serialized_packet_;
   }
   EXPECT_EQ(ENCRYPTION_NONE, serialized.encryption_level);
-  delete serialized.packet;
   delete stream_frame;
 }
 
 TEST_P(QuicPacketCreatorTest, ReserializeFrameWithForwardSecurity) {
   QuicStreamFrame* stream_frame =
       new QuicStreamFrame(0u, /*fin=*/false, 0u, StringPiece());
   QuicFrames frames;
   frames.push_back(QuicFrame(stream_frame));
   creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
   char buffer[kMaxPacketSize];
   PendingRetransmission retransmission(CreateRetransmission(
       frames, false /* has_crypto_handshake */, false /* needs padding */,
       ENCRYPTION_NONE,
       QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)));
   if (FLAGS_quic_retransmit_via_onserializedpacket) {
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   }
   SerializedPacket serialized =
       creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
   if (FLAGS_quic_retransmit_via_onserializedpacket) {
     serialized = serialized_packet_;
   }
   EXPECT_EQ(ENCRYPTION_FORWARD_SECURE, serialized.encryption_level);
-  delete serialized.packet;
   delete stream_frame;
 }
 
 TEST_P(QuicPacketCreatorTest, ReserializeFramesWithPadding) {
   QuicFrame frame;
   QuicIOVector io_vector(MakeIOVector("fake handshake message data"));
   QuicPacketCreatorPeer::CreateStreamFrame(&creator_, kCryptoStreamId,
                                            io_vector, 0u, 0u, false, &frame);
   QuicFrames frames;
   frames.push_back(frame);
   char buffer[kMaxPacketSize];
   PendingRetransmission retransmission(CreateRetransmission(
       frames, true /* has_crypto_handshake */, true /* needs padding */,
       ENCRYPTION_NONE,
       QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)));
   if (FLAGS_quic_retransmit_via_onserializedpacket) {
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   }
   SerializedPacket serialized =
       creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
   if (FLAGS_quic_retransmit_via_onserializedpacket) {
     serialized = serialized_packet_;
   }
-  EXPECT_EQ(kDefaultMaxPacketSize, serialized.packet->length());
-  delete serialized.packet;
+  EXPECT_EQ(kDefaultMaxPacketSize, serialized.encrypted_length);
   delete frame.stream_frame;
 }
 
 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');
@@ skipping 19 matching lines @@
         creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
     if (FLAGS_quic_retransmit_via_onserializedpacket) {
       serialized = serialized_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(kDefaultMaxPacketSize - bytes_free,
-                serialized.packet->length());
+                serialized.encrypted_length);
     } else {
-      EXPECT_EQ(kDefaultMaxPacketSize, serialized.packet->length());
+      EXPECT_EQ(kDefaultMaxPacketSize, serialized.encrypted_length);
     }
 
-    delete serialized.packet;
     delete frame.stream_frame;
     frames_.clear();
   }
 }
 
 TEST_P(QuicPacketCreatorTest, SerializeConnectionClose) {
   QuicConnectionCloseFrame frame;
   frame.error_code = QUIC_NO_ERROR;
   frame.error_details = "error";
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&frame));
   SerializedPacket serialized = SerializeAllFrames(frames);
   EXPECT_EQ(ENCRYPTION_NONE, serialized.encryption_level);
   ASSERT_EQ(1u, serialized.packet_number);
   ASSERT_EQ(1u, creator_.packet_number());
 
   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_, OnConnectionCloseFrame(_));
   EXPECT_CALL(framer_visitor_, OnPacketComplete());
 
-  ProcessPacket(serialized.packet);
-  delete serialized.packet;
+  ProcessPacket(serialized);
 }
 
 TEST_P(QuicPacketCreatorTest, SwitchFecOnOffWithGroupInProgress) {
   // Send FEC packet every 6 packets.
   creator_.set_max_packets_per_fec_group(6);
   // Turn on FEC protection.
   QuicFrame frame;
   QuicIOVector io_vector(MakeIOVector("test"));
   ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
                                    MUST_FEC_PROTECT));
@@ skipping 148 matching lines @@
     ASSERT_TRUE(frame.stream_frame);
 
     // BytesFree() returns bytes available for the next frame, which will
     // be two bytes smaller since the stream frame would need to be grown.
     EXPECT_EQ(2u, creator_.ExpansionOnNewFrame());
     size_t expected_bytes_free = bytes_free < 3 ? 0 : bytes_free - 2;
     EXPECT_EQ(expected_bytes_free, creator_.BytesFree()) << "delta: " << delta;
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
     creator_.Flush();
-    ASSERT_TRUE(serialized_packet_.packet);
-    ClearSerializedPacket(&serialized_packet_);
+    ASSERT_TRUE(serialized_packet_.encrypted_buffer);
+    DeleteSerializedPacket();
   }
 }
 
 TEST_P(QuicPacketCreatorTest, StreamFrameConsumptionWithFec) {
   // Send FEC packet every 6 packets.
   creator_.set_max_packets_per_fec_group(6);
   // Turn on FEC protection.
   QuicFrame frame;
   QuicIOVector io_vector(MakeIOVector("test"));
   ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
@@ skipping 30 matching lines @@
       EXPECT_CALL(delegate_, OnSerializedPacket(_))
           .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
       // Every 6th packet will generate an extra FEC packet.
       if (delta == -1 || delta == 5) {
         EXPECT_CALL(delegate_, OnSerializedPacket(_))
             .WillOnce(
                 Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
       }
     }
     creator_.Flush();
-    ASSERT_TRUE(serialized_packet_.packet);
-    ClearSerializedPacket(&serialized_packet_);
+    ASSERT_TRUE(serialized_packet_.encrypted_buffer);
+    DeleteSerializedPacket();
   }
 }
 
 TEST_P(QuicPacketCreatorTest, CryptoStreamFramePacketPadding) {
   // 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(kMaxPacketSize, 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;
     QuicIOVector io_vector(MakeIOVector(data));
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillRepeatedly(
             Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
     ASSERT_TRUE(creator_.ConsumeData(kCryptoStreamId, io_vector, 0u, kOffset,
                                      false, true, &frame, MAY_FEC_PROTECT));
     ASSERT_TRUE(frame.stream_frame);
     size_t bytes_consumed = frame.stream_frame->frame_length;
     EXPECT_LT(0u, bytes_consumed);
     creator_.Flush();
-    ASSERT_TRUE(serialized_packet_.packet);
+    ASSERT_TRUE(serialized_packet_.encrypted_buffer);
     // 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(kDefaultMaxPacketSize - bytes_free,
-                serialized_packet_.packet->length());
+                serialized_packet_.encrypted_length);
     } else {
-      EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_.packet->length());
+      EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_.encrypted_length);
     }
-    ClearSerializedPacket(&serialized_packet_);
+    DeleteSerializedPacket();
   }
 }
 
 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;
     QuicIOVector io_vector(MakeIOVector(data));
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
     ASSERT_TRUE(creator_.ConsumeData(kClientDataStreamId1, io_vector, 0u,
                                      kOffset, false, false, &frame,
                                      MAY_FEC_PROTECT));
     ASSERT_TRUE(frame.stream_frame);
     size_t bytes_consumed = frame.stream_frame->frame_length;
     EXPECT_LT(0u, bytes_consumed);
     creator_.Flush();
-    ASSERT_TRUE(serialized_packet_.packet);
+    ASSERT_TRUE(serialized_packet_.encrypted_buffer);
     if (bytes_free > 0) {
       EXPECT_EQ(kDefaultMaxPacketSize - bytes_free,
-                serialized_packet_.packet->length());
+                serialized_packet_.encrypted_length);
     } else {
-      EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_.packet->length());
+      EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_.encrypted_length);
     }
-    ClearSerializedPacket(&serialized_packet_);
+    DeleteSerializedPacket();
   }
 }
 
 TEST_P(QuicPacketCreatorTest, SerializeVersionNegotiationPacket) {
   QuicFramerPeer::SetPerspective(&client_framer_, Perspective::IS_SERVER);
   QuicVersionVector versions;
   versions.push_back(test::QuicVersionMax());
   scoped_ptr<QuicEncryptedPacket> encrypted(
       creator_.SerializeVersionNegotiationPacket(versions));
 
@@ skipping 76 matching lines @@
     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(_))
         .WillOnce(DoAll(SaveArg<0>(&header), Return(true)));
     EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
   }
-  ProcessPacket(serialized.packet);
+  ProcessPacket(serialized);
   EXPECT_EQ(GetParam().version_serialization,
             header.public_header.version_flag);
-  delete serialized.packet;
 }
 
 TEST_P(QuicPacketCreatorTest, ConsumeDataLargerThanOneStreamFrame) {
   if (!GetParam().version_serialization) {
     creator_.StopSendingVersion();
   }
   // A string larger than fits into a frame.
   size_t payload_length;
   creator_.SetMaxPacketLength(GetPacketLengthForOneStream(
       client_framer_.version(),
       QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
       QuicPacketCreatorPeer::SendPathIdInPacket(&creator_),
       creator_.connection_id_length(), PACKET_1BYTE_PACKET_NUMBER,
       NOT_IN_FEC_GROUP, &payload_length));
   QuicFrame frame;
   const string too_long_payload(payload_length * 2, 'a');
   QuicIOVector io_vector(MakeIOVector(too_long_payload));
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, true, false, &frame,
                                    MAY_FEC_PROTECT));
   ASSERT_TRUE(frame.stream_frame);
   size_t consumed = frame.stream_frame->frame_length;
   EXPECT_EQ(payload_length, consumed);
   const string payload(payload_length, 'a');
   CheckStreamFrame(frame, 1u, payload, 0u, false);
   creator_.Flush();
-  ClearSerializedPacket(&serialized_packet_);
+  DeleteSerializedPacket();
 }
 
 TEST_P(QuicPacketCreatorTest, AddFrameAndFlush) {
   if (!GetParam().version_serialization) {
     creator_.StopSendingVersion();
   }
   const size_t max_plaintext_size =
       client_framer_.GetMaxPlaintextSize(creator_.max_packet_length());
   EXPECT_FALSE(creator_.HasPendingFrames());
   EXPECT_EQ(max_plaintext_size -
@@ skipping 22 matching lines @@
   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(padding_frame)));
   EXPECT_TRUE(creator_.HasPendingFrames());
   EXPECT_EQ(0u, creator_.BytesFree());
 
   // Packet is full. Creator will flush.
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   EXPECT_FALSE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
 
   // Ensure the packet is successfully created.
-  ASSERT_TRUE(serialized_packet_.packet);
+  ASSERT_TRUE(serialized_packet_.encrypted_buffer);
   ASSERT_FALSE(serialized_packet_.retransmittable_frames.empty());
   const QuicFrames& retransmittable = serialized_packet_.retransmittable_frames;
   ASSERT_EQ(1u, retransmittable.size());
   EXPECT_EQ(STREAM_FRAME, retransmittable[0].type);
   ASSERT_TRUE(retransmittable[0].stream_frame);
-  ClearSerializedPacket(&serialized_packet_);
+  DeleteSerializedPacket();
 
   EXPECT_FALSE(creator_.HasPendingFrames());
   EXPECT_EQ(max_plaintext_size -
                 GetPacketHeaderSize(
                     creator_.connection_id_length(),
                     QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
                     /*include_path_id=*/false, PACKET_1BYTE_PACKET_NUMBER,
                     NOT_IN_FEC_GROUP),
             creator_.BytesFree());
 }
@@ skipping 29 matching lines @@
   EXPECT_EQ(4u, consumed);
   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));
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   size_t est_packet_size = creator_.PacketSize();
   creator_.Flush();
-  ASSERT_TRUE(serialized_packet_.packet);
+  ASSERT_TRUE(serialized_packet_.encrypted_buffer);
   EXPECT_EQ(est_packet_size, client_framer_.GetMaxPlaintextSize(
-                                 serialized_packet_.packet->length()));
-  ClearSerializedPacket(&serialized_packet_);
+                                 serialized_packet_.encrypted_length));
+  DeleteSerializedPacket();
 }
 
 TEST_P(QuicPacketCreatorTest, SerializeTruncatedAckFrameWithSmallPacketSize) {
   if (!GetParam().version_serialization) {
     creator_.StopSendingVersion();
   }
   creator_.SetMaxPacketLength(500u);
 
   const size_t max_plaintext_size =
       client_framer_.GetMaxPlaintextSize(creator_.max_packet_length());
@@ skipping 14 matching lines @@
             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();
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   creator_.Flush();
-  ASSERT_TRUE(serialized_packet_.packet);
+  ASSERT_TRUE(serialized_packet_.encrypted_buffer);
   EXPECT_GE(est_packet_size, client_framer_.GetMaxPlaintextSize(
-                                 serialized_packet_.packet->length()));
-  ClearSerializedPacket(&serialized_packet_);
+                                 serialized_packet_.encrypted_length));
+  DeleteSerializedPacket();
 }
 
 TEST_P(QuicPacketCreatorTest, EntropyFlag) {
   frames_.push_back(
       QuicFrame(new QuicStreamFrame(0u, false, 0u, StringPiece())));
 
   for (int i = 0; i < 2; ++i) {
     for (int j = 0; j < 64; ++j) {
       SerializedPacket serialized = SerializeAllFrames(frames_);
       // Verify both BoolSource and hash algorithm.
       bool expected_rand_bool =
           (mock_random_.RandUint64() & (UINT64_C(1) << j)) != 0;
       bool observed_rand_bool =
           (serialized.entropy_hash & (1 << ((j + 1) % 8))) != 0;
       uint8_t rest_of_hash = serialized.entropy_hash & ~(1 << ((j + 1) % 8));
       EXPECT_EQ(expected_rand_bool, observed_rand_bool);
       EXPECT_EQ(0, rest_of_hash);
-      delete serialized.packet;
     }
     // After 64 calls, BoolSource will refresh the bucket - make sure it does.
     mock_random_.ChangeValue();
   }
 
   delete frames_[0].stream_frame;
 }
 
 TEST_P(QuicPacketCreatorTest, ResetFecGroup) {
   // Send FEC packet every 6 packets.
@@ skipping 53 matching lines @@
   // Should return true since there are packets in the FEC group.
   ASSERT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
 
   // Change FEC policy, send FEC packet and close FEC group.
   creator_.set_fec_send_policy(FEC_ANY_TRIGGER);
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true,
                                            /*is_fec_timeout=*/false);
   ASSERT_EQ(3u, serialized_packet_.packet_number);
-  ClearSerializedPacket(&serialized_packet_);
+  DeleteSerializedPacket();
 }
 
 TEST_P(QuicPacketCreatorTest, ResetFecGroupWithQueuedFrames) {
   // Send FEC packet every 6 packets.
   creator_.set_max_packets_per_fec_group(6);
   // Add a stream frame to the creator and turn on FEC protection.
   QuicFrame frame;
   QuicIOVector io_vector(MakeIOVector("test"));
   ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
                                    MUST_FEC_PROTECT));
@@ skipping 198 matching lines @@
   EXPECT_TRUE(creator_.HasPendingFrames());
   EXPECT_EQ(0u, creator_.packet_number());
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillRepeatedly(
           Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   creator_.Flush();
   EXPECT_FALSE(creator_.HasPendingFrames());
   EXPECT_EQ(1u, creator_.packet_number());
   // Verify serialized data packet's path id.
   EXPECT_EQ(kDefaultPathId, serialized_packet_.path_id);
-  ClearSerializedPacket(&serialized_packet_);
+  DeleteSerializedPacket();
 
   // Change to path 1.
   QuicPathId kPathId1 = 1;
   creator_.SetCurrentPath(kPathId1, 1, 0);
   EXPECT_EQ(kPathId1, QuicPacketCreatorPeer::GetCurrentPath(&creator_));
   EXPECT_FALSE(creator_.HasPendingFrames());
   EXPECT_EQ(0u, creator_.packet_number());
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
 
   // Add a stream frame to the creator and flush the packet.
   ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
                                    MAY_FEC_PROTECT));
   ASSERT_TRUE(frame.stream_frame);
   consumed = frame.stream_frame->frame_length;
   EXPECT_EQ(4u, consumed);
   EXPECT_TRUE(creator_.HasPendingFrames());
   creator_.Flush();
   // Verify serialized data packet's path id.
   EXPECT_EQ(kPathId1, serialized_packet_.path_id);
-  ClearSerializedPacket(&serialized_packet_);
+  DeleteSerializedPacket();
 }
 
 TEST_P(QuicPacketCreatorTest, AddUnencryptedStreamDataClosesConnection) {
   FLAGS_quic_never_write_unencrypted_data = true;
   EXPECT_CALL(delegate_, CloseConnection(_, _));
   QuicStreamFrame stream_frame(kHeadersStreamId, /*fin=*/false, 0u,
                                StringPiece());
   EXPECT_DFATAL(creator_.AddSavedFrame(QuicFrame(&stream_frame)),
                 "Cannot send stream data without encryption.");
 }
@@ skipping 44 matching lines @@
   EXPECT_CALL(delegate_, CloseConnection(QUIC_UNENCRYPTED_FEC_DATA, _));
   char seralized_fec_buffer[kMaxPacketSize];
   EXPECT_DFATAL(QuicPacketCreatorPeer::SerializeFec(
                     &creator_, seralized_fec_buffer, kMaxPacketSize),
                 "SerializeFEC must be called with encryption.");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net