rel-note: automated rollback of internal change 138108562

net/quic/core/quic_stream_sequencer_buffer.cc

 // 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.
 
 #include "net/quic/core/quic_stream_sequencer_buffer.h"
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
@@ skipping 31 matching lines @@
 
 QuicStreamSequencerBuffer::FrameInfo::FrameInfo(size_t length,
                                                 QuicTime timestamp)
     : length(length), timestamp(timestamp) {}
 
 QuicStreamSequencerBuffer::QuicStreamSequencerBuffer(size_t max_capacity_bytes)
     : max_buffer_capacity_bytes_(max_capacity_bytes),
       blocks_count_(
           ceil(static_cast<double>(max_capacity_bytes) / kBlockSizeBytes)),
       total_bytes_read_(0),
-      blocks_(nullptr),
+      reduce_sequencer_buffer_memory_life_time_(
+          FLAGS_quic_reduce_sequencer_buffer_memory_life_time),  // NOLINT
+      blocks_(reduce_sequencer_buffer_memory_life_time_
+                  ? nullptr
+                  : new BufferBlock*[blocks_count_]()),
       destruction_indicator_(123456) {
   CHECK_GT(blocks_count_, 1u)
       << "blocks_count_ = " << blocks_count_
       << ", max_buffer_capacity_bytes_ = " << max_buffer_capacity_bytes_;
   Clear();
 }
 
 QuicStreamSequencerBuffer::~QuicStreamSequencerBuffer() {
   Clear();
   destruction_indicator_ = 654321;
 }
 
 void QuicStreamSequencerBuffer::Clear() {
-  if (blocks_ != nullptr) {
+  if (!reduce_sequencer_buffer_memory_life_time_ || blocks_ != nullptr) {
     for (size_t i = 0; i < blocks_count_; ++i) {
       if (blocks_[i] != nullptr) {
         RetireBlock(i);
       }
     }
   }
   num_bytes_buffered_ = 0;
   // Reset gaps_ so that buffer is in a state as if all data before
   // total_bytes_read_ has been consumed, and those after total_bytes_read_
   // has never arrived.
@@ skipping 98 matching lines @@
 
     size_t block_capacity = GetBlockCapacity(write_block_num);
     size_t bytes_avail = block_capacity - write_block_offset;
 
     // If this write meets the upper boundary of the buffer,
     // reduce the available free bytes.
     if (offset + bytes_avail > total_bytes_read_ + max_buffer_capacity_bytes_) {
       bytes_avail = total_bytes_read_ + max_buffer_capacity_bytes_ - offset;
     }
 
-    if (blocks_ == nullptr) {
+    if (reduce_sequencer_buffer_memory_life_time_ && blocks_ == nullptr) {
       blocks_.reset(new BufferBlock*[blocks_count_]());
       for (size_t i = 0; i < blocks_count_; ++i) {
         blocks_[i] = nullptr;
       }
     }
 
     if (write_block_num >= blocks_count_) {
       *error_details = StringPrintf(
           "QuicStreamSequencerBuffer error: OnStreamData() exceed array bounds."
           "write offset = %" PRIu64 " write_block_num = %" PRIuS
@@ skipping 270 matching lines @@
 }
 
 size_t QuicStreamSequencerBuffer::FlushBufferedFrames() {
   size_t prev_total_bytes_read = total_bytes_read_;
   total_bytes_read_ = gaps_.back().begin_offset;
   Clear();
   return total_bytes_read_ - prev_total_bytes_read;
 }
 
 void QuicStreamSequencerBuffer::ReleaseWholeBuffer() {
+  if (!reduce_sequencer_buffer_memory_life_time_) {
+    // Don't release buffer if flag is off.
+    return;
+  }
   Clear();
   blocks_.reset(nullptr);
 }
 
 size_t QuicStreamSequencerBuffer::ReadableBytes() const {
   return gaps_.front().begin_offset - total_bytes_read_;
 }
 
 bool QuicStreamSequencerBuffer::HasBytesToRead() const {
   return ReadableBytes() > 0;
@@ skipping 111 matching lines @@
     QuicStreamOffset current_frame_end_offset =
         it.second.length + current_frame_begin_offset;
     current_frames_string = string(StringPrintf(
         "%s[%" PRIu64 ", %" PRIu64 ") ", current_frames_string.c_str(),
         current_frame_begin_offset, current_frame_end_offset));
   }
   return current_frames_string;
 }
 
 }  //  namespace net