Replace QuicEncryptedPacket's fields with equivalents in SerializedPacket.

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_.packet = serialized_packet->packet->Clone();
-    delete serialized_packet->packet;
+    serialized_packet_.encrypted_buffer =
+        QuicUtils::CopyBuffer(*serialized_packet);
     serialized_packet->retransmittable_frames.clear();
   }
 
-  void DeleteSerializedPacket() { ClearSerializedPacket(&serialized_packet_); }
+  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),
         connection_id_(2),
@@ skipping 10 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(const SerializedPacket& packet) {
-    server_framer_.ProcessPacket(*packet.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 89 matching lines @@
       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);
-    delete serialized.packet;
   }
 }
 
 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 113 matching lines @@
   // 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(_));
@@ skipping 11 matching lines @@
 
   // 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(_));
@@ skipping 148 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);
-  delete serialized.packet;
   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);
-  delete serialized.packet;
 }
 
 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);
+    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"));
@@ skipping 31 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);
+    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);
     }
     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);
     }
     DeleteSerializedPacket();
   }
 }
 
 TEST_P(QuicPacketCreatorTest, SerializeVersionNegotiationPacket) {
   QuicFramerPeer::SetPerspective(&client_framer_, Perspective::IS_SERVER);
   QuicVersionVector versions;
   versions.push_back(test::QuicVersionMax());
   scoped_ptr<QuicEncryptedPacket> encrypted(
@@ skipping 81 matching lines @@
     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);
   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(),
@@ skipping 50 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);
   DeleteSerializedPacket();
 
   EXPECT_FALSE(creator_.HasPendingFrames());
   EXPECT_EQ(max_plaintext_size -
                 GetPacketHeaderSize(
@@ skipping 35 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()));
+                                 serialized_packet_.encrypted_length));
   DeleteSerializedPacket();
 }
 
 TEST_P(QuicPacketCreatorTest, SerializeTruncatedAckFrameWithSmallPacketSize) {
   if (!GetParam().version_serialization) {
     creator_.StopSendingVersion();
   }
   creator_.SetMaxPacketLength(500u);
 
   const size_t max_plaintext_size =
@@ skipping 15 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()));
+                                 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 358 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