relnote: Refactor stream buffer allocation out into a scoped_ptr.

net/quic/quic_protocol.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_protocol.h"
 
 #include "base/stl_util.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
 
@@ skipping 73 matching lines @@
       is_in_fec_group(NOT_IN_FEC_GROUP),
       fec_group(0) {}
 
 QuicPublicResetPacket::QuicPublicResetPacket()
     : nonce_proof(0), rejected_packet_number(0) {}
 
 QuicPublicResetPacket::QuicPublicResetPacket(
     const QuicPacketPublicHeader& header)
     : public_header(header), nonce_proof(0), rejected_packet_number(0) {}
 
+UniqueStreamBuffer NewStreamBuffer(size_t size) {
+  return UniqueStreamBuffer(new char[size]);
+}
+
 QuicStreamFrame::QuicStreamFrame() : stream_id(0), fin(false), offset(0) {
 }
 
 QuicStreamFrame::QuicStreamFrame(const QuicStreamFrame& frame)
     : stream_id(frame.stream_id),
       fin(frame.fin),
       offset(frame.offset),
       data(frame.data) {
 }
 
@@ skipping 709 matching lines @@
       case WINDOW_UPDATE_FRAME:
         delete it->window_update_frame;
         break;
       case BLOCKED_FRAME:
         delete it->blocked_frame;
         break;
       case NUM_FRAME_TYPES:
         DCHECK(false) << "Cannot delete type: " << it->type;
     }
   }
+  // TODO(rtenneti): Delete the for loop once chrome has c++11 library support
+  // for "std::vector<UniqueStreamBuffer> stream_data_;".
   for (const char* buffer : stream_data_) {
     delete[] buffer;
   }
 }
 
 const QuicFrame& RetransmittableFrames::AddFrame(const QuicFrame& frame) {
   return AddFrame(frame, nullptr);
 }
 
 const QuicFrame& RetransmittableFrames::AddFrame(const QuicFrame& frame,
-                                                 char* buffer) {
+                                                 UniqueStreamBuffer buffer) {
   if (frame.type == STREAM_FRAME &&
       frame.stream_frame->stream_id == kCryptoStreamId) {
     has_crypto_handshake_ = IS_HANDSHAKE;
   }
   if (buffer != nullptr) {
-    stream_data_.push_back(buffer);
+    stream_data_.push_back(buffer.release());
   }
   frames_.push_back(frame);
   return frames_.back();
 }
 
 void RetransmittableFrames::RemoveFramesForStream(QuicStreamId stream_id) {
   QuicFrames::iterator it = frames_.begin();
   while (it != frames_.end()) {
     if (it->type != STREAM_FRAME || it->stream_frame->stream_id != stream_id) {
       ++it;
@@ skipping 58 matching lines @@
       sent_time(sent_time),
       bytes_sent(bytes_sent),
       nack_count(0),
       transmission_type(transmission_type),
       all_transmissions(nullptr),
       in_flight(false),
       is_unackable(false),
       is_fec_packet(is_fec_packet) {}
 
 }  // namespace net