Release read buffer of QuicCryptoStream when incoming message become less frequent. Protected by --…

net/quic/core/quic_stream_sequencer_buffer_test.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 <algorithm>
 #include <limits>
 #include <map>
 #include <string>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/rand_util.h"
 #include "net/quic/test_tools/mock_clock.h"
+#include "net/quic/test_tools/quic_stream_sequencer_buffer_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using std::min;
 using std::string;
 
 namespace net {
@@ skipping 22 matching lines @@
 }
 
 const size_t kMaxNumGapsAllowed = 2 * kMaxPacketGap;
 
 static const size_t kBlockSizeBytes =
     QuicStreamSequencerBuffer::kBlockSizeBytes;
 typedef QuicStreamSequencerBuffer::BufferBlock BufferBlock;
 typedef QuicStreamSequencerBuffer::Gap Gap;
 typedef QuicStreamSequencerBuffer::FrameInfo FrameInfo;
 
-class QuicStreamSequencerBufferPeer {
- public:
-  explicit QuicStreamSequencerBufferPeer(QuicStreamSequencerBuffer* buffer)
-      : buffer_(buffer) {}
-
-  // Read from this buffer_ into the given destination buffer_ up to the
-  // size of the destination. Returns the number of bytes read. Reading from
-  // an empty buffer_->returns 0.
-  size_t Read(char* dest_buffer, size_t size) {
-    iovec dest;
-    dest.iov_base = dest_buffer, dest.iov_len = size;
-    size_t bytes_read;
-    string error_details;
-    EXPECT_EQ(QUIC_NO_ERROR,
-              buffer_->Readv(&dest, 1, &bytes_read, &error_details));
-    return bytes_read;
-  }
-
-  // If buffer is empty, the blocks_ array must be empty, which means all
-  // blocks are deallocated.
-  bool CheckEmptyInvariants() {
-    return !buffer_->Empty() || IsBlockArrayEmpty();
-  }
-
-  bool IsBlockArrayEmpty() {
-    if (FLAGS_quic_reduce_sequencer_buffer_memory_life_time &&  // NOLINT
-        buffer_->blocks_ == nullptr) {
-      return true;
-    }
-
-    size_t count = buffer_->blocks_count_;
-    for (size_t i = 0; i < count; i++) {
-      if (buffer_->blocks_[i] != nullptr) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  bool CheckInitialState() {
-    EXPECT_TRUE(buffer_->Empty() && buffer_->total_bytes_read_ == 0 &&
-                buffer_->num_bytes_buffered_ == 0);
-    return CheckBufferInvariants();
-  }
-
-  bool CheckBufferInvariants() {
-    QuicStreamOffset data_span =
-        buffer_->gaps_.back().begin_offset - buffer_->total_bytes_read_;
-    bool capacity_sane = data_span <= buffer_->max_buffer_capacity_bytes_ &&
-                         data_span >= buffer_->num_bytes_buffered_;
-    if (!capacity_sane) {
-      LOG(ERROR) << "data span is larger than capacity.";
-      LOG(ERROR) << "total read: " << buffer_->total_bytes_read_
-                 << " last byte: " << buffer_->gaps_.back().begin_offset;
-    }
-    bool total_read_sane =
-        buffer_->gaps_.front().begin_offset >= buffer_->total_bytes_read_;
-    if (!total_read_sane) {
-      LOG(ERROR) << "read across 1st gap.";
-    }
-    bool read_offset_sane = buffer_->ReadOffset() < kBlockSizeBytes;
-    if (!capacity_sane) {
-      LOG(ERROR) << "read offset go beyond 1st block";
-    }
-    bool block_match_capacity =
-        (buffer_->max_buffer_capacity_bytes_ <=
-         buffer_->blocks_count_ * kBlockSizeBytes) &&
-        (buffer_->max_buffer_capacity_bytes_ >
-         (buffer_->blocks_count_ - 1) * kBlockSizeBytes);
-    if (!capacity_sane) {
-      LOG(ERROR) << "block number not match capcaity.";
-    }
-    bool block_retired_when_empty = CheckEmptyInvariants();
-    if (!block_retired_when_empty) {
-      LOG(ERROR) << "block is not retired after use.";
-    }
-    return capacity_sane && total_read_sane && read_offset_sane &&
-           block_match_capacity && block_retired_when_empty;
-  }
-
-  size_t GetInBlockOffset(QuicStreamOffset offset) {
-    return buffer_->GetInBlockOffset(offset);
-  }
-
-  BufferBlock* GetBlock(size_t index) { return buffer_->blocks_[index]; }
-
-  int GapSize() { return buffer_->gaps_.size(); }
-
-  std::list<Gap> GetGaps() { return buffer_->gaps_; }
-
-  size_t max_buffer_capacity() { return buffer_->max_buffer_capacity_bytes_; }
-
-  size_t ReadableBytes() { return buffer_->ReadableBytes(); }
-
-  std::map<QuicStreamOffset, FrameInfo>* frame_arrival_time_map() {
-    return &(buffer_->frame_arrival_time_map_);
-  }
-
-  void set_total_bytes_read(QuicStreamOffset total_bytes_read) {
-    buffer_->total_bytes_read_ = total_bytes_read;
-  }
-
-  void set_gaps(const std::list<Gap>& gaps) { buffer_->gaps_ = gaps; }
-
-  bool IsBufferAllocated() { return buffer_->blocks_ != nullptr; }
-
- private:
-  QuicStreamSequencerBuffer* buffer_;
-};
-
 namespace {
 
 class QuicStreamSequencerBufferTest : public testing::Test {
  public:
   void SetUp() override { Initialize(); }
 
   void ResetMaxCapacityBytes(size_t max_capacity_bytes) {
     max_capacity_bytes_ = max_capacity_bytes;
     Initialize();
   }
@@ skipping 987 matching lines @@
   EXPECT_LE(bytes_to_buffer_, total_bytes_read_) << "iterations: "
                                                  << iterations;
   EXPECT_LE(bytes_to_buffer_, total_bytes_written_);
 }
 
 }  // anonymous namespace
 
 }  // namespace test
 
 }  // namespace net