chromium/net/third_party/quiche/src/quiche/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 "quiche/quic/core/quic_stream_sequencer_buffer.h"

#include <algorithm>
#include <cstddef>
#include <memory>
#include <string>
#include <utility>

#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "quiche/quic/core/quic_constants.h"
#include "quiche/quic/core/quic_interval.h"
#include "quiche/quic/platform/api/quic_bug_tracker.h"
#include "quiche/quic/platform/api/quic_flag_utils.h"
#include "quiche/quic/platform/api/quic_flags.h"
#include "quiche/quic/platform/api/quic_logging.h"

namespace quic {
namespace {

size_t CalculateBlockCount(size_t max_capacity_bytes) { … }

// Upper limit of how many gaps allowed in buffer, which ensures a reasonable
// number of iterations needed to find the right gap to fill when a frame
// arrives.
const size_t kMaxNumDataIntervalsAllowed = …;

// Number of blocks allocated initially.
constexpr size_t kInitialBlockCount = …;

// How fast block pointers container grow in size.
// Choose 4 to reduce the amount of reallocation.
constexpr int kBlocksGrowthFactor = …;

}  // namespace

QuicStreamSequencerBuffer::QuicStreamSequencerBuffer(size_t max_capacity_bytes)
    : … { … }

QuicStreamSequencerBuffer::~QuicStreamSequencerBuffer() { … }

void QuicStreamSequencerBuffer::Clear() { … }

bool QuicStreamSequencerBuffer::RetireBlock(size_t index) { … }

void QuicStreamSequencerBuffer::MaybeAddMoreBlocks(
    QuicStreamOffset next_expected_byte) { … }

QuicErrorCode QuicStreamSequencerBuffer::OnStreamData(
    QuicStreamOffset starting_offset, absl::string_view data,
    size_t* const bytes_buffered, std::string* error_details) { … }

bool QuicStreamSequencerBuffer::CopyStreamData(QuicStreamOffset offset,
                                               absl::string_view data,
                                               size_t* bytes_copy,
                                               std::string* error_details) { … }

QuicErrorCode QuicStreamSequencerBuffer::Readv(const iovec* dest_iov,
                                               size_t dest_count,
                                               size_t* bytes_read,
                                               std::string* error_details) { … }

int QuicStreamSequencerBuffer::GetReadableRegions(struct iovec* iov,
                                                  int iov_len) const { … }

bool QuicStreamSequencerBuffer::GetReadableRegion(iovec* iov) const { … }

bool QuicStreamSequencerBuffer::PeekRegion(QuicStreamOffset offset,
                                           iovec* iov) const { … }

bool QuicStreamSequencerBuffer::MarkConsumed(size_t bytes_consumed) { … }

size_t QuicStreamSequencerBuffer::FlushBufferedFrames() { … }

void QuicStreamSequencerBuffer::ReleaseWholeBuffer() { … }

size_t QuicStreamSequencerBuffer::ReadableBytes() const { … }

bool QuicStreamSequencerBuffer::HasBytesToRead() const { … }

QuicStreamOffset QuicStreamSequencerBuffer::BytesConsumed() const { … }

size_t QuicStreamSequencerBuffer::BytesBuffered() const { … }

size_t QuicStreamSequencerBuffer::GetBlockIndex(QuicStreamOffset offset) const { … }

size_t QuicStreamSequencerBuffer::GetInBlockOffset(
    QuicStreamOffset offset) const { … }

size_t QuicStreamSequencerBuffer::ReadOffset() const { … }

size_t QuicStreamSequencerBuffer::NextBlockToRead() const { … }

bool QuicStreamSequencerBuffer::RetireBlockIfEmpty(size_t block_index) { … }

bool QuicStreamSequencerBuffer::Empty() const { … }

size_t QuicStreamSequencerBuffer::GetBlockCapacity(size_t block_index) const { … }

std::string QuicStreamSequencerBuffer::ReceivedFramesDebugString() const { … }

QuicStreamOffset QuicStreamSequencerBuffer::FirstMissingByte() const { … }

QuicStreamOffset QuicStreamSequencerBuffer::NextExpectedByte() const { … }

}  //  namespace quic