relnote: Refactor stream buffer allocation out into a scoped_ptr.

net/quic/quic_packet_generator.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 "base/basictypes.h"
 #include "base/logging.h"
 #include "net/quic/quic_ack_notifier.h"
 #include "net/quic/quic_fec_group.h"
@@ skipping 150 matching lines @@
 
   if (!fin && (iov.total_length == 0)) {
     LOG(DFATAL) << "Attempt to consume empty data without FIN.";
     return QuicConsumedData(0, false);
   }
 
   int frames_created = 0;
   while (delegate_->ShouldGeneratePacket(
       HAS_RETRANSMITTABLE_DATA, has_handshake ? IS_HANDSHAKE : NOT_HANDSHAKE)) {
     QuicFrame frame;
-    scoped_ptr<char[]> buffer;
+    UniqueStreamBuffer buffer;
     size_t bytes_consumed = packet_creator_.CreateStreamFrame(
         id, iov, total_bytes_consumed, offset + total_bytes_consumed, fin,
         &frame, &buffer);
     ++frames_created;
 
     // We want to track which packet this stream frame ends up in.
     if (notifier != nullptr) {
       ack_notifiers_.push_back(notifier);
     }
 
-    if (!AddFrame(frame, buffer.get(), has_handshake)) {
+    if (!AddFrame(frame, buffer.Pass(), has_handshake)) {
       LOG(DFATAL) << "Failed to add stream frame.";
       // Inability to add a STREAM frame creates an unrecoverable hole in a
       // the stream, so it's best to close the connection.
       delegate_->CloseConnection(QUIC_INTERNAL_ERROR, false);
       delete notifier;
       return QuicConsumedData(0, false);
     }
-    // When AddFrame succeeds, it takes ownership of the buffer.
-    ignore_result(buffer.release());
 
     total_bytes_consumed += bytes_consumed;
     fin_consumed = fin && total_bytes_consumed == iov.total_length;
     DCHECK(total_bytes_consumed == iov.total_length ||
            packet_creator_.BytesFree() == 0u);
 
     if (!InBatchMode() || !packet_creator_.HasRoomForStreamFrame(id, offset)) {
       // TODO(rtenneti): remove MaybeSendFecPacketAndCloseGroup() from inside
       // SerializeAndSendPacket() and make it an explicit call here (and
       // elsewhere where we call SerializeAndSendPacket?).
@@ skipping 233 matching lines @@
   if (!AddFrame(queued_control_frames_.back(), nullptr,
                 /*needs_padding=*/false)) {
     // Packet was full.
     return false;
   }
   queued_control_frames_.pop_back();
   return true;
 }
 
 bool QuicPacketGenerator::AddFrame(const QuicFrame& frame,
-                                   char* buffer,
+                                   UniqueStreamBuffer buffer,
                                    bool needs_padding) {
   bool success = needs_padding
-                     ? packet_creator_.AddPaddedSavedFrame(frame, buffer)
-                     : packet_creator_.AddSavedFrame(frame, buffer);
+                     ? packet_creator_.AddPaddedSavedFrame(frame, buffer.Pass())
+                     : packet_creator_.AddSavedFrame(frame, buffer.Pass());
   if (success && debug_delegate_) {
     debug_delegate_->OnFrameAddedToPacket(frame);
   }
   return success;
 }
 
 void QuicPacketGenerator::SerializeAndSendPacket() {
   // The optimized encryption algorithm implementations run faster when
   // operating on aligned memory.
   //
@@ skipping 95 matching lines @@
 void QuicPacketGenerator::set_encryption_level(EncryptionLevel level) {
   packet_creator_.set_encryption_level(level);
 }
 
 void QuicPacketGenerator::SetEncrypter(EncryptionLevel level,
                                        QuicEncrypter* encrypter) {
   packet_creator_.SetEncrypter(level, encrypter);
 }
 
 }  // namespace net