Replace QuicEncryptedPacket's fields with equivalents in SerializedPacket.

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 106 matching lines @@
         generator_(42, &framer_, &random_, &buffer_allocator_, &delegate_),
         creator_(QuicPacketGeneratorPeer::GetPacketCreator(&generator_)) {
     generator_.set_fec_send_policy(GetParam());
     // 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;
   }
 
   ~QuicPacketGeneratorTest() override {
     for (SerializedPacket& packet : packets_) {
+      delete[] packet.encrypted_buffer;
       QuicUtils::ClearSerializedPacket(&packet);
     }
   }
 
   void SavePacket(SerializedPacket* packet) {
+    packet->encrypted_buffer = QuicUtils::CopyBuffer(*packet);
     packets_.push_back(*packet);
-    ASSERT_FALSE(packet->packet->owns_buffer());
-    scoped_ptr<QuicEncryptedPacket> encrypted_deleter(packets_.back().packet);
-    packets_.back().packet = packets_.back().packet->Clone();
+    packet->encrypted_buffer = nullptr;
     packet->retransmittable_frames.clear();
   }
 
  protected:
   QuicRstStreamFrame* CreateRstStreamFrame() {
     return new QuicRstStreamFrame(1, QUIC_STREAM_NO_ERROR, 0);
   }
 
   QuicGoAwayFrame* CreateGoAwayFrame() {
     return new QuicGoAwayFrame(QUIC_NO_ERROR, 1, string());
@@ skipping 12 matching lines @@
         contents.num_mtu_discovery_frames + num_retransmittable_frames;
 
     if (num_retransmittable_frames == 0) {
       ASSERT_TRUE(packet.retransmittable_frames.empty());
     } else {
       ASSERT_FALSE(packet.retransmittable_frames.empty());
       EXPECT_EQ(num_retransmittable_frames,
                 packet.retransmittable_frames.size());
     }
 
-    ASSERT_TRUE(packet.packet != nullptr);
-    ASSERT_TRUE(simple_framer_.ProcessPacket(*packet.packet));
+    ASSERT_TRUE(packet.encrypted_buffer != nullptr);
+    ASSERT_TRUE(simple_framer_.ProcessPacket(
+        QuicEncryptedPacket(packet.encrypted_buffer, packet.encrypted_length)));
     EXPECT_EQ(num_frames, simple_framer_.num_frames());
     EXPECT_EQ(contents.num_ack_frames, simple_framer_.ack_frames().size());
     EXPECT_EQ(contents.num_connection_close_frames,
               simple_framer_.connection_close_frames().size());
     EXPECT_EQ(contents.num_goaway_frames,
               simple_framer_.goaway_frames().size());
     EXPECT_EQ(contents.num_rst_stream_frames,
               simple_framer_.rst_stream_frames().size());
     EXPECT_EQ(contents.num_stream_frames,
               simple_framer_.stream_frames().size());
     EXPECT_EQ(contents.num_stop_waiting_frames,
               simple_framer_.stop_waiting_frames().size());
     EXPECT_EQ(contents.fec_group, simple_framer_.header().fec_group);
 
     // From the receiver's perspective, MTU discovery frames are ping frames.
     EXPECT_EQ(contents.num_ping_frames + contents.num_mtu_discovery_frames,
               simple_framer_.ping_frames().size());
   }
 
   void CheckPacketHasSingleStreamFrame(size_t packet_index) {
     ASSERT_GT(packets_.size(), packet_index);
     const SerializedPacket& packet = packets_[packet_index];
     ASSERT_FALSE(packet.retransmittable_frames.empty());
     EXPECT_EQ(1u, packet.retransmittable_frames.size());
-    ASSERT_TRUE(packet.packet != nullptr);
-    ASSERT_TRUE(simple_framer_.ProcessPacket(*packet.packet));
+    ASSERT_TRUE(packet.encrypted_buffer != nullptr);
+    ASSERT_TRUE(simple_framer_.ProcessPacket(
+        QuicEncryptedPacket(packet.encrypted_buffer, packet.encrypted_length)));
     EXPECT_EQ(1u, simple_framer_.num_frames());
     EXPECT_EQ(1u, simple_framer_.stream_frames().size());
   }
 
   void CheckAllPacketsHaveSingleStreamFrame() {
     for (size_t i = 0; i < packets_.size(); i++) {
       CheckPacketHasSingleStreamFrame(i);
     }
   }
 
   void CheckPacketIsFec(size_t packet_index, QuicPacketNumber fec_group) {
     ASSERT_GT(packets_.size(), packet_index);
     const SerializedPacket& packet = packets_[packet_index];
     ASSERT_TRUE(packet.retransmittable_frames.empty());
-    ASSERT_TRUE(packet.packet != nullptr);
-    ASSERT_TRUE(simple_framer_.ProcessPacket(*packet.packet));
+    ASSERT_TRUE(packet.encrypted_buffer != nullptr);
+    ASSERT_TRUE(simple_framer_.ProcessPacket(
+        QuicEncryptedPacket(packet.encrypted_buffer, packet.encrypted_length)));
     EXPECT_TRUE(simple_framer_.header().fec_flag);
   }
 
   QuicIOVector CreateData(size_t len) {
     data_array_.reset(new char[len]);
     memset(data_array_.get(), '?', len);
     iov_.iov_base = data_array_.get();
     iov_.iov_len = len;
     return QuicIOVector(&iov_, 1, len);
   }
@@ skipping 186 matching lines @@
       kCryptoStreamId, MakeIOVector("foo"), 0, false, MAY_FEC_PROTECT, 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());
-  EXPECT_EQ(kDefaultMaxPacketSize, packets_[0].packet->length());
+  EXPECT_EQ(kDefaultMaxPacketSize, packets_[0].encrypted_length);
 }
 
 TEST_P(QuicPacketGeneratorTest, ConsumeData_EmptyData) {
   EXPECT_DFATAL(generator_.ConsumeData(kHeadersStreamId, MakeIOVector(""), 0,
                                        false, MAY_FEC_PROTECT, nullptr),
                 "Attempt to consume empty data without FIN.");
 }
 
 TEST_P(QuicPacketGeneratorTest,
        ConsumeDataMultipleTimes_WritableAndShouldNotFlush) {
@@ skipping 979 matching lines @@
                              /*fin=*/true, MAY_FEC_PROTECT, nullptr);
   EXPECT_EQ(data_len, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
   EXPECT_FALSE(generator_.HasQueuedFrames());
 
   // We expect three packets, and first two of them have to be of packet_len
   // size.  We check multiple packets (instead of just one) because we want to
   // ensure that |max_packet_length_| does not get changed incorrectly by the
   // generator after first packet is serialized.
   ASSERT_EQ(3u, packets_.size());
-  EXPECT_EQ(packet_len, packets_[0].packet->length());
-  EXPECT_EQ(packet_len, packets_[1].packet->length());
+  EXPECT_EQ(packet_len, packets_[0].encrypted_length);
+  EXPECT_EQ(packet_len, packets_[1].encrypted_length);
   CheckAllPacketsHaveSingleStreamFrame();
 }
 
 // Test whether SetMaxPacketLength() works in the situation when we first write
 // data, then change packet size, then write data again.
 TEST_P(QuicPacketGeneratorTest, SetMaxPacketLength_Middle) {
   delegate_.SetCanWriteAnything();
 
   // We send enough data to overflow default packet length, but not the altered
   // one.
@@ skipping 26 matching lines @@
   consumed = generator_.ConsumeData(kHeadersStreamId, CreateData(data_len),
                                     2 + data_len,
                                     /*fin=*/true, MAY_FEC_PROTECT, nullptr);
   EXPECT_EQ(data_len, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
   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].packet->length());
-  EXPECT_LE(kDefaultMaxPacketSize, packets_[2].packet->length());
+  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_P(QuicPacketGeneratorTest, SetMaxPacketLength_Midpacket) {
   delegate_.SetCanWriteAnything();
   generator_.StartBatchOperations();
 
   size_t first_write_len = kDefaultMaxPacketSize / 2;
@@ skipping 30 matching lines @@
       generator_.ConsumeData(kHeadersStreamId, CreateData(second_write_len),
                              /*offset=*/2 + first_write_len,
                              /*fin=*/true, MAY_FEC_PROTECT, 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].packet->length());
+  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_P(QuicPacketGeneratorTest, SetMaxPacketLength_MidpacketFlush) {
   delegate_.SetCanWriteAnything();
@@ skipping 39 matching lines @@
       generator_.ConsumeData(kHeadersStreamId, CreateData(second_write_len),
                              /*offset=*/2 + first_write_len,
                              /*fin=*/true, MAY_FEC_PROTECT, nullptr);
   EXPECT_EQ(second_write_len, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
   EXPECT_TRUE(generator_.HasQueuedFrames());
 
   // We expect the first packet to be underfilled, and the second packet be up
   // to the new max packet size.
   ASSERT_EQ(2u, packets_.size());
-  EXPECT_GT(kDefaultMaxPacketSize, packets_[0].packet->length());
-  EXPECT_EQ(packet_len, packets_[1].packet->length());
+  EXPECT_GT(kDefaultMaxPacketSize, packets_[0].encrypted_length);
+  EXPECT_EQ(packet_len, packets_[1].encrypted_length);
 
   CheckAllPacketsHaveSingleStreamFrame();
 }
 
 // Test sending an MTU probe, without any surrounding data.
 TEST_P(QuicPacketGeneratorTest, GenerateMtuDiscoveryPacket_Simple) {
   delegate_.SetCanWriteAnything();
 
   const size_t target_mtu = kDefaultMaxPacketSize + 100;
   static_assert(target_mtu < kMaxPacketSize,
                 "The MTU probe used by the test exceeds maximum packet size");
 
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 
   generator_.GenerateMtuDiscoveryPacket(target_mtu, nullptr);
 
   EXPECT_FALSE(generator_.HasQueuedFrames());
   ASSERT_EQ(1u, packets_.size());
-  EXPECT_EQ(target_mtu, packets_[0].packet->length());
+  EXPECT_EQ(target_mtu, packets_[0].encrypted_length);
 
   PacketContents contents;
   contents.num_mtu_discovery_frames = 1;
   CheckPacketContains(contents, 0);
 }
 
 // Test sending an MTU probe.  Surround it with data, to ensure that it resets
 // the MTU to the value before the probe was sent.
 TEST_P(QuicPacketGeneratorTest, GenerateMtuDiscoveryPacket_SurroundedByData) {
   delegate_.SetCanWriteAnything();
@@ skipping 26 matching lines @@
 
   // Send data after the MTU probe.
   consumed = generator_.ConsumeData(kHeadersStreamId, CreateData(data_len),
                                     /*offset=*/2 + data_len,
                                     /*fin=*/true, MAY_FEC_PROTECT, nullptr);
   EXPECT_EQ(data_len, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
   EXPECT_FALSE(generator_.HasQueuedFrames());
 
   ASSERT_EQ(5u, packets_.size());
-  EXPECT_EQ(kDefaultMaxPacketSize, packets_[0].packet->length());
-  EXPECT_EQ(target_mtu, packets_[2].packet->length());
-  EXPECT_EQ(kDefaultMaxPacketSize, packets_[3].packet->length());
+  EXPECT_EQ(kDefaultMaxPacketSize, packets_[0].encrypted_length);
+  EXPECT_EQ(target_mtu, packets_[2].encrypted_length);
+  EXPECT_EQ(kDefaultMaxPacketSize, packets_[3].encrypted_length);
 
   PacketContents probe_contents;
   probe_contents.num_mtu_discovery_frames = 1;
 
   CheckPacketHasSingleStreamFrame(0);
   CheckPacketHasSingleStreamFrame(1);
   CheckPacketContains(probe_contents, 2);
   CheckPacketHasSingleStreamFrame(3);
   CheckPacketHasSingleStreamFrame(4);
 }
@@ skipping 49 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