chromium/net/third_party/quiche/src/quiche/quic/test_tools/simple_session_notifier.cc

// Copyright (c) 2018 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/test_tools/simple_session_notifier.h"

#include "quiche/quic/core/quic_utils.h"
#include "quiche/quic/platform/api/quic_logging.h"
#include "quiche/quic/test_tools/quic_test_utils.h"

namespace quic {

namespace test {

SimpleSessionNotifier::SimpleSessionNotifier(QuicConnection* connection)
    : … { … }

SimpleSessionNotifier::~SimpleSessionNotifier() { … }

SimpleSessionNotifier::StreamState::StreamState()
    : … { … }

SimpleSessionNotifier::StreamState::~StreamState() { … }

QuicConsumedData SimpleSessionNotifier::WriteOrBufferData(
    QuicStreamId id, QuicByteCount data_length, StreamSendingState state) { … }

QuicConsumedData SimpleSessionNotifier::WriteOrBufferData(
    QuicStreamId id, QuicByteCount data_length, StreamSendingState state,
    TransmissionType transmission_type) { … }

void SimpleSessionNotifier::OnStreamDataConsumed(QuicStreamId id,
                                                 QuicStreamOffset offset,
                                                 QuicByteCount data_length,
                                                 bool fin) { … }

size_t SimpleSessionNotifier::WriteCryptoData(EncryptionLevel level,
                                              QuicByteCount data_length,
                                              QuicStreamOffset offset) { … }

void SimpleSessionNotifier::WriteOrBufferRstStream(
    QuicStreamId id, QuicRstStreamErrorCode error,
    QuicStreamOffset bytes_written) { … }

void SimpleSessionNotifier::WriteOrBufferWindowUpate(
    QuicStreamId id, QuicStreamOffset byte_offset) { … }

void SimpleSessionNotifier::WriteOrBufferPing() { … }

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

void SimpleSessionNotifier::NeuterUnencryptedData() { … }

void SimpleSessionNotifier::OnCanWrite() { … }

void SimpleSessionNotifier::OnStreamReset(QuicStreamId id,
                                          QuicRstStreamErrorCode error) { … }

bool SimpleSessionNotifier::WillingToWrite() const { … }

QuicByteCount SimpleSessionNotifier::StreamBytesSent() const { … }

QuicByteCount SimpleSessionNotifier::StreamBytesToSend() const { … }

bool SimpleSessionNotifier::OnFrameAcked(const QuicFrame& frame,
                                         QuicTime::Delta /*ack_delay_time*/,
                                         QuicTime /*receive_timestamp*/) { … }

void SimpleSessionNotifier::OnFrameLost(const QuicFrame& frame) { … }

bool SimpleSessionNotifier::RetransmitFrames(const QuicFrames& frames,
                                             TransmissionType type) { … }

bool SimpleSessionNotifier::IsFrameOutstanding(const QuicFrame& frame) const { … }

bool SimpleSessionNotifier::HasUnackedCryptoData() const { … }

bool SimpleSessionNotifier::HasUnackedStreamData() const { … }

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

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

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

bool SimpleSessionNotifier::RetransmitLostControlFrames() { … }

bool SimpleSessionNotifier::RetransmitLostCryptoData() { … }

bool SimpleSessionNotifier::RetransmitLostStreamData() { … }

bool SimpleSessionNotifier::WriteBufferedCryptoData() { … }

bool SimpleSessionNotifier::WriteBufferedControlFrames() { … }

bool SimpleSessionNotifier::HasBufferedControlFrames() const { … }

bool SimpleSessionNotifier::HasBufferedStreamData() const { … }

bool SimpleSessionNotifier::StreamIsWaitingForAcks(QuicStreamId id) const { … }

bool SimpleSessionNotifier::StreamHasBufferedData(QuicStreamId id) const { … }

bool SimpleSessionNotifier::HasLostStreamData() const { … }

}  // namespace test

}  // namespace quic