lazy allocation and early release memory in QuicStreamSequencerBuffer. Protected by --quic_reduce_s…

net/quic/core/quic_stream_sequencer_buffer.h

 // Copyright (c) 2015 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.
 
 #ifndef NET_QUIC_QUIC_STREAM_SEQUENCER_BUFFER_H_
 #define NET_QUIC_QUIC_STREAM_SEQUENCER_BUFFER_H_
 
 // QuicStreamSequencerBuffer implements QuicStreamSequencerBufferInterface.
 // It is a circular stream buffer with random write and
 // in-sequence read. It consists of a vector of pointers pointing
@@ skipping 134 matching lines @@
 
   // Called after GetReadableRegions() to free up |bytes_used| space if these
   // bytes are processed.
   // Pre-requisite: bytes_used <= available bytes to read.
   bool MarkConsumed(size_t bytes_buffered);
 
   // Deletes and records as consumed any buffered data and clear the buffer.
   // (To be called only after sequencer's StopReading has been called.)
   size_t FlushBufferedFrames();
 
+  // Free the memory of buffered data.
+  void ReleaseWholeBuffer();
+
   // Whether there are bytes can be read out.
   bool HasBytesToRead() const;
 
   // Count how many bytes have been consumed (read out of buffer).
   QuicStreamOffset BytesConsumed() const;
 
   // Count how many bytes are in buffer at this moment.
   size_t BytesBuffered() const;
 
+  bool reduce_sequencer_buffer_memory_life_time() const {
+    return reduce_sequencer_buffer_memory_life_time_;
+  }
+
  private:
   friend class test::QuicStreamSequencerBufferPeer;
 
   // Dispose the given buffer block.
   // After calling this method, blocks_[index] is set to nullptr
   // in order to indicate that no memory set is allocated for that block.
   void RetireBlock(size_t index);
 
   // Should only be called after the indexed block is read till the end of the
   // block or a gap has been reached.
@@ skipping 47 matching lines @@
 
   // How many blocks this buffer would need when it reaches full capacity.
   const size_t blocks_count_;
 
   // Number of bytes read out of buffer.
   QuicStreamOffset total_bytes_read_;
 
   // Contains Gaps which represents currently missing data.
   std::list<Gap> gaps_;
 
+  // If true, allocate buffer memory upon the first frame arrival and release
+  // the memory when stream is read closed.
+  bool reduce_sequencer_buffer_memory_life_time_;
+
   // An ordered, variable-length list of blocks, with the length limited
   // such that the number of blocks never exceeds blocks_count_.
   // Each list entry can hold up to kBlockSizeBytes bytes.
-  std::vector<BufferBlock*> blocks_;
+  std::unique_ptr<BufferBlock* []> blocks_;
 
   // Number of bytes in buffer.
   size_t num_bytes_buffered_;
 
   // Stores all the buffered frames' start offset, length and arrival time.
   std::map<QuicStreamOffset, FrameInfo> frame_arrival_time_map_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicStreamSequencerBuffer);
 };
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_STREAM_SEQUENCER_BUFFER_H_