chromium/net/third_party/quiche/src/quiche/quic/core/quic_stream_send_buffer.cc

// Copyright (c) 2017 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_send_buffer.h"

#include <algorithm>
#include <utility>

#include "quiche/quic/core/quic_data_writer.h"
#include "quiche/quic/core/quic_interval.h"
#include "quiche/quic/core/quic_utils.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"
#include "quiche/common/platform/api/quiche_mem_slice.h"

namespace quic {

namespace {

struct CompareOffset { … };

}  // namespace

BufferedSlice::BufferedSlice(quiche::QuicheMemSlice mem_slice,
                             QuicStreamOffset offset)
    : … { … }

BufferedSlice::BufferedSlice(BufferedSlice&& other) = default;

BufferedSlice& BufferedSlice::operator=(BufferedSlice&& other) = default;

BufferedSlice::~BufferedSlice() { … }

QuicInterval<std::size_t> BufferedSlice::interval() const { … }

bool StreamPendingRetransmission::operator==(
    const StreamPendingRetransmission& other) const { … }

QuicStreamSendBuffer::QuicStreamSendBuffer(
    quiche::QuicheBufferAllocator* allocator)
    : … { … }

QuicStreamSendBuffer::~QuicStreamSendBuffer() { … }

void QuicStreamSendBuffer::SaveStreamData(absl::string_view data) { … }

void QuicStreamSendBuffer::SaveMemSlice(quiche::QuicheMemSlice slice) { … }

QuicByteCount QuicStreamSendBuffer::SaveMemSliceSpan(
    absl::Span<quiche::QuicheMemSlice> span) { … }

void QuicStreamSendBuffer::OnStreamDataConsumed(size_t bytes_consumed) { … }

bool QuicStreamSendBuffer::WriteStreamData(QuicStreamOffset offset,
                                           QuicByteCount data_length,
                                           QuicDataWriter* writer) { … }

bool QuicStreamSendBuffer::OnStreamDataAcked(
    QuicStreamOffset offset, QuicByteCount data_length,
    QuicByteCount* newly_acked_length) { … }

void QuicStreamSendBuffer::OnStreamDataLost(QuicStreamOffset offset,
                                            QuicByteCount data_length) { … }

void QuicStreamSendBuffer::OnStreamDataRetransmitted(
    QuicStreamOffset offset, QuicByteCount data_length) { … }

bool QuicStreamSendBuffer::HasPendingRetransmission() const { … }

StreamPendingRetransmission QuicStreamSendBuffer::NextPendingRetransmission()
    const { … }

bool QuicStreamSendBuffer::FreeMemSlices(QuicStreamOffset start,
                                         QuicStreamOffset end) { … }

void QuicStreamSendBuffer::CleanUpBufferedSlices() { … }

bool QuicStreamSendBuffer::IsStreamDataOutstanding(
    QuicStreamOffset offset, QuicByteCount data_length) const { … }

size_t QuicStreamSendBuffer::size() const { … }

}  // namespace quic