spdy_stream_test_util.cc | Explore in Territory

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "net/spdy/spdy_stream_test_util.h"

#include <cstddef>
#include <string_view>
#include <utility>

#include "net/spdy/spdy_stream.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace net::test {

ClosingDelegate::ClosingDelegate(
    const base::WeakPtr<SpdyStream>& stream) : … { … }

ClosingDelegate::~ClosingDelegate() = default;

void ClosingDelegate::OnHeadersSent() { … }

void ClosingDelegate::OnEarlyHintsReceived(
    const quiche::HttpHeaderBlock& headers) { … }

void ClosingDelegate::OnHeadersReceived(
    const quiche::HttpHeaderBlock& response_headers) { … }

void ClosingDelegate::OnDataReceived(std::unique_ptr<SpdyBuffer> buffer) { … }

void ClosingDelegate::OnDataSent() { … }

void ClosingDelegate::OnTrailers(const quiche::HttpHeaderBlock& trailers) { … }

void ClosingDelegate::OnClose(int status) { … }

bool ClosingDelegate::CanGreaseFrameType() const { … }

NetLogSource ClosingDelegate::source_dependency() const { … }

StreamDelegateBase::StreamDelegateBase(const base::WeakPtr<SpdyStream>& stream)
    : … { … }

StreamDelegateBase::~StreamDelegateBase() = default;

void StreamDelegateBase::OnHeadersSent() { … }

void StreamDelegateBase::OnEarlyHintsReceived(
    const quiche::HttpHeaderBlock& headers) { … }

void StreamDelegateBase::OnHeadersReceived(
    const quiche::HttpHeaderBlock& response_headers) { … }

void StreamDelegateBase::OnDataReceived(std::unique_ptr<SpdyBuffer> buffer) { … }

void StreamDelegateBase::OnDataSent() { … }

void StreamDelegateBase::OnTrailers(const quiche::HttpHeaderBlock& trailers) { … }

void StreamDelegateBase::OnClose(int status) { … }

bool StreamDelegateBase::CanGreaseFrameType() const { … }

NetLogSource StreamDelegateBase::source_dependency() const { … }

int StreamDelegateBase::WaitForClose() { … }

std::string StreamDelegateBase::TakeReceivedData() { … }

std::string StreamDelegateBase::GetResponseHeaderValue(
    const std::string& name) const { … }

const LoadTimingInfo& StreamDelegateBase::GetLoadTimingInfo() { … }

StreamDelegateDoNothing::StreamDelegateDoNothing(
    const base::WeakPtr<SpdyStream>& stream)
    : … { … }

StreamDelegateDoNothing::~StreamDelegateDoNothing() = default;

StreamDelegateConsumeData::StreamDelegateConsumeData(
    const base::WeakPtr<SpdyStream>& stream)
    : … { … }

StreamDelegateConsumeData::~StreamDelegateConsumeData() = default;

void StreamDelegateConsumeData::OnDataReceived(
    std::unique_ptr<SpdyBuffer> buffer) { … }

StreamDelegateSendImmediate::StreamDelegateSendImmediate(
    const base::WeakPtr<SpdyStream>& stream,
    std::string_view data)
    : … { … }

StreamDelegateSendImmediate::~StreamDelegateSendImmediate() = default;

void StreamDelegateSendImmediate::OnHeadersReceived(
    const quiche::HttpHeaderBlock& response_headers) { … }

StreamDelegateWithBody::StreamDelegateWithBody(
    const base::WeakPtr<SpdyStream>& stream,
    std::string_view data)
    : … { … }

StreamDelegateWithBody::~StreamDelegateWithBody() = default;

void StreamDelegateWithBody::OnHeadersSent() { … }

StreamDelegateCloseOnHeaders::StreamDelegateCloseOnHeaders(
    const base::WeakPtr<SpdyStream>& stream)
    : … { … }

StreamDelegateCloseOnHeaders::~StreamDelegateCloseOnHeaders() = default;

void StreamDelegateCloseOnHeaders::OnHeadersReceived(
    const quiche::HttpHeaderBlock& response_headers) { … }

StreamDelegateDetectEOF::StreamDelegateDetectEOF(
    const base::WeakPtr<SpdyStream>& stream)
    : … { … }

StreamDelegateDetectEOF::~StreamDelegateDetectEOF() = default;

void StreamDelegateDetectEOF::OnDataReceived(
    std::unique_ptr<SpdyBuffer> buffer) { … }

}  // namespace net::test
chromium/net/spdy/spdy_stream_test_util.cc
