relnote: Refactor stream buffer allocation out into a scoped_ptr.

net/quic/quic_packet_creator.h

 // 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.
 //
 // Accumulates frames for the next packet until more frames no longer fit or
 // it's time to create a packet from them.  Also provides packet creation of
 // FEC packets based on previously created packets.
 
 #ifndef NET_QUIC_QUIC_PACKET_CREATOR_H_
 #define NET_QUIC_QUIC_PACKET_CREATOR_H_
@@ skipping 71 matching lines @@
   // Returns the number of bytes consumed from data.
   // If data is empty and fin is true, the expected behavior is to consume the
   // fin but return 0.  If any data is consumed, it will be copied into a
   // new buffer that |frame| will point to and will be stored in |buffer|.
   size_t CreateStreamFrame(QuicStreamId id,
                            const QuicIOVector& iov,
                            size_t iov_offset,
                            QuicStreamOffset offset,
                            bool fin,
                            QuicFrame* frame,
-                           scoped_ptr<char[]>* buffer);
+                           UniqueStreamBuffer* buffer);
 
   // Serializes all frames into a single packet. All frames must fit into a
   // single packet. Also, sets the entropy hash of the serialized packet to a
   // random bool and returns that value as a member of SerializedPacket.
   // Never returns a RetransmittableFrames in SerializedPacket.
   SerializedPacket SerializeAllFrames(const QuicFrames& frames,
                                       char* buffer,
                                       size_t buffer_len);
 
   // Re-serializes frames with the original packet's packet number length.
@@ skipping 41 matching lines @@
   // in BytesFree.
   size_t PacketSize() const;
 
   // TODO(jri): AddSavedFrame calls AddFrame, which only saves the frame
   // if it is a stream frame, not other types of frames. Fix this API;
   // add a AddNonSavedFrame method.
   // Adds |frame| to the packet creator's list of frames to be serialized.
   // Returns false if the frame doesn't fit into the current packet.
   bool AddSavedFrame(const QuicFrame& frame);
 
-  // Identical to AddSavedFrame, but takes ownership of the buffer if it returns
-  // true.
-  bool AddSavedFrame(const QuicFrame& frame, char* buffer);
+  // Identical to AddSavedFrame, but takes ownership of the buffer.
+  bool AddSavedFrame(const QuicFrame& frame, UniqueStreamBuffer buffer);
 
-  // Identical to AddSavedFrame, but takes ownership of the buffer if it returns
-  // true, and allows to cause the packet to be padded.
-  bool AddPaddedSavedFrame(const QuicFrame& frame, char* buffer);
+  // Identical to AddSavedFrame, but takes ownership of the buffer, and allows
+  // to cause the packet to be padded.
+  bool AddPaddedSavedFrame(const QuicFrame& frame, UniqueStreamBuffer buffer);
 
   // Serializes all frames which have been added and adds any which should be
   // retransmitted to |retransmittable_frames| if it's not nullptr. All frames
   // must fit into a single packet. Sets the entropy hash of the serialized
   // packet to a random bool and returns that value as a member of
   // SerializedPacket. Also, sets |serialized_frames| in the SerializedPacket to
   // the corresponding RetransmittableFrames if any frames are to be
   // retransmitted.
   // Fails if |buffer_len| isn't long enough for the encrypted packet.
   SerializedPacket SerializePacket(char* encrypted_buffer, size_t buffer_len);
@@ skipping 86 matching lines @@
 
   void FillPacketHeader(QuicFecGroupNumber fec_group,
                         bool fec_flag,
                         QuicPacketHeader* header);
 
   // Allows a frame to be added without creating retransmittable frames.
   // Particularly useful for retransmits using SerializeAllFrames().
   bool AddFrame(const QuicFrame& frame,
                 bool save_retransmittable_frames,
                 bool needs_padding,
-                char* buffer);
+                UniqueStreamBuffer buffer);
 
   // Adds a padding frame to the current packet only if the current packet
   // contains a handshake message, and there is sufficient room to fit a
   // padding frame.
   void MaybeAddPadding();
 
   QuicConnectionId connection_id_;
   EncryptionLevel encryption_level_;
   QuicFramer* framer_;
   scoped_ptr<QuicRandomBoolSource> random_bool_source_;
@@ skipping 28 matching lines @@
   scoped_ptr<RetransmittableFrames> queued_retransmittable_frames_;
   // If true, the packet will be padded up to |max_packet_length_|.
   bool needs_padding_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicPacketCreator);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PACKET_CREATOR_H_