relnote: Refactor stream buffer allocation out into a scoped_ptr.

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/stl_util.h"
 #include "net/quic/crypto/null_encrypter.h"
@@ skipping 473 matching lines @@
     EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
   }
   ProcessPacket(serialized.packet);
   delete serialized.packet;
 }
 
 TEST_P(QuicPacketCreatorTest, ReserializeFramesWithPadding) {
   QuicFrame frame;
   QuicIOVector io_vector(MakeIOVector("fake handshake message data"));
-  scoped_ptr<char[]> stream_buffer;
+  UniqueStreamBuffer stream_buffer;
   creator_.CreateStreamFrame(kCryptoStreamId, io_vector, 0u, 0u, false, &frame,
                              &stream_buffer);
   RetransmittableFrames frames(ENCRYPTION_NONE);
   frames.AddFrame(frame);
   frames.set_needs_padding(true);
   char buffer[kMaxPacketSize];
   SerializedPacket serialized = creator_.ReserializeAllFrames(
       frames, QuicPacketCreatorPeer::NextPacketNumberLength(&creator_), buffer,
       kMaxPacketSize);
   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;
 
     QuicFrame frame;
     QuicIOVector io_vector(MakeIOVector(data));
-    scoped_ptr<char[]> stream_buffer;
+    UniqueStreamBuffer stream_buffer;
     creator_.CreateStreamFrame(kCryptoStreamId, io_vector, 0, kOffset, false,
                                &frame, &stream_buffer);
     RetransmittableFrames frames(ENCRYPTION_NONE);
     frames.AddFrame(frame);
     frames.set_needs_padding(true);
     char buffer[kMaxPacketSize];
     SerializedPacket serialized = creator_.ReserializeAllFrames(
         frames, QuicPacketCreatorPeer::NextPacketNumberLength(&creator_),
         buffer, kMaxPacketSize);
 
@@ skipping 87 matching lines @@
   creator_.StopFecProtectingPackets();
   EXPECT_FALSE(creator_.IsFecProtected());
   creator_.StartFecProtectingPackets();
   EXPECT_TRUE(creator_.IsFecProtected());
 }
 
 TEST_P(QuicPacketCreatorTest, SwitchFecOnWithStreamFrameQueued) {
   // Add a stream frame to the creator.
   QuicFrame frame;
   QuicIOVector io_vector(MakeIOVector("test"));
-  scoped_ptr<char[]> stream_buffer;
+  UniqueStreamBuffer stream_buffer;
   size_t consumed = creator_.CreateStreamFrame(1u, io_vector, 0u, 0u, false,
                                                &frame, &stream_buffer);
   EXPECT_EQ(4u, consumed);
   ASSERT_TRUE(frame.stream_frame);
   EXPECT_TRUE(creator_.AddSavedFrame(frame));
   EXPECT_TRUE(creator_.HasPendingFrames());
 
   // Enable FEC protection, and send FEC packet every 6 packets.
   creator_.set_max_packets_per_fec_group(6);
   EXPECT_TRUE(creator_.IsFecEnabled());
@@ skipping 10 matching lines @@
   EXPECT_FALSE(creator_.HasPendingFrames());
 
   // Since all pending frames have been serialized, turning FEC on should work.
   creator_.StartFecProtectingPackets();
   EXPECT_TRUE(creator_.IsFecProtected());
 }
 
 TEST_P(QuicPacketCreatorTest, CreateStreamFrame) {
   QuicFrame frame;
   QuicIOVector io_vector(MakeIOVector("test"));
-  scoped_ptr<char[]> stream_buffer;
+  UniqueStreamBuffer stream_buffer;
   size_t consumed = creator_.CreateStreamFrame(1u, io_vector, 0u, 0u, false,
                                                &frame, &stream_buffer);
   EXPECT_EQ(4u, consumed);
   CheckStreamFrame(frame, 1u, "test", 0u, false);
   RetransmittableFrames cleanup_frames(ENCRYPTION_NONE);
   cleanup_frames.AddFrame(frame);
 }
 
 TEST_P(QuicPacketCreatorTest, CreateStreamFrameFin) {
   QuicFrame frame;
   QuicIOVector io_vector(MakeIOVector("test"));
-  scoped_ptr<char[]> stream_buffer;
+  UniqueStreamBuffer stream_buffer;
   size_t consumed = creator_.CreateStreamFrame(1u, io_vector, 0u, 10u, true,
                                                &frame, &stream_buffer);
   EXPECT_EQ(4u, consumed);
   CheckStreamFrame(frame, 1u, "test", 10u, true);
   RetransmittableFrames cleanup_frames(ENCRYPTION_NONE);
   cleanup_frames.AddFrame(frame);
 }
 
 TEST_P(QuicPacketCreatorTest, CreateStreamFrameFinOnly) {
   QuicFrame frame;
   QuicIOVector io_vector(nullptr, 0, 0);
-  scoped_ptr<char[]> stream_buffer;
+  UniqueStreamBuffer stream_buffer;
   size_t consumed = creator_.CreateStreamFrame(1u, io_vector, 0u, 0u, true,
                                                &frame, &stream_buffer);
   EXPECT_EQ(0u, consumed);
   CheckStreamFrame(frame, 1u, string(), 0u, true);
   delete frame.stream_frame;
 }
 
 TEST_P(QuicPacketCreatorTest, CreateAllFreeBytesForStreamFrames) {
   const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP)
                           + GetEncryptionOverhead();
   for (size_t i = overhead; i < overhead + 100; ++i) {
     creator_.SetMaxPacketLength(i);
     const bool should_have_room = i > overhead + GetStreamFrameOverhead(
         NOT_IN_FEC_GROUP);
     ASSERT_EQ(should_have_room, creator_.HasRoomForStreamFrame(
                                     kClientDataStreamId1, kOffset));
     if (should_have_room) {
       QuicFrame frame;
       QuicIOVector io_vector(MakeIOVector("testdata"));
-      scoped_ptr<char[]> stream_buffer;
+      UniqueStreamBuffer stream_buffer;
       size_t bytes_consumed =
           creator_.CreateStreamFrame(kClientDataStreamId1, io_vector, 0u,
                                      kOffset, false, &frame, &stream_buffer);
       EXPECT_LT(0u, bytes_consumed);
       ASSERT_TRUE(creator_.AddSavedFrame(frame));
       char buffer[kMaxPacketSize];
       SerializedPacket serialized_packet =
           creator_.SerializePacket(buffer, kMaxPacketSize);
       ASSERT_TRUE(serialized_packet.packet);
       delete serialized_packet.packet;
       delete serialized_packet.retransmittable_frames;
     }
   }
 }
 
 TEST_P(QuicPacketCreatorTest, StreamFrameConsumption) {
   // 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);
   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));
-    scoped_ptr<char[]> stream_buffer;
+    UniqueStreamBuffer stream_buffer;
     size_t bytes_consumed =
         creator_.CreateStreamFrame(kClientDataStreamId1, io_vector, 0u, kOffset,
                                    false, &frame, &stream_buffer);
     EXPECT_EQ(capacity - bytes_free, bytes_consumed);
 
     ASSERT_TRUE(creator_.AddSavedFrame(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;
@@ skipping 13 matching lines @@
   // Compute the total overhead for a single frame in packet.
   const size_t overhead = GetPacketHeaderOverhead(IN_FEC_GROUP)
       + GetEncryptionOverhead() + GetStreamFrameOverhead(IN_FEC_GROUP);
   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));
-    scoped_ptr<char[]> stream_buffer;
+    UniqueStreamBuffer stream_buffer;
     size_t bytes_consumed =
         creator_.CreateStreamFrame(kClientDataStreamId1, io_vector, 0u, kOffset,
                                    false, &frame, &stream_buffer);
     EXPECT_EQ(capacity - bytes_free, bytes_consumed);
 
     ASSERT_TRUE(creator_.AddSavedFrame(frame));
     // BytesFree() returns bytes available for the next frame. Since stream
     // frame does not grow for FEC protected packets, this should be the same
     // as bytes_free (bound by 0).
     EXPECT_EQ(0u, creator_.ExpansionOnNewFrame());
@@ skipping 14 matching lines @@
       + 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));
-    scoped_ptr<char[]> stream_buffer;
+    UniqueStreamBuffer stream_buffer;
     size_t bytes_consumed = creator_.CreateStreamFrame(
         kCryptoStreamId, io_vector, 0u, kOffset, false, &frame, &stream_buffer);
     EXPECT_LT(0u, bytes_consumed);
     ASSERT_TRUE(creator_.AddPaddedSavedFrame(frame, nullptr));
     char buffer[kMaxPacketSize];
     SerializedPacket serialized_packet =
         creator_.SerializePacket(buffer, kMaxPacketSize);
     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
@@ skipping 15 matching lines @@
       + 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));
-    scoped_ptr<char[]> stream_buffer;
+    UniqueStreamBuffer stream_buffer;
     size_t bytes_consumed =
         creator_.CreateStreamFrame(kClientDataStreamId1, io_vector, 0u, kOffset,
                                    false, &frame, &stream_buffer);
     EXPECT_LT(0u, bytes_consumed);
     ASSERT_TRUE(creator_.AddSavedFrame(frame));
     char buffer[kMaxPacketSize];
     SerializedPacket serialized_packet =
         creator_.SerializePacket(buffer, kMaxPacketSize);
     ASSERT_TRUE(serialized_packet.packet);
     if (bytes_free > 0) {
@@ skipping 115 matching lines @@
   // A string larger than fits into a frame.
   size_t payload_length;
   creator_.SetMaxPacketLength(GetPacketLengthForOneStream(
       client_framer_.version(),
       QuicPacketCreatorPeer::SendVersionInPacket(&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));
-  scoped_ptr<char[]> stream_buffer;
+  UniqueStreamBuffer stream_buffer;
   size_t consumed = creator_.CreateStreamFrame(1u, io_vector, 0u, 0u, true,
                                                &frame, &stream_buffer);
   EXPECT_EQ(payload_length, consumed);
   const string payload(payload_length, 'a');
   CheckStreamFrame(frame, 1u, payload, 0u, false);
   RetransmittableFrames cleanup_frames(ENCRYPTION_NONE);
   cleanup_frames.AddFrame(frame);
 }
 
 TEST_P(QuicPacketCreatorTest, AddFrameAndSerialize) {
@@ skipping 10 matching lines @@
                     PACKET_1BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP),
             creator_.BytesFree());
 
   // Add a variety of frame types and then a padding frame.
   QuicAckFrame ack_frame(MakeAckFrame(0u));
   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
   EXPECT_TRUE(creator_.HasPendingFrames());
 
   QuicFrame frame;
   QuicIOVector io_vector(MakeIOVector("test"));
-  scoped_ptr<char[]> stream_buffer;
+  UniqueStreamBuffer stream_buffer;
   size_t consumed = creator_.CreateStreamFrame(1u, io_vector, 0u, 0u, false,
                                                &frame, &stream_buffer);
   EXPECT_EQ(4u, consumed);
   ASSERT_TRUE(frame.stream_frame);
   EXPECT_TRUE(creator_.AddSavedFrame(frame));
   EXPECT_TRUE(creator_.HasPendingFrames());
 
   QuicPaddingFrame padding_frame;
   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&padding_frame)));
   EXPECT_TRUE(creator_.HasPendingFrames());
@@ skipping 40 matching lines @@
 
   // Add ack frame to creator.
   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
   EXPECT_TRUE(creator_.HasPendingFrames());
   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;
   QuicIOVector io_vector(MakeIOVector("test"));
-  scoped_ptr<char[]> stream_buffer;
+  UniqueStreamBuffer stream_buffer;
   size_t consumed = creator_.CreateStreamFrame(2u, io_vector, 0u, 0u, false,
                                                &stream_frame, &stream_buffer);
   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_,
@@ skipping 125 matching lines @@
 
   serialized = creator_.SerializeFec(buffer, kMaxPacketSize);
   ASSERT_EQ(3u, serialized.packet_number);
   delete serialized.packet;
 }
 
 TEST_P(QuicPacketCreatorTest, ResetFecGroupWithQueuedFrames) {
   // Add a stream frame to the creator.
   QuicFrame frame;
   QuicIOVector io_vector(MakeIOVector("test"));
-  scoped_ptr<char[]> stream_buffer;
+  UniqueStreamBuffer stream_buffer;
   size_t consumed = creator_.CreateStreamFrame(1u, io_vector, 0u, 0u, false,
                                                &frame, &stream_buffer);
   EXPECT_EQ(4u, consumed);
   ASSERT_TRUE(frame.stream_frame);
   EXPECT_TRUE(creator_.AddSavedFrame(frame));
   EXPECT_TRUE(creator_.HasPendingFrames());
   EXPECT_DFATAL(creator_.ResetFecGroup(),
                 "Cannot reset FEC group with pending frames.");
 
   // Serialize packet for transmission.
   char buffer[kMaxPacketSize];
   SerializedPacket serialized =
       creator_.SerializePacket(buffer, kMaxPacketSize);
   delete serialized.packet;
   delete serialized.retransmittable_frames;
   EXPECT_FALSE(creator_.HasPendingFrames());
 
   // Close the FEC Group.
   creator_.ResetFecGroup();
   EXPECT_FALSE(creator_.IsFecGroupOpen());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net