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

#include <string>

#include "absl/strings/str_cat.h"
#include "quiche/quic/core/frames/quic_ack_frequency_frame.h"
#include "quiche/quic/core/frames/quic_frame.h"
#include "quiche/quic/core/frames/quic_new_connection_id_frame.h"
#include "quiche/quic/core/frames/quic_retire_connection_id_frame.h"
#include "quiche/quic/core/quic_constants.h"
#include "quiche/quic/core/quic_session.h"
#include "quiche/quic/core/quic_types.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"

namespace quic {

namespace {

// The maximum number of buffered control frames which are waiting to be ACKed
// or sent for the first time.
const size_t kMaxNumControlFrames = …;

}  // namespace

QuicControlFrameManager::QuicControlFrameManager(QuicSession* session)
    : … { … }

QuicControlFrameManager::~QuicControlFrameManager() { … }

void QuicControlFrameManager::WriteOrBufferQuicFrame(QuicFrame frame) { … }

void QuicControlFrameManager::WriteOrBufferRstStream(
    QuicStreamId id, QuicResetStreamError error,
    QuicStreamOffset bytes_written) { … }

void QuicControlFrameManager::WriteOrBufferGoAway(
    QuicErrorCode error, QuicStreamId last_good_stream_id,
    const std::string& reason) { … }

void QuicControlFrameManager::WriteOrBufferWindowUpdate(
    QuicStreamId id, QuicStreamOffset byte_offset) { … }

void QuicControlFrameManager::WriteOrBufferBlocked(
    QuicStreamId id, QuicStreamOffset byte_offset) { … }

void QuicControlFrameManager::WriteOrBufferStreamsBlocked(QuicStreamCount count,
                                                          bool unidirectional) { … }

void QuicControlFrameManager::WriteOrBufferMaxStreams(QuicStreamCount count,
                                                      bool unidirectional) { … }

void QuicControlFrameManager::WriteOrBufferStopSending(
    QuicResetStreamError error, QuicStreamId stream_id) { … }

void QuicControlFrameManager::WriteOrBufferHandshakeDone() { … }

void QuicControlFrameManager::WriteOrBufferAckFrequency(
    const QuicAckFrequencyFrame& ack_frequency_frame) { … }

void QuicControlFrameManager::WriteOrBufferNewConnectionId(
    const QuicConnectionId& connection_id, uint64_t sequence_number,
    uint64_t retire_prior_to,
    const StatelessResetToken& stateless_reset_token) { … }

void QuicControlFrameManager::WriteOrBufferRetireConnectionId(
    uint64_t sequence_number) { … }

void QuicControlFrameManager::WriteOrBufferNewToken(absl::string_view token) { … }

void QuicControlFrameManager::OnControlFrameSent(const QuicFrame& frame) { … }

bool QuicControlFrameManager::OnControlFrameAcked(const QuicFrame& frame) { … }

void QuicControlFrameManager::OnControlFrameLost(const QuicFrame& frame) { … }

bool QuicControlFrameManager::IsControlFrameOutstanding(
    const QuicFrame& frame) const { … }

bool QuicControlFrameManager::HasPendingRetransmission() const { … }

bool QuicControlFrameManager::WillingToWrite() const { … }

size_t QuicControlFrameManager::NumBufferedMaxStreams() const { … }

QuicFrame QuicControlFrameManager::NextPendingRetransmission() const { … }

void QuicControlFrameManager::OnCanWrite() { … }

bool QuicControlFrameManager::RetransmitControlFrame(const QuicFrame& frame,
                                                     TransmissionType type) { … }

void QuicControlFrameManager::WriteBufferedFrames() { … }

void QuicControlFrameManager::WritePendingRetransmission() { … }

bool QuicControlFrameManager::OnControlFrameIdAcked(QuicControlFrameId id) { … }

bool QuicControlFrameManager::HasBufferedFrames() const { … }

}  // namespace quic