rel-note: automated rollback of internal change 138108562

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_CORE_QUIC_STREAM_SEQUENCER_BUFFER_H_
 #define NET_QUIC_CORE_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 150 matching lines @@
 
   // 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.
   // Returns true on success, false otherwise.
   bool RetireBlock(size_t index);
 
   // Should only be called after the indexed block is read till the end of the
@@ skipping 49 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::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_;
 
   // For debugging use after free, assigned to 123456 in constructor and 654321
   // in destructor. As long as it's not 123456, this means either use after free
   // or memory corruption.
   int32_t destruction_indicator_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicStreamSequencerBuffer);
 };
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_QUIC_STREAM_SEQUENCER_BUFFER_H_