Run clang-format on some of the QUIC files.
PiperOrigin-RevId: 396579083
diff --git a/quic/core/http/quic_spdy_server_stream_base_test.cc b/quic/core/http/quic_spdy_server_stream_base_test.cc
index fe630de..41dfe71 100644
--- a/quic/core/http/quic_spdy_server_stream_base_test.cc
+++ b/quic/core/http/quic_spdy_server_stream_base_test.cc
@@ -19,8 +19,7 @@
class TestQuicSpdyServerStream : public QuicSpdyServerStreamBase {
public:
- TestQuicSpdyServerStream(QuicStreamId id,
- QuicSpdySession* session,
+ TestQuicSpdyServerStream(QuicStreamId id, QuicSpdySession* session,
StreamType type)
: QuicSpdyServerStreamBase(id, session, type) {}
@@ -30,8 +29,7 @@
class QuicSpdyServerStreamBaseTest : public QuicTest {
protected:
QuicSpdyServerStreamBaseTest()
- : session_(new MockQuicConnection(&helper_,
- &alarm_factory_,
+ : session_(new MockQuicConnection(&helper_, &alarm_factory_,
Perspective::IS_SERVER)) {
session_.Initialize();
session_.connection()->SetEncrypter(
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index c19dc3c..40ee645 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -177,8 +177,7 @@
class TestStream : public QuicSpdyStream {
public:
- TestStream(QuicStreamId id,
- QuicSpdySession* session,
+ TestStream(QuicStreamId id, QuicSpdySession* session,
bool should_process_data)
: QuicSpdyStream(id, session, BIDIRECTIONAL),
should_process_data_(should_process_data),
@@ -203,8 +202,7 @@
MOCK_METHOD(void, WriteHeadersMock, (bool fin), ());
- size_t WriteHeadersImpl(spdy::SpdyHeaderBlock header_block,
- bool fin,
+ size_t WriteHeadersImpl(spdy::SpdyHeaderBlock header_block, bool fin,
QuicReferenceCountedPointer<QuicAckListenerInterface>
/*ack_listener*/) override {
saved_headers_ = std::move(header_block);
@@ -226,8 +224,7 @@
return QuicStream::sequencer();
}
- void OnStreamHeaderList(bool fin,
- size_t frame_len,
+ void OnStreamHeaderList(bool fin, size_t frame_len,
const QuicHeaderList& header_list) override {
headers_payload_length_ = frame_len;
QuicSpdyStream::OnStreamHeaderList(fin, frame_len, header_list);
@@ -280,8 +277,7 @@
spdy::SpdyStreamPrecedence(QuicStream::kDefaultPriority)) {}
void UpdateStreamPriority(
- QuicStreamId id,
- const spdy::SpdyStreamPrecedence& precedence) override {
+ QuicStreamId id, const spdy::SpdyStreamPrecedence& precedence) override {
EXPECT_EQ(id, expected_stream_->id());
EXPECT_EQ(expected_precedence_, precedence);
EXPECT_EQ(expected_precedence_, expected_stream_->precedence());
@@ -491,8 +487,7 @@
SpdyHeaderBlock headers_;
};
-INSTANTIATE_TEST_SUITE_P(Tests,
- QuicSpdyStreamTest,
+INSTANTIATE_TEST_SUITE_P(Tests, QuicSpdyStreamTest,
::testing::ValuesIn(AllSupportedVersions()),
::testing::PrintToStringParamName());
@@ -2575,8 +2570,7 @@
QuicStreamOffset consumed_bytes_;
};
-INSTANTIATE_TEST_SUITE_P(Tests,
- QuicSpdyStreamIncrementalConsumptionTest,
+INSTANTIATE_TEST_SUITE_P(Tests, QuicSpdyStreamIncrementalConsumptionTest,
::testing::ValuesIn(AllSupportedVersions()),
::testing::PrintToStringParamName());
diff --git a/quic/core/quic_control_frame_manager.cc b/quic/core/quic_control_frame_manager.cc
index 4286249..afcdabc 100644
--- a/quic/core/quic_control_frame_manager.cc
+++ b/quic/core/quic_control_frame_manager.cc
@@ -59,8 +59,7 @@
}
void QuicControlFrameManager::WriteOrBufferRstStream(
- QuicStreamId id,
- QuicRstStreamErrorCode error,
+ QuicStreamId id, QuicRstStreamErrorCode error,
QuicStreamOffset bytes_written) {
QUIC_DVLOG(1) << "Writing RST_STREAM_FRAME";
WriteOrBufferQuicFrame((QuicFrame(new QuicRstStreamFrame(
@@ -68,8 +67,7 @@
}
void QuicControlFrameManager::WriteOrBufferGoAway(
- QuicErrorCode error,
- QuicStreamId last_good_stream_id,
+ QuicErrorCode error, QuicStreamId last_good_stream_id,
const std::string& reason) {
QUIC_DVLOG(1) << "Writing GOAWAY_FRAME";
WriteOrBufferQuicFrame(QuicFrame(new QuicGoAwayFrame(
@@ -77,8 +75,7 @@
}
void QuicControlFrameManager::WriteOrBufferWindowUpdate(
- QuicStreamId id,
- QuicStreamOffset byte_offset) {
+ QuicStreamId id, QuicStreamOffset byte_offset) {
QUIC_DVLOG(1) << "Writing WINDOW_UPDATE_FRAME";
WriteOrBufferQuicFrame(QuicFrame(
new QuicWindowUpdateFrame(++last_control_frame_id_, id, byte_offset)));
@@ -107,8 +104,7 @@
}
void QuicControlFrameManager::WriteOrBufferStopSending(
- QuicRstStreamErrorCode code,
- QuicStreamId stream_id) {
+ QuicRstStreamErrorCode code, QuicStreamId stream_id) {
QUIC_DVLOG(1) << "Writing STOP_SENDING_FRAME";
WriteOrBufferQuicFrame(QuicFrame(
new QuicStopSendingFrame(++last_control_frame_id_, stream_id, code)));
@@ -134,8 +130,7 @@
}
void QuicControlFrameManager::WriteOrBufferNewConnectionId(
- const QuicConnectionId& connection_id,
- uint64_t sequence_number,
+ const QuicConnectionId& connection_id, uint64_t sequence_number,
uint64_t retire_prior_to,
const StatelessResetToken& stateless_reset_token) {
QUIC_DVLOG(1) << "Writing NEW_CONNECTION_ID frame";
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 2912b3d..ad373e3 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -59,22 +59,14 @@
(perspective() == Perspective::IS_SERVER ? "Server: " : "Client: ")
QuicSession::QuicSession(
- QuicConnection* connection,
- Visitor* owner,
- const QuicConfig& config,
+ QuicConnection* connection, Visitor* owner, const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
QuicStreamCount num_expected_unidirectional_static_streams)
- : QuicSession(connection,
- owner,
- config,
- supported_versions,
- num_expected_unidirectional_static_streams,
- nullptr) {}
+ : QuicSession(connection, owner, config, supported_versions,
+ num_expected_unidirectional_static_streams, nullptr) {}
QuicSession::QuicSession(
- QuicConnection* connection,
- Visitor* owner,
- const QuicConfig& config,
+ QuicConnection* connection, Visitor* owner, const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
QuicStreamCount num_expected_unidirectional_static_streams,
std::unique_ptr<QuicDatagramQueue::Observer> datagram_observer)
@@ -83,14 +75,10 @@
visitor_(owner),
write_blocked_streams_(connection->transport_version()),
config_(config),
- stream_id_manager_(perspective(),
- connection->transport_version(),
+ stream_id_manager_(perspective(), connection->transport_version(),
kDefaultMaxStreamsPerConnection,
config_.GetMaxBidirectionalStreamsToSend()),
- ietf_streamid_manager_(perspective(),
- connection->version(),
- this,
- 0,
+ ietf_streamid_manager_(perspective(), connection->version(), this, 0,
num_expected_unidirectional_static_streams,
config_.GetMaxBidirectionalStreamsToSend(),
config_.GetMaxUnidirectionalStreamsToSend() +
@@ -100,15 +88,13 @@
num_static_streams_(0),
num_zombie_streams_(0),
flow_controller_(
- this,
- QuicUtils::GetInvalidStreamId(connection->transport_version()),
+ this, QuicUtils::GetInvalidStreamId(connection->transport_version()),
/*is_connection_flow_controller*/ true,
connection->version().AllowsLowFlowControlLimits()
? 0
: kMinimumFlowControlSendWindow,
config_.GetInitialSessionFlowControlWindowToSend(),
- kSessionReceiveWindowLimit,
- perspective() == Perspective::IS_SERVER,
+ kSessionReceiveWindowLimit, perspective() == Perspective::IS_SERVER,
nullptr),
currently_writing_stream_id_(0),
transport_goaway_sent_(false),
@@ -489,9 +475,7 @@
void QuicSession::OnForwardProgressMadeAfterPathDegrading() {}
-bool QuicSession::AllowSelfAddressChange() const {
- return false;
-}
+bool QuicSession::AllowSelfAddressChange() const { return false; }
void QuicSession::OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) {
// Stream may be closed by the time we receive a WINDOW_UPDATE, so we can't
@@ -814,8 +798,7 @@
return data;
}
-size_t QuicSession::SendCryptoData(EncryptionLevel level,
- size_t write_length,
+size_t QuicSession::SendCryptoData(EncryptionLevel level, size_t write_length,
QuicStreamOffset offset,
TransmissionType type) {
QUICHE_DCHECK(QuicVersionUsesCryptoFrames(transport_version()));
@@ -962,8 +945,7 @@
}
void QuicSession::InsertLocallyClosedStreamsHighestOffset(
- const QuicStreamId id,
- QuicStreamOffset offset) {
+ const QuicStreamId id, QuicStreamOffset offset) {
locally_closed_streams_highest_offset_[id] = offset;
}
@@ -1052,8 +1034,7 @@
}
void QuicSession::OnFinalByteOffsetReceived(
- QuicStreamId stream_id,
- QuicStreamOffset final_byte_offset) {
+ QuicStreamId stream_id, QuicStreamOffset final_byte_offset) {
auto it = locally_closed_streams_highest_offset_.find(stream_id);
if (it == locally_closed_streams_highest_offset_.end()) {
return;
@@ -1314,8 +1295,7 @@
}
absl::optional<std::string> QuicSession::OnAlpsData(
- const uint8_t* /*alps_data*/,
- size_t /*alps_length*/) {
+ const uint8_t* /*alps_data*/, size_t /*alps_length*/) {
return absl::nullopt;
}
@@ -1543,10 +1523,8 @@
}
bool QuicSession::OnNewDecryptionKeyAvailable(
- EncryptionLevel level,
- std::unique_ptr<QuicDecrypter> decrypter,
- bool set_alternative_decrypter,
- bool latch_once_used) {
+ EncryptionLevel level, std::unique_ptr<QuicDecrypter> decrypter,
+ bool set_alternative_decrypter, bool latch_once_used) {
if (connection_->version().handshake_protocol == PROTOCOL_TLS1_3 &&
!connection()->framer().HasEncrypterOfEncryptionLevel(
QuicUtils::GetEncryptionLevel(
@@ -1569,8 +1547,7 @@
}
void QuicSession::OnNewEncryptionKeyAvailable(
- EncryptionLevel level,
- std::unique_ptr<QuicEncrypter> encrypter) {
+ EncryptionLevel level, std::unique_ptr<QuicEncrypter> encrypter) {
connection()->SetEncrypter(level, std::move(encrypter));
if (connection_->version().handshake_protocol != PROTOCOL_TLS1_3) {
return;
@@ -1737,8 +1714,7 @@
}
QuicErrorCode QuicSession::ProcessTransportParameters(
- const TransportParameters& params,
- bool is_resumption,
+ const TransportParameters& params, bool is_resumption,
std::string* error_details) {
return config_.ProcessTransportParameters(params, is_resumption,
error_details);
@@ -1766,8 +1742,7 @@
const CryptoHandshakeMessage& /*message*/) {}
void QuicSession::RegisterStreamPriority(
- QuicStreamId id,
- bool is_static,
+ QuicStreamId id, bool is_static,
const spdy::SpdyStreamPrecedence& precedence) {
write_blocked_streams()->RegisterStream(id, is_static, precedence);
}
@@ -1777,14 +1752,11 @@
}
void QuicSession::UpdateStreamPriority(
- QuicStreamId id,
- const spdy::SpdyStreamPrecedence& new_precedence) {
+ QuicStreamId id, const spdy::SpdyStreamPrecedence& new_precedence) {
write_blocked_streams()->UpdateStreamPriority(id, new_precedence);
}
-QuicConfig* QuicSession::config() {
- return &config_;
-}
+QuicConfig* QuicSession::config() { return &config_; }
void QuicSession::ActivateStream(std::unique_ptr<QuicStream> stream) {
QuicStreamId stream_id = stream->id();
@@ -1995,8 +1967,7 @@
}
bool QuicSession::MaybeSetStreamPriority(
- QuicStreamId stream_id,
- const spdy::SpdyStreamPrecedence& precedence) {
+ QuicStreamId stream_id, const spdy::SpdyStreamPrecedence& precedence) {
auto active_stream = stream_map_.find(stream_id);
if (active_stream != stream_map_.end()) {
active_stream->second->SetPriority(precedence);
@@ -2474,9 +2445,7 @@
<< " is considered lost";
}
-void QuicSession::CleanUpClosedStreams() {
- closed_streams_.clear();
-}
+void QuicSession::CleanUpClosedStreams() { closed_streams_.clear(); }
QuicPacketLength QuicSession::GetCurrentLargestMessagePayload() const {
return connection_->GetCurrentLargestMessagePayload();
@@ -2597,8 +2566,7 @@
bool QuicSession::MigratePath(const QuicSocketAddress& self_address,
const QuicSocketAddress& peer_address,
- QuicPacketWriter* writer,
- bool owns_writer) {
+ QuicPacketWriter* writer, bool owns_writer) {
return connection_->MigratePath(self_address, peer_address, writer,
owns_writer);
}
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 7fc0a80..431824b 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -97,13 +97,11 @@
};
// Does not take ownership of |connection| or |visitor|.
- QuicSession(QuicConnection* connection,
- Visitor* owner,
+ QuicSession(QuicConnection* connection, Visitor* owner,
const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
QuicStreamCount num_expected_unidirectional_static_streams);
- QuicSession(QuicConnection* connection,
- Visitor* owner,
+ QuicSession(QuicConnection* connection, Visitor* owner,
const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
QuicStreamCount num_expected_unidirectional_static_streams,
@@ -183,14 +181,12 @@
QuicStreamOffset offset,
QuicByteCount data_length,
QuicDataWriter* writer) override;
- bool WriteCryptoData(EncryptionLevel level,
- QuicStreamOffset offset,
+ bool WriteCryptoData(EncryptionLevel level, QuicStreamOffset offset,
QuicByteCount data_length,
QuicDataWriter* writer) override;
// SessionNotifierInterface methods:
- bool OnFrameAcked(const QuicFrame& frame,
- QuicTime::Delta ack_delay_time,
+ bool OnFrameAcked(const QuicFrame& frame, QuicTime::Delta ack_delay_time,
QuicTime receive_timestamp) override;
void OnStreamFrameRetransmitted(const QuicStreamFrame& frame) override;
void OnFrameLost(const QuicFrame& frame) override;
@@ -299,8 +295,7 @@
bool set_alternative_decrypter,
bool latch_once_used) override;
void OnNewEncryptionKeyAvailable(
- EncryptionLevel level,
- std::unique_ptr<QuicEncrypter> encrypter) override;
+ EncryptionLevel level, std::unique_ptr<QuicEncrypter> encrypter) override;
void SetDefaultEncryptionLevel(EncryptionLevel level) override;
void OnTlsHandshakeComplete() override;
void DiscardOldDecryptionKey(EncryptionLevel level) override;
@@ -323,8 +318,7 @@
std::string error_details) override;
// Sets priority in the write blocked list.
void RegisterStreamPriority(
- QuicStreamId id,
- bool is_static,
+ QuicStreamId id, bool is_static,
const spdy::SpdyStreamPrecedence& precedence) override;
// Clears priority from the write blocked list.
void UnregisterStreamPriority(QuicStreamId id, bool is_static) override;
@@ -343,8 +337,7 @@
TransmissionType type,
EncryptionLevel level) override;
- size_t SendCryptoData(EncryptionLevel level,
- size_t write_length,
+ size_t SendCryptoData(EncryptionLevel level, size_t write_length,
QuicStreamOffset offset,
TransmissionType type) override;
@@ -466,8 +459,7 @@
// Switch to the path described in |context| without validating the path.
bool MigratePath(const QuicSocketAddress& self_address,
const QuicSocketAddress& peer_address,
- QuicPacketWriter* writer,
- bool owns_writer);
+ QuicPacketWriter* writer, bool owns_writer);
// Returns the largest payload that will fit into a single MESSAGE frame.
// Because overhead can vary during a connection, this method should be
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index 8654ebf..b50f7d0 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -119,8 +119,7 @@
stream_bytes_read_(0),
fin_received_(false),
connection_flow_controller_(session->flow_controller()),
- flow_controller_(session,
- id,
+ flow_controller_(session, id,
/*is_connection_flow_controller*/ false,
GetReceivedFlowControlWindow(session, id),
GetInitialStreamFlowControlWindowToSend(session, id),
@@ -134,9 +133,7 @@
// QuicSession::ProcessPendingStream() can read it.
}
-void PendingStream::OnFinRead() {
- QUICHE_DCHECK(sequencer_.IsClosed());
-}
+void PendingStream::OnFinRead() { QUICHE_DCHECK(sequencer_.IsClosed()); }
void PendingStream::AddBytesConsumed(QuicByteCount bytes) {
// It will be called when the metadata of the stream is consumed.
@@ -161,13 +158,9 @@
stream_delegate_->OnStreamError(error, ietf_error, details);
}
-QuicStreamId PendingStream::id() const {
- return id_;
-}
+QuicStreamId PendingStream::id() const { return id_; }
-ParsedQuicVersion PendingStream::version() const {
- return version_;
-}
+ParsedQuicVersion PendingStream::version() const { return version_; }
void PendingStream::OnStreamFrame(const QuicStreamFrame& frame) {
QUICHE_DCHECK_EQ(frame.stream_id, id_);
@@ -277,18 +270,11 @@
sequencer_.StopReading();
}
-QuicStream::QuicStream(PendingStream* pending,
- QuicSession* session,
- StreamType type,
- bool is_static)
- : QuicStream(pending->id_,
- session,
- std::move(pending->sequencer_),
- is_static,
- type,
- pending->stream_bytes_read_,
- pending->fin_received_,
- std::move(pending->flow_controller_),
+QuicStream::QuicStream(PendingStream* pending, QuicSession* session,
+ StreamType type, bool is_static)
+ : QuicStream(pending->id_, session, std::move(pending->sequencer_),
+ is_static, type, pending->stream_bytes_read_,
+ pending->fin_received_, std::move(pending->flow_controller_),
pending->connection_flow_controller_) {
sequencer_.set_stream(this);
}
@@ -317,26 +303,15 @@
} // namespace
-QuicStream::QuicStream(QuicStreamId id,
- QuicSession* session,
- bool is_static,
+QuicStream::QuicStream(QuicStreamId id, QuicSession* session, bool is_static,
StreamType type)
- : QuicStream(id,
- session,
- QuicStreamSequencer(this),
- is_static,
- type,
- 0,
- false,
- FlowController(id, session, type),
+ : QuicStream(id, session, QuicStreamSequencer(this), is_static, type, 0,
+ false, FlowController(id, session, type),
session->flow_controller()) {}
-QuicStream::QuicStream(QuicStreamId id,
- QuicSession* session,
- QuicStreamSequencer sequencer,
- bool is_static,
- StreamType type,
- uint64_t stream_bytes_read,
+QuicStream::QuicStream(QuicStreamId id, QuicSession* session,
+ QuicStreamSequencer sequencer, bool is_static,
+ StreamType type, uint64_t stream_bytes_read,
bool fin_received,
absl::optional<QuicFlowController> flow_controller,
QuicFlowController* connection_flow_controller)
@@ -371,8 +346,7 @@
was_draining_(false),
type_(VersionHasIetfQuicFrames(session->transport_version()) &&
type != CRYPTO
- ? QuicUtils::GetStreamType(id_,
- session->perspective(),
+ ? QuicUtils::GetStreamType(id_, session->perspective(),
session->IsIncomingStream(id_),
session->version())
: type),
@@ -628,8 +602,7 @@
}
void QuicStream::WriteOrBufferData(
- absl::string_view data,
- bool fin,
+ absl::string_view data, bool fin,
QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
QUIC_BUG_IF(quic_bug_12570_4,
QuicUtils::IsCryptoStreamId(transport_version(), id_))
@@ -877,9 +850,7 @@
return send_buffer_.stream_offset() > stream_bytes_written();
}
-ParsedQuicVersion QuicStream::version() const {
- return session_->version();
-}
+ParsedQuicVersion QuicStream::version() const { return session_->version(); }
QuicTransportVersion QuicStream::transport_version() const {
return session_->transport_version();
@@ -1060,8 +1031,7 @@
}
bool QuicStream::OnStreamFrameAcked(QuicStreamOffset offset,
- QuicByteCount data_length,
- bool fin_acked,
+ QuicByteCount data_length, bool fin_acked,
QuicTime::Delta /*ack_delay_time*/,
QuicTime /*receive_timestamp*/,
QuicByteCount* newly_acked_length) {
@@ -1101,8 +1071,7 @@
}
void QuicStream::OnStreamFrameLost(QuicStreamOffset offset,
- QuicByteCount data_length,
- bool fin_lost) {
+ QuicByteCount data_length, bool fin_lost) {
QUIC_DVLOG(1) << ENDPOINT << "stream " << id_ << " Losting "
<< "[" << offset << ", " << offset + data_length << "]"
<< " fin = " << fin_lost;
@@ -1115,8 +1084,7 @@
}
bool QuicStream::RetransmitStreamData(QuicStreamOffset offset,
- QuicByteCount data_length,
- bool fin,
+ QuicByteCount data_length, bool fin,
TransmissionType type) {
QUICHE_DCHECK(type == PTO_RETRANSMISSION || type == RTO_RETRANSMISSION ||
type == TLP_RETRANSMISSION || type == PROBING_RETRANSMISSION);
@@ -1380,9 +1348,7 @@
return true;
}
-void QuicStream::OnDeadlinePassed() {
- Reset(QUIC_STREAM_TTL_EXPIRED);
-}
+void QuicStream::OnDeadlinePassed() { Reset(QUIC_STREAM_TTL_EXPIRED); }
bool QuicStream::IsFlowControlBlocked() const {
if (!flow_controller_.has_value()) {
diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h
index 1b35e7f..6537dd1 100644
--- a/quic/core/quic_stream.h
+++ b/quic/core/quic_stream.h
@@ -135,13 +135,9 @@
// |type| indicates whether the stream is bidirectional, read unidirectional
// or write unidirectional.
// TODO(fayang): Remove |type| when IETF stream ID numbering fully kicks in.
- QuicStream(QuicStreamId id,
- QuicSession* session,
- bool is_static,
+ QuicStream(QuicStreamId id, QuicSession* session, bool is_static,
StreamType type);
- QuicStream(PendingStream* pending,
- QuicSession* session,
- StreamType type,
+ QuicStream(PendingStream* pending, QuicSession* session, StreamType type,
bool is_static);
QuicStream(const QuicStream&) = delete;
QuicStream& operator=(const QuicStream&) = delete;
@@ -291,31 +287,26 @@
// session, write_side_closed() becomes true, otherwise fin_buffered_ becomes
// true.
void WriteOrBufferData(
- absl::string_view data,
- bool fin,
+ absl::string_view data, bool fin,
QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
// Sends |data| to connection with specified |level|.
void WriteOrBufferDataAtLevel(
- absl::string_view data,
- bool fin,
- EncryptionLevel level,
+ absl::string_view data, bool fin, EncryptionLevel level,
QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
// Adds random padding after the fin is consumed for this stream.
void AddRandomPaddingAfterFin();
// Write |data_length| of data starts at |offset| from send buffer.
- bool WriteStreamData(QuicStreamOffset offset,
- QuicByteCount data_length,
+ bool WriteStreamData(QuicStreamOffset offset, QuicByteCount data_length,
QuicDataWriter* writer);
// Called when data [offset, offset + data_length) is acked. |fin_acked|
// indicates whether the fin is acked. Returns true and updates
// |newly_acked_length| if any new stream data (including fin) gets acked.
virtual bool OnStreamFrameAcked(QuicStreamOffset offset,
- QuicByteCount data_length,
- bool fin_acked,
+ QuicByteCount data_length, bool fin_acked,
QuicTime::Delta ack_delay_time,
QuicTime receive_timestamp,
QuicByteCount* newly_acked_length);
@@ -329,15 +320,13 @@
// Called when data [offset, offset + data_length) is considered as lost.
// |fin_lost| indicates whether the fin is considered as lost.
virtual void OnStreamFrameLost(QuicStreamOffset offset,
- QuicByteCount data_length,
- bool fin_lost);
+ QuicByteCount data_length, bool fin_lost);
// Called to retransmit outstanding portion in data [offset, offset +
// data_length) and |fin| with Transmission |type|.
// Returns true if all data gets retransmitted.
virtual bool RetransmitStreamData(QuicStreamOffset offset,
- QuicByteCount data_length,
- bool fin,
+ QuicByteCount data_length, bool fin,
TransmissionType type);
// Sets deadline of this stream to be now + |ttl|, returns true if the setting
@@ -359,8 +348,7 @@
// outstanding or fin is outstanding (if |fin| is true). Returns false
// otherwise.
bool IsStreamFrameOutstanding(QuicStreamOffset offset,
- QuicByteCount data_length,
- bool fin) const;
+ QuicByteCount data_length, bool fin) const;
StreamType type() const { return type_; }
@@ -391,8 +379,7 @@
// Called when data of [offset, offset + data_length] is buffered in send
// buffer.
virtual void OnDataBuffered(
- QuicStreamOffset /*offset*/,
- QuicByteCount /*data_length*/,
+ QuicStreamOffset /*offset*/, QuicByteCount /*data_length*/,
const QuicReferenceCountedPointer<QuicAckListenerInterface>&
/*ack_listener*/) {}
@@ -468,13 +455,9 @@
friend class test::QuicStreamPeer;
friend class QuicStreamUtils;
- QuicStream(QuicStreamId id,
- QuicSession* session,
- QuicStreamSequencer sequencer,
- bool is_static,
- StreamType type,
- uint64_t stream_bytes_read,
- bool fin_received,
+ QuicStream(QuicStreamId id, QuicSession* session,
+ QuicStreamSequencer sequencer, bool is_static, StreamType type,
+ uint64_t stream_bytes_read, bool fin_received,
absl::optional<QuicFlowController> flow_controller,
QuicFlowController* connection_flow_controller);
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 429b564..fa0362e 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -103,26 +103,17 @@
// constructed packet, the framer must be set to use NullDecrypter.
QuicEncryptedPacket* ConstructEncryptedPacket(
QuicConnectionId destination_connection_id,
- QuicConnectionId source_connection_id,
- bool version_flag,
- bool reset_flag,
- uint64_t packet_number,
- const std::string& data,
- bool full_padding,
+ QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
+ uint64_t packet_number, const std::string& data, bool full_padding,
QuicConnectionIdIncluded destination_connection_id_included,
QuicConnectionIdIncluded source_connection_id_included,
QuicPacketNumberLength packet_number_length,
- ParsedQuicVersionVector* versions,
- Perspective perspective);
+ ParsedQuicVersionVector* versions, Perspective perspective);
QuicEncryptedPacket* ConstructEncryptedPacket(
QuicConnectionId destination_connection_id,
- QuicConnectionId source_connection_id,
- bool version_flag,
- bool reset_flag,
- uint64_t packet_number,
- const std::string& data,
- bool full_padding,
+ QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
+ uint64_t packet_number, const std::string& data, bool full_padding,
QuicConnectionIdIncluded destination_connection_id_included,
QuicConnectionIdIncluded source_connection_id_included,
QuicPacketNumberLength packet_number_length,
@@ -134,11 +125,8 @@
// constructed packet, the framer must be set to use NullDecrypter.
QuicEncryptedPacket* ConstructEncryptedPacket(
QuicConnectionId destination_connection_id,
- QuicConnectionId source_connection_id,
- bool version_flag,
- bool reset_flag,
- uint64_t packet_number,
- const std::string& data,
+ QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
+ uint64_t packet_number, const std::string& data,
QuicConnectionIdIncluded destination_connection_id_included,
QuicConnectionIdIncluded source_connection_id_included,
QuicPacketNumberLength packet_number_length,
@@ -147,11 +135,8 @@
// This form assumes |versions| == nullptr.
QuicEncryptedPacket* ConstructEncryptedPacket(
QuicConnectionId destination_connection_id,
- QuicConnectionId source_connection_id,
- bool version_flag,
- bool reset_flag,
- uint64_t packet_number,
- const std::string& data,
+ QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
+ uint64_t packet_number, const std::string& data,
QuicConnectionIdIncluded destination_connection_id_included,
QuicConnectionIdIncluded source_connection_id_included,
QuicPacketNumberLength packet_number_length);
@@ -161,11 +146,8 @@
// |versions| == nullptr.
QuicEncryptedPacket* ConstructEncryptedPacket(
QuicConnectionId destination_connection_id,
- QuicConnectionId source_connection_id,
- bool version_flag,
- bool reset_flag,
- uint64_t packet_number,
- const std::string& data);
+ QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
+ uint64_t packet_number, const std::string& data);
// Creates a client-to-server ZERO-RTT packet that will fail to decrypt.
std::unique_ptr<QuicEncryptedPacket> GetUndecryptableEarlyPacket(
@@ -175,8 +157,7 @@
// Constructs a received packet for testing. The caller must take ownership
// of the returned pointer.
QuicReceivedPacket* ConstructReceivedPacket(
- const QuicEncryptedPacket& encrypted_packet,
- QuicTime receipt_time);
+ const QuicEncryptedPacket& encrypted_packet, QuicTime receipt_time);
// Create an encrypted packet for testing whose data portion erroneous.
// The specific way the data portion is erroneous is not specified, but
@@ -185,15 +166,11 @@
// constructed packet, the framer must be set to use NullDecrypter.
QuicEncryptedPacket* ConstructMisFramedEncryptedPacket(
QuicConnectionId destination_connection_id,
- QuicConnectionId source_connection_id,
- bool version_flag,
- bool reset_flag,
- uint64_t packet_number,
- const std::string& data,
+ QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
+ uint64_t packet_number, const std::string& data,
QuicConnectionIdIncluded destination_connection_id_included,
QuicConnectionIdIncluded source_connection_id_included,
- QuicPacketNumberLength packet_number_length,
- ParsedQuicVersion version,
+ QuicPacketNumberLength packet_number_length, ParsedQuicVersion version,
Perspective perspective);
// Returns QuicConfig set to default values.
@@ -228,8 +205,7 @@
// Testing convenice method to construct a QuicAckFrame with |largest_acked|,
// ack blocks of width 1 packet and |gap_size|.
-QuicAckFrame MakeAckFrameWithGaps(uint64_t gap_size,
- size_t max_num_gaps,
+QuicAckFrame MakeAckFrameWithGaps(uint64_t gap_size, size_t max_num_gaps,
uint64_t largest_acked);
// Returns the encryption level that corresponds to the header type in
@@ -241,15 +217,12 @@
// is populated with the fields in |header| and |frames|, or is nullptr if the
// packet could not be created.
std::unique_ptr<QuicPacket> BuildUnsizedDataPacket(
- QuicFramer* framer,
- const QuicPacketHeader& header,
+ QuicFramer* framer, const QuicPacketHeader& header,
const QuicFrames& frames);
// Returns a QuicPacket that is owned by the caller, and of size |packet_size|.
std::unique_ptr<QuicPacket> BuildUnsizedDataPacket(
- QuicFramer* framer,
- const QuicPacketHeader& header,
- const QuicFrames& frames,
- size_t packet_size);
+ QuicFramer* framer, const QuicPacketHeader& header,
+ const QuicFrames& frames, size_t packet_size);
// Compute SHA-1 hash of the supplied std::string.
std::string Sha1Hash(absl::string_view data);
@@ -297,21 +270,14 @@
MOCK_METHOD(void, OnError, (QuicFramer*), (override));
// The constructor sets this up to return false by default.
- MOCK_METHOD(bool,
- OnProtocolVersionMismatch,
- (ParsedQuicVersion version),
+ MOCK_METHOD(bool, OnProtocolVersionMismatch, (ParsedQuicVersion version),
(override));
MOCK_METHOD(void, OnPacket, (), (override));
- MOCK_METHOD(void,
- OnPublicResetPacket,
- (const QuicPublicResetPacket& header),
+ MOCK_METHOD(void, OnPublicResetPacket, (const QuicPublicResetPacket& header),
(override));
- MOCK_METHOD(void,
- OnVersionNegotiationPacket,
- (const QuicVersionNegotiationPacket& packet),
- (override));
- MOCK_METHOD(void,
- OnRetryPacket,
+ MOCK_METHOD(void, OnVersionNegotiationPacket,
+ (const QuicVersionNegotiationPacket& packet), (override));
+ MOCK_METHOD(void, OnRetryPacket,
(QuicConnectionId original_connection_id,
QuicConnectionId new_connection_id,
absl::string_view retry_token,
@@ -319,133 +285,75 @@
absl::string_view retry_without_tag),
(override));
// The constructor sets this up to return true by default.
- MOCK_METHOD(bool,
- OnUnauthenticatedHeader,
- (const QuicPacketHeader& header),
+ MOCK_METHOD(bool, OnUnauthenticatedHeader, (const QuicPacketHeader& header),
(override));
// The constructor sets this up to return true by default.
- MOCK_METHOD(bool,
- OnUnauthenticatedPublicHeader,
- (const QuicPacketHeader& header),
+ MOCK_METHOD(bool, OnUnauthenticatedPublicHeader,
+ (const QuicPacketHeader& header), (override));
+ MOCK_METHOD(void, OnDecryptedPacket, (size_t length, EncryptionLevel level),
(override));
- MOCK_METHOD(void,
- OnDecryptedPacket,
- (size_t length, EncryptionLevel level),
+ MOCK_METHOD(bool, OnPacketHeader, (const QuicPacketHeader& header),
(override));
- MOCK_METHOD(bool,
- OnPacketHeader,
- (const QuicPacketHeader& header),
+ MOCK_METHOD(void, OnCoalescedPacket, (const QuicEncryptedPacket& packet),
(override));
- MOCK_METHOD(void,
- OnCoalescedPacket,
- (const QuicEncryptedPacket& packet),
- (override));
- MOCK_METHOD(void,
- OnUndecryptablePacket,
+ MOCK_METHOD(void, OnUndecryptablePacket,
(const QuicEncryptedPacket& packet,
- EncryptionLevel decryption_level,
- bool has_decryption_key),
+ EncryptionLevel decryption_level, bool has_decryption_key),
(override));
MOCK_METHOD(bool, OnStreamFrame, (const QuicStreamFrame& frame), (override));
MOCK_METHOD(bool, OnCryptoFrame, (const QuicCryptoFrame& frame), (override));
- MOCK_METHOD(bool,
- OnAckFrameStart,
- (QuicPacketNumber, QuicTime::Delta),
+ MOCK_METHOD(bool, OnAckFrameStart, (QuicPacketNumber, QuicTime::Delta),
(override));
- MOCK_METHOD(bool,
- OnAckRange,
- (QuicPacketNumber, QuicPacketNumber),
+ MOCK_METHOD(bool, OnAckRange, (QuicPacketNumber, QuicPacketNumber),
(override));
MOCK_METHOD(bool, OnAckTimestamp, (QuicPacketNumber, QuicTime), (override));
MOCK_METHOD(bool, OnAckFrameEnd, (QuicPacketNumber), (override));
- MOCK_METHOD(bool,
- OnStopWaitingFrame,
- (const QuicStopWaitingFrame& frame),
+ MOCK_METHOD(bool, OnStopWaitingFrame, (const QuicStopWaitingFrame& frame),
(override));
- MOCK_METHOD(bool,
- OnPaddingFrame,
- (const QuicPaddingFrame& frame),
+ MOCK_METHOD(bool, OnPaddingFrame, (const QuicPaddingFrame& frame),
(override));
MOCK_METHOD(bool, OnPingFrame, (const QuicPingFrame& frame), (override));
- MOCK_METHOD(bool,
- OnRstStreamFrame,
- (const QuicRstStreamFrame& frame),
+ MOCK_METHOD(bool, OnRstStreamFrame, (const QuicRstStreamFrame& frame),
(override));
- MOCK_METHOD(bool,
- OnConnectionCloseFrame,
- (const QuicConnectionCloseFrame& frame),
+ MOCK_METHOD(bool, OnConnectionCloseFrame,
+ (const QuicConnectionCloseFrame& frame), (override));
+ MOCK_METHOD(bool, OnNewConnectionIdFrame,
+ (const QuicNewConnectionIdFrame& frame), (override));
+ MOCK_METHOD(bool, OnRetireConnectionIdFrame,
+ (const QuicRetireConnectionIdFrame& frame), (override));
+ MOCK_METHOD(bool, OnNewTokenFrame, (const QuicNewTokenFrame& frame),
(override));
- MOCK_METHOD(bool,
- OnNewConnectionIdFrame,
- (const QuicNewConnectionIdFrame& frame),
+ MOCK_METHOD(bool, OnStopSendingFrame, (const QuicStopSendingFrame& frame),
(override));
- MOCK_METHOD(bool,
- OnRetireConnectionIdFrame,
- (const QuicRetireConnectionIdFrame& frame),
+ MOCK_METHOD(bool, OnPathChallengeFrame, (const QuicPathChallengeFrame& frame),
(override));
- MOCK_METHOD(bool,
- OnNewTokenFrame,
- (const QuicNewTokenFrame& frame),
- (override));
- MOCK_METHOD(bool,
- OnStopSendingFrame,
- (const QuicStopSendingFrame& frame),
- (override));
- MOCK_METHOD(bool,
- OnPathChallengeFrame,
- (const QuicPathChallengeFrame& frame),
- (override));
- MOCK_METHOD(bool,
- OnPathResponseFrame,
- (const QuicPathResponseFrame& frame),
+ MOCK_METHOD(bool, OnPathResponseFrame, (const QuicPathResponseFrame& frame),
(override));
MOCK_METHOD(bool, OnGoAwayFrame, (const QuicGoAwayFrame& frame), (override));
- MOCK_METHOD(bool,
- OnMaxStreamsFrame,
- (const QuicMaxStreamsFrame& frame),
+ MOCK_METHOD(bool, OnMaxStreamsFrame, (const QuicMaxStreamsFrame& frame),
(override));
- MOCK_METHOD(bool,
- OnStreamsBlockedFrame,
- (const QuicStreamsBlockedFrame& frame),
+ MOCK_METHOD(bool, OnStreamsBlockedFrame,
+ (const QuicStreamsBlockedFrame& frame), (override));
+ MOCK_METHOD(bool, OnWindowUpdateFrame, (const QuicWindowUpdateFrame& frame),
(override));
- MOCK_METHOD(bool,
- OnWindowUpdateFrame,
- (const QuicWindowUpdateFrame& frame),
+ MOCK_METHOD(bool, OnBlockedFrame, (const QuicBlockedFrame& frame),
(override));
- MOCK_METHOD(bool,
- OnBlockedFrame,
- (const QuicBlockedFrame& frame),
+ MOCK_METHOD(bool, OnMessageFrame, (const QuicMessageFrame& frame),
(override));
- MOCK_METHOD(bool,
- OnMessageFrame,
- (const QuicMessageFrame& frame),
+ MOCK_METHOD(bool, OnHandshakeDoneFrame, (const QuicHandshakeDoneFrame& frame),
(override));
- MOCK_METHOD(bool,
- OnHandshakeDoneFrame,
- (const QuicHandshakeDoneFrame& frame),
- (override));
- MOCK_METHOD(bool,
- OnAckFrequencyFrame,
- (const QuicAckFrequencyFrame& frame),
+ MOCK_METHOD(bool, OnAckFrequencyFrame, (const QuicAckFrequencyFrame& frame),
(override));
MOCK_METHOD(void, OnPacketComplete, (), (override));
- MOCK_METHOD(bool,
- IsValidStatelessResetToken,
- (const StatelessResetToken&),
+ MOCK_METHOD(bool, IsValidStatelessResetToken, (const StatelessResetToken&),
(const, override));
- MOCK_METHOD(void,
- OnAuthenticatedIetfStatelessResetPacket,
- (const QuicIetfStatelessResetPacket&),
- (override));
+ MOCK_METHOD(void, OnAuthenticatedIetfStatelessResetPacket,
+ (const QuicIetfStatelessResetPacket&), (override));
MOCK_METHOD(void, OnKeyUpdate, (KeyUpdateReason), (override));
MOCK_METHOD(void, OnDecryptedFirstPacketInKeyPhase, (), (override));
MOCK_METHOD(std::unique_ptr<QuicDecrypter>,
- AdvanceKeysAndCreateCurrentOneRttDecrypter,
- (),
- (override));
- MOCK_METHOD(std::unique_ptr<QuicEncrypter>,
- CreateCurrentOneRttEncrypter,
- (),
+ AdvanceKeysAndCreateCurrentOneRttDecrypter, (), (override));
+ MOCK_METHOD(std::unique_ptr<QuicEncrypter>, CreateCurrentOneRttEncrypter, (),
(override));
};
@@ -529,97 +437,66 @@
MOCK_METHOD(void, OnStreamFrame, (const QuicStreamFrame& frame), (override));
MOCK_METHOD(void, OnCryptoFrame, (const QuicCryptoFrame& frame), (override));
- MOCK_METHOD(void,
- OnWindowUpdateFrame,
- (const QuicWindowUpdateFrame& frame),
+ MOCK_METHOD(void, OnWindowUpdateFrame, (const QuicWindowUpdateFrame& frame),
(override));
- MOCK_METHOD(void,
- OnBlockedFrame,
- (const QuicBlockedFrame& frame),
+ MOCK_METHOD(void, OnBlockedFrame, (const QuicBlockedFrame& frame),
(override));
MOCK_METHOD(void, OnRstStream, (const QuicRstStreamFrame& frame), (override));
MOCK_METHOD(void, OnGoAway, (const QuicGoAwayFrame& frame), (override));
MOCK_METHOD(void, OnMessageReceived, (absl::string_view message), (override));
MOCK_METHOD(void, OnHandshakeDoneReceived, (), (override));
MOCK_METHOD(void, OnNewTokenReceived, (absl::string_view token), (override));
- MOCK_METHOD(void,
- OnConnectionClosed,
+ MOCK_METHOD(void, OnConnectionClosed,
(const QuicConnectionCloseFrame& frame,
ConnectionCloseSource source),
(override));
MOCK_METHOD(void, OnWriteBlocked, (), (override));
MOCK_METHOD(void, OnCanWrite, (), (override));
MOCK_METHOD(bool, SendProbingData, (), (override));
- MOCK_METHOD(bool,
- ValidateStatelessReset,
+ MOCK_METHOD(bool, ValidateStatelessReset,
(const quic::QuicSocketAddress&, const quic::QuicSocketAddress&),
(override));
MOCK_METHOD(void, OnCongestionWindowChange, (QuicTime now), (override));
- MOCK_METHOD(void,
- OnConnectionMigration,
- (AddressChangeType type),
+ MOCK_METHOD(void, OnConnectionMigration, (AddressChangeType type),
(override));
MOCK_METHOD(void, OnPathDegrading, (), (override));
MOCK_METHOD(void, OnForwardProgressMadeAfterPathDegrading, (), (override));
MOCK_METHOD(bool, WillingAndAbleToWrite, (), (const, override));
MOCK_METHOD(bool, ShouldKeepConnectionAlive, (), (const, override));
MOCK_METHOD(std::string, GetStreamsInfoForLogging, (), (const, override));
- MOCK_METHOD(void,
- OnSuccessfulVersionNegotiation,
- (const ParsedQuicVersion& version),
- (override));
- MOCK_METHOD(void,
- OnPacketReceived,
+ MOCK_METHOD(void, OnSuccessfulVersionNegotiation,
+ (const ParsedQuicVersion& version), (override));
+ MOCK_METHOD(void, OnPacketReceived,
(const QuicSocketAddress& self_address,
const QuicSocketAddress& peer_address,
bool is_connectivity_probe),
(override));
MOCK_METHOD(void, OnAckNeedsRetransmittableFrame, (), (override));
- MOCK_METHOD(void,
- SendAckFrequency,
- (const QuicAckFrequencyFrame& frame),
+ MOCK_METHOD(void, SendAckFrequency, (const QuicAckFrequencyFrame& frame),
(override));
- MOCK_METHOD(void,
- SendNewConnectionId,
- (const QuicNewConnectionIdFrame& frame),
+ MOCK_METHOD(void, SendNewConnectionId,
+ (const QuicNewConnectionIdFrame& frame), (override));
+ MOCK_METHOD(void, SendRetireConnectionId, (uint64_t sequence_number),
(override));
- MOCK_METHOD(void,
- SendRetireConnectionId,
- (uint64_t sequence_number),
- (override));
- MOCK_METHOD(void,
- OnServerConnectionIdIssued,
- (const QuicConnectionId& server_connection_id),
- (override));
- MOCK_METHOD(void,
- OnServerConnectionIdRetired,
- (const QuicConnectionId& server_connection_id),
- (override));
+ MOCK_METHOD(void, OnServerConnectionIdIssued,
+ (const QuicConnectionId& server_connection_id), (override));
+ MOCK_METHOD(void, OnServerConnectionIdRetired,
+ (const QuicConnectionId& server_connection_id), (override));
MOCK_METHOD(bool, AllowSelfAddressChange, (), (const, override));
MOCK_METHOD(HandshakeState, GetHandshakeState, (), (const, override));
- MOCK_METHOD(bool,
- OnMaxStreamsFrame,
- (const QuicMaxStreamsFrame& frame),
+ MOCK_METHOD(bool, OnMaxStreamsFrame, (const QuicMaxStreamsFrame& frame),
(override));
- MOCK_METHOD(bool,
- OnStreamsBlockedFrame,
- (const QuicStreamsBlockedFrame& frame),
- (override));
- MOCK_METHOD(void,
- OnStopSendingFrame,
- (const QuicStopSendingFrame& frame),
+ MOCK_METHOD(bool, OnStreamsBlockedFrame,
+ (const QuicStreamsBlockedFrame& frame), (override));
+ MOCK_METHOD(void, OnStopSendingFrame, (const QuicStopSendingFrame& frame),
(override));
MOCK_METHOD(void, OnPacketDecrypted, (EncryptionLevel), (override));
MOCK_METHOD(void, OnOneRttPacketAcknowledged, (), (override));
MOCK_METHOD(void, OnHandshakePacketSent, (), (override));
MOCK_METHOD(void, OnKeyUpdate, (KeyUpdateReason), (override));
MOCK_METHOD(std::unique_ptr<QuicDecrypter>,
- AdvanceKeysAndCreateCurrentOneRttDecrypter,
- (),
- (override));
- MOCK_METHOD(std::unique_ptr<QuicEncrypter>,
- CreateCurrentOneRttEncrypter,
- (),
+ AdvanceKeysAndCreateCurrentOneRttDecrypter, (), (override));
+ MOCK_METHOD(std::unique_ptr<QuicEncrypter>, CreateCurrentOneRttEncrypter, (),
(override));
MOCK_METHOD(void, BeforeConnectionCloseSent, (), (override));
MOCK_METHOD(bool, ValidateToken, (absl::string_view), (const, override));
@@ -703,32 +580,26 @@
public:
// Uses a ConnectionId of 42 and 127.0.0.1:123.
MockQuicConnection(MockQuicConnectionHelper* helper,
- MockAlarmFactory* alarm_factory,
- Perspective perspective);
+ MockAlarmFactory* alarm_factory, Perspective perspective);
// Uses a ConnectionId of 42.
MockQuicConnection(QuicSocketAddress address,
MockQuicConnectionHelper* helper,
- MockAlarmFactory* alarm_factory,
- Perspective perspective);
+ MockAlarmFactory* alarm_factory, Perspective perspective);
// Uses 127.0.0.1:123.
MockQuicConnection(QuicConnectionId connection_id,
MockQuicConnectionHelper* helper,
- MockAlarmFactory* alarm_factory,
- Perspective perspective);
+ MockAlarmFactory* alarm_factory, Perspective perspective);
// Uses a ConnectionId of 42, and 127.0.0.1:123.
MockQuicConnection(MockQuicConnectionHelper* helper,
- MockAlarmFactory* alarm_factory,
- Perspective perspective,
+ MockAlarmFactory* alarm_factory, Perspective perspective,
const ParsedQuicVersionVector& supported_versions);
- MockQuicConnection(QuicConnectionId connection_id,
- QuicSocketAddress address,
+ MockQuicConnection(QuicConnectionId connection_id, QuicSocketAddress address,
MockQuicConnectionHelper* helper,
- MockAlarmFactory* alarm_factory,
- Perspective perspective,
+ MockAlarmFactory* alarm_factory, Perspective perspective,
const ParsedQuicVersionVector& supported_versions);
MockQuicConnection(const MockQuicConnection&) = delete;
MockQuicConnection& operator=(const MockQuicConnection&) = delete;
@@ -740,64 +611,45 @@
// will advance the time of the MockClock.
void AdvanceTime(QuicTime::Delta delta);
- MOCK_METHOD(void,
- ProcessUdpPacket,
+ MOCK_METHOD(void, ProcessUdpPacket,
(const QuicSocketAddress& self_address,
const QuicSocketAddress& peer_address,
const QuicReceivedPacket& packet),
(override));
- MOCK_METHOD(void,
- CloseConnection,
- (QuicErrorCode error,
+ MOCK_METHOD(void, CloseConnection,
+ (QuicErrorCode error, const std::string& details,
+ ConnectionCloseBehavior connection_close_behavior),
+ (override));
+ MOCK_METHOD(void, CloseConnection,
+ (QuicErrorCode error, QuicIetfTransportErrorCodes ietf_error,
const std::string& details,
ConnectionCloseBehavior connection_close_behavior),
(override));
- MOCK_METHOD(void,
- CloseConnection,
- (QuicErrorCode error,
- QuicIetfTransportErrorCodes ietf_error,
- const std::string& details,
- ConnectionCloseBehavior connection_close_behavior),
- (override));
- MOCK_METHOD(void,
- SendConnectionClosePacket,
- (QuicErrorCode error,
- QuicIetfTransportErrorCodes ietf_error,
+ MOCK_METHOD(void, SendConnectionClosePacket,
+ (QuicErrorCode error, QuicIetfTransportErrorCodes ietf_error,
const std::string& details),
(override));
MOCK_METHOD(void, OnCanWrite, (), (override));
- MOCK_METHOD(void,
- SendConnectivityProbingResponsePacket,
- (const QuicSocketAddress& peer_address),
- (override));
- MOCK_METHOD(bool,
- SendConnectivityProbingPacket,
+ MOCK_METHOD(void, SendConnectivityProbingResponsePacket,
+ (const QuicSocketAddress& peer_address), (override));
+ MOCK_METHOD(bool, SendConnectivityProbingPacket,
(QuicPacketWriter*, const QuicSocketAddress& peer_address),
(override));
- MOCK_METHOD(void,
- OnSendConnectionState,
- (const CachedNetworkParameters&),
+ MOCK_METHOD(void, OnSendConnectionState, (const CachedNetworkParameters&),
(override));
- MOCK_METHOD(void,
- ResumeConnectionState,
- (const CachedNetworkParameters&, bool),
- (override));
+ MOCK_METHOD(void, ResumeConnectionState,
+ (const CachedNetworkParameters&, bool), (override));
MOCK_METHOD(void, SetMaxPacingRate, (QuicBandwidth), (override));
- MOCK_METHOD(void,
- OnStreamReset,
- (QuicStreamId, QuicRstStreamErrorCode),
+ MOCK_METHOD(void, OnStreamReset, (QuicStreamId, QuicRstStreamErrorCode),
(override));
MOCK_METHOD(bool, SendControlFrame, (const QuicFrame& frame), (override));
MOCK_METHOD(MessageStatus, SendMessage,
(QuicMessageId, absl::Span<QuicMemSlice>, bool), (override));
- MOCK_METHOD(bool,
- SendPathChallenge,
- (const QuicPathFrameBuffer&,
- const QuicSocketAddress&,
- const QuicSocketAddress&,
- const QuicSocketAddress&,
+ MOCK_METHOD(bool, SendPathChallenge,
+ (const QuicPathFrameBuffer&, const QuicSocketAddress&,
+ const QuicSocketAddress&, const QuicSocketAddress&,
QuicPacketWriter*),
(override));
@@ -809,8 +661,7 @@
void ReallyOnCanWrite() { QuicConnection::OnCanWrite(); }
void ReallyCloseConnection(
- QuicErrorCode error,
- const std::string& details,
+ QuicErrorCode error, const std::string& details,
ConnectionCloseBehavior connection_close_behavior) {
// Call the 4-param method directly instead of the 3-param method, so that
// it doesn't invoke the virtual 4-param method causing the mock 4-param
@@ -820,8 +671,7 @@
}
void ReallyCloseConnection4(
- QuicErrorCode error,
- QuicIetfTransportErrorCodes ietf_error,
+ QuicErrorCode error, QuicIetfTransportErrorCodes ietf_error,
const std::string& details,
ConnectionCloseBehavior connection_close_behavior) {
QuicConnection::CloseConnection(error, ietf_error, details,
@@ -847,8 +697,7 @@
}
bool ReallySendConnectivityProbingPacket(
- QuicPacketWriter* probing_writer,
- const QuicSocketAddress& peer_address) {
+ QuicPacketWriter* probing_writer, const QuicSocketAddress& peer_address) {
return QuicConnection::SendConnectivityProbingPacket(probing_writer,
peer_address);
}
@@ -862,18 +711,12 @@
return QuicConnection::OnPathResponseFrame(frame);
}
- MOCK_METHOD(bool,
- OnPathResponseFrame,
- (const QuicPathResponseFrame&),
+ MOCK_METHOD(bool, OnPathResponseFrame, (const QuicPathResponseFrame&),
(override));
- MOCK_METHOD(bool,
- OnStopSendingFrame,
- (const QuicStopSendingFrame& frame),
+ MOCK_METHOD(bool, OnStopSendingFrame, (const QuicStopSendingFrame& frame),
(override));
- MOCK_METHOD(size_t,
- SendCryptoData,
- (EncryptionLevel, size_t, QuicStreamOffset),
- (override));
+ MOCK_METHOD(size_t, SendCryptoData,
+ (EncryptionLevel, size_t, QuicStreamOffset), (override));
size_t QuicConnection_SendCryptoData(EncryptionLevel level,
size_t write_length,
QuicStreamOffset offset) {
@@ -919,53 +762,41 @@
const QuicCryptoStream* GetCryptoStream() const override;
void SetCryptoStream(QuicCryptoStream* crypto_stream);
- MOCK_METHOD(void,
- OnConnectionClosed,
+ MOCK_METHOD(void, OnConnectionClosed,
(const QuicConnectionCloseFrame& frame,
ConnectionCloseSource source),
(override));
MOCK_METHOD(QuicStream*, CreateIncomingStream, (QuicStreamId id), (override));
- MOCK_METHOD(QuicSpdyStream*,
- CreateIncomingStream,
- (PendingStream*),
+ MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (PendingStream*),
(override));
MOCK_METHOD(QuicConsumedData, WritevData,
(QuicStreamId id, size_t write_length, QuicStreamOffset offset,
StreamSendingState state, TransmissionType type,
EncryptionLevel level),
(override));
- MOCK_METHOD(bool,
- WriteControlFrame,
- (const QuicFrame& frame, TransmissionType type),
- (override));
- MOCK_METHOD(void,
- MaybeSendRstStreamFrame,
- (QuicStreamId stream_id,
- QuicRstStreamErrorCode error,
+ MOCK_METHOD(bool, WriteControlFrame,
+ (const QuicFrame& frame, TransmissionType type), (override));
+ MOCK_METHOD(void, MaybeSendRstStreamFrame,
+ (QuicStreamId stream_id, QuicRstStreamErrorCode error,
QuicStreamOffset bytes_written),
(override));
- MOCK_METHOD(void,
- MaybeSendStopSendingFrame,
+ MOCK_METHOD(void, MaybeSendStopSendingFrame,
(QuicStreamId stream_id, QuicRstStreamErrorCode error),
(override));
MOCK_METHOD(bool, ShouldKeepConnectionAlive, (), (const, override));
MOCK_METHOD(std::vector<std::string>, GetAlpnsToOffer, (), (const, override));
- MOCK_METHOD(std::vector<absl::string_view>::const_iterator,
- SelectAlpn,
- (const std::vector<absl::string_view>&),
- (const, override));
+ MOCK_METHOD(std::vector<absl::string_view>::const_iterator, SelectAlpn,
+ (const std::vector<absl::string_view>&), (const, override));
MOCK_METHOD(void, OnAlpnSelected, (absl::string_view), (override));
using QuicSession::ActivateStream;
// Returns a QuicConsumedData that indicates all of |write_length| (and |fin|
// if set) has been consumed.
- QuicConsumedData ConsumeData(QuicStreamId id,
- size_t write_length,
+ QuicConsumedData ConsumeData(QuicStreamId id, size_t write_length,
QuicStreamOffset offset,
- StreamSendingState state,
- TransmissionType type,
+ StreamSendingState state, TransmissionType type,
absl::optional<EncryptionLevel> level);
void ReallyMaybeSendRstStreamFrame(QuicStreamId id,
@@ -1039,26 +870,17 @@
}
// From QuicSession.
- MOCK_METHOD(void,
- OnConnectionClosed,
+ MOCK_METHOD(void, OnConnectionClosed,
(const QuicConnectionCloseFrame& frame,
ConnectionCloseSource source),
(override));
- MOCK_METHOD(QuicSpdyStream*,
- CreateIncomingStream,
- (QuicStreamId id),
+ MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (QuicStreamId id),
(override));
- MOCK_METHOD(QuicSpdyStream*,
- CreateIncomingStream,
- (PendingStream*),
+ MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (PendingStream*),
(override));
- MOCK_METHOD(QuicSpdyStream*,
- CreateOutgoingBidirectionalStream,
- (),
+ MOCK_METHOD(QuicSpdyStream*, CreateOutgoingBidirectionalStream, (),
(override));
- MOCK_METHOD(QuicSpdyStream*,
- CreateOutgoingUnidirectionalStream,
- (),
+ MOCK_METHOD(QuicSpdyStream*, CreateOutgoingUnidirectionalStream, (),
(override));
MOCK_METHOD(bool, ShouldCreateIncomingStream, (QuicStreamId id), (override));
MOCK_METHOD(bool, ShouldCreateOutgoingBidirectionalStream, (), (override));
@@ -1068,53 +890,38 @@
StreamSendingState state, TransmissionType type,
EncryptionLevel level),
(override));
- MOCK_METHOD(void,
- MaybeSendRstStreamFrame,
- (QuicStreamId stream_id,
- QuicRstStreamErrorCode error,
+ MOCK_METHOD(void, MaybeSendRstStreamFrame,
+ (QuicStreamId stream_id, QuicRstStreamErrorCode error,
QuicStreamOffset bytes_written),
(override));
- MOCK_METHOD(void,
- MaybeSendStopSendingFrame,
+ MOCK_METHOD(void, MaybeSendStopSendingFrame,
(QuicStreamId stream_id, QuicRstStreamErrorCode error),
(override));
- MOCK_METHOD(void,
- SendWindowUpdate,
- (QuicStreamId id, QuicStreamOffset byte_offset),
- (override));
+ MOCK_METHOD(void, SendWindowUpdate,
+ (QuicStreamId id, QuicStreamOffset byte_offset), (override));
MOCK_METHOD(void, SendBlocked, (QuicStreamId id), (override));
- MOCK_METHOD(void,
- OnStreamHeadersPriority,
+ MOCK_METHOD(void, OnStreamHeadersPriority,
(QuicStreamId stream_id,
const spdy::SpdyStreamPrecedence& precedence),
(override));
- MOCK_METHOD(void,
- OnStreamHeaderList,
- (QuicStreamId stream_id,
- bool fin,
- size_t frame_len,
+ MOCK_METHOD(void, OnStreamHeaderList,
+ (QuicStreamId stream_id, bool fin, size_t frame_len,
const QuicHeaderList& header_list),
(override));
- MOCK_METHOD(void,
- OnPromiseHeaderList,
- (QuicStreamId stream_id,
- QuicStreamId promised_stream_id,
- size_t frame_len,
- const QuicHeaderList& header_list),
+ MOCK_METHOD(void, OnPromiseHeaderList,
+ (QuicStreamId stream_id, QuicStreamId promised_stream_id,
+ size_t frame_len, const QuicHeaderList& header_list),
(override));
- MOCK_METHOD(void,
- OnPriorityFrame,
+ MOCK_METHOD(void, OnPriorityFrame,
(QuicStreamId id, const spdy::SpdyStreamPrecedence& precedence),
(override));
MOCK_METHOD(void, OnCongestionWindowChange, (QuicTime now), (override));
// Returns a QuicConsumedData that indicates all of |write_length| (and |fin|
// if set) has been consumed.
- QuicConsumedData ConsumeData(QuicStreamId id,
- size_t write_length,
+ QuicConsumedData ConsumeData(QuicStreamId id, size_t write_length,
QuicStreamOffset offset,
- StreamSendingState state,
- TransmissionType type,
+ StreamSendingState state, TransmissionType type,
absl::optional<EncryptionLevel> level);
using QuicSession::ActivateStream;
@@ -1129,73 +936,45 @@
MOCK_METHOD(void, OnQpackEncoderStreamCreated, (QuicStreamId), (override));
MOCK_METHOD(void, OnQpackDecoderStreamCreated, (QuicStreamId), (override));
MOCK_METHOD(void, OnPeerControlStreamCreated, (QuicStreamId), (override));
- MOCK_METHOD(void,
- OnPeerQpackEncoderStreamCreated,
- (QuicStreamId),
+ MOCK_METHOD(void, OnPeerQpackEncoderStreamCreated, (QuicStreamId),
(override));
- MOCK_METHOD(void,
- OnPeerQpackDecoderStreamCreated,
- (QuicStreamId),
+ MOCK_METHOD(void, OnPeerQpackDecoderStreamCreated, (QuicStreamId),
(override));
- MOCK_METHOD(void,
- OnSettingsFrameReceivedViaAlps,
- (const SettingsFrame&),
+ MOCK_METHOD(void, OnSettingsFrameReceivedViaAlps, (const SettingsFrame&),
(override));
- MOCK_METHOD(void,
- OnAcceptChFrameReceivedViaAlps,
- (const AcceptChFrame&),
+ MOCK_METHOD(void, OnAcceptChFrameReceivedViaAlps, (const AcceptChFrame&),
(override));
- MOCK_METHOD(void,
- OnSettingsFrameReceived,
- (const SettingsFrame&),
+ MOCK_METHOD(void, OnSettingsFrameReceived, (const SettingsFrame&),
(override));
MOCK_METHOD(void, OnGoAwayFrameReceived, (const GoAwayFrame&), (override));
- MOCK_METHOD(void,
- OnMaxPushIdFrameReceived,
- (const MaxPushIdFrame&),
+ MOCK_METHOD(void, OnMaxPushIdFrameReceived, (const MaxPushIdFrame&),
(override));
- MOCK_METHOD(void,
- OnPriorityUpdateFrameReceived,
- (const PriorityUpdateFrame&),
+ MOCK_METHOD(void, OnPriorityUpdateFrameReceived, (const PriorityUpdateFrame&),
(override));
- MOCK_METHOD(void,
- OnAcceptChFrameReceived,
- (const AcceptChFrame&),
+ MOCK_METHOD(void, OnAcceptChFrameReceived, (const AcceptChFrame&),
(override));
- MOCK_METHOD(void,
- OnDataFrameReceived,
- (QuicStreamId, QuicByteCount),
+ MOCK_METHOD(void, OnDataFrameReceived, (QuicStreamId, QuicByteCount),
(override));
- MOCK_METHOD(void,
- OnHeadersFrameReceived,
- (QuicStreamId, QuicByteCount),
+ MOCK_METHOD(void, OnHeadersFrameReceived, (QuicStreamId, QuicByteCount),
(override));
- MOCK_METHOD(void,
- OnHeadersDecoded,
- (QuicStreamId, QuicHeaderList),
+ MOCK_METHOD(void, OnHeadersDecoded, (QuicStreamId, QuicHeaderList),
(override));
- MOCK_METHOD(void,
- OnUnknownFrameReceived,
- (QuicStreamId, uint64_t, QuicByteCount),
- (override));
+ MOCK_METHOD(void, OnUnknownFrameReceived,
+ (QuicStreamId, uint64_t, QuicByteCount), (override));
MOCK_METHOD(void, OnSettingsFrameSent, (const SettingsFrame&), (override));
MOCK_METHOD(void, OnGoAwayFrameSent, (QuicStreamId), (override));
MOCK_METHOD(void, OnMaxPushIdFrameSent, (const MaxPushIdFrame&), (override));
- MOCK_METHOD(void,
- OnPriorityUpdateFrameSent,
- (const PriorityUpdateFrame&),
+ MOCK_METHOD(void, OnPriorityUpdateFrameSent, (const PriorityUpdateFrame&),
(override));
MOCK_METHOD(void, OnDataFrameSent, (QuicStreamId, QuicByteCount), (override));
- MOCK_METHOD(void,
- OnHeadersFrameSent,
- (QuicStreamId, const spdy::SpdyHeaderBlock&),
- (override));
+ MOCK_METHOD(void, OnHeadersFrameSent,
+ (QuicStreamId, const spdy::SpdyHeaderBlock&), (override));
};
class TestQuicSpdyServerSession : public QuicServerSessionBase {
@@ -1211,26 +990,16 @@
delete;
~TestQuicSpdyServerSession() override;
- MOCK_METHOD(QuicSpdyStream*,
- CreateIncomingStream,
- (QuicStreamId id),
+ MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (QuicStreamId id),
(override));
- MOCK_METHOD(QuicSpdyStream*,
- CreateIncomingStream,
- (PendingStream*),
+ MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (PendingStream*),
(override));
- MOCK_METHOD(QuicSpdyStream*,
- CreateOutgoingBidirectionalStream,
- (),
+ MOCK_METHOD(QuicSpdyStream*, CreateOutgoingBidirectionalStream, (),
(override));
- MOCK_METHOD(QuicSpdyStream*,
- CreateOutgoingUnidirectionalStream,
- (),
+ MOCK_METHOD(QuicSpdyStream*, CreateOutgoingUnidirectionalStream, (),
(override));
- MOCK_METHOD(std::vector<absl::string_view>::const_iterator,
- SelectAlpn,
- (const std::vector<absl::string_view>&),
- (const, override));
+ MOCK_METHOD(std::vector<absl::string_view>::const_iterator, SelectAlpn,
+ (const std::vector<absl::string_view>&), (const, override));
MOCK_METHOD(void, OnAlpnSelected, (absl::string_view), (override));
std::unique_ptr<QuicCryptoServerStreamBase> CreateQuicCryptoServerStream(
const QuicCryptoServerConfig* crypto_config,
@@ -1297,31 +1066,19 @@
bool IsAuthorized(const std::string& authority) override;
// QuicSpdyClientSessionBase
- MOCK_METHOD(void,
- OnProofValid,
- (const QuicCryptoClientConfig::CachedState& cached),
- (override));
- MOCK_METHOD(void,
- OnProofVerifyDetailsAvailable,
- (const ProofVerifyDetails& verify_details),
- (override));
+ MOCK_METHOD(void, OnProofValid,
+ (const QuicCryptoClientConfig::CachedState& cached), (override));
+ MOCK_METHOD(void, OnProofVerifyDetailsAvailable,
+ (const ProofVerifyDetails& verify_details), (override));
// TestQuicSpdyClientSession
- MOCK_METHOD(QuicSpdyStream*,
- CreateIncomingStream,
- (QuicStreamId id),
+ MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (QuicStreamId id),
(override));
- MOCK_METHOD(QuicSpdyStream*,
- CreateIncomingStream,
- (PendingStream*),
+ MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (PendingStream*),
(override));
- MOCK_METHOD(QuicSpdyStream*,
- CreateOutgoingBidirectionalStream,
- (),
+ MOCK_METHOD(QuicSpdyStream*, CreateOutgoingBidirectionalStream, (),
(override));
- MOCK_METHOD(QuicSpdyStream*,
- CreateOutgoingUnidirectionalStream,
- (),
+ MOCK_METHOD(QuicSpdyStream*, CreateOutgoingUnidirectionalStream, (),
(override));
MOCK_METHOD(bool, ShouldCreateIncomingStream, (QuicStreamId id), (override));
MOCK_METHOD(bool, ShouldCreateOutgoingBidirectionalStream, (), (override));
@@ -1361,24 +1118,17 @@
MockPacketWriter& operator=(const MockPacketWriter&) = delete;
~MockPacketWriter() override;
- MOCK_METHOD(WriteResult,
- WritePacket,
- (const char*,
- size_t buf_len,
- const QuicIpAddress& self_address,
- const QuicSocketAddress& peer_address,
- PerPacketOptions*),
+ MOCK_METHOD(WriteResult, WritePacket,
+ (const char*, size_t buf_len, const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address, PerPacketOptions*),
(override));
MOCK_METHOD(bool, IsWriteBlocked, (), (const, override));
MOCK_METHOD(void, SetWritable, (), (override));
- MOCK_METHOD(QuicByteCount,
- GetMaxPacketSize,
- (const QuicSocketAddress& peer_address),
- (const, override));
+ MOCK_METHOD(QuicByteCount, GetMaxPacketSize,
+ (const QuicSocketAddress& peer_address), (const, override));
MOCK_METHOD(bool, SupportsReleaseTime, (), (const, override));
MOCK_METHOD(bool, IsBatchMode, (), (const, override));
- MOCK_METHOD(QuicPacketBuffer,
- GetNextWriteLocation,
+ MOCK_METHOD(QuicPacketBuffer, GetNextWriteLocation,
(const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address),
(override));
@@ -1392,32 +1142,19 @@
MockSendAlgorithm& operator=(const MockSendAlgorithm&) = delete;
~MockSendAlgorithm() override;
- MOCK_METHOD(void,
- SetFromConfig,
- (const QuicConfig& config, Perspective perspective),
- (override));
- MOCK_METHOD(void,
- ApplyConnectionOptions,
- (const QuicTagVector& connection_options),
- (override));
- MOCK_METHOD(void,
- SetInitialCongestionWindowInPackets,
- (QuicPacketCount packets),
- (override));
- MOCK_METHOD(void,
- OnCongestionEvent,
- (bool rtt_updated,
- QuicByteCount bytes_in_flight,
- QuicTime event_time,
- const AckedPacketVector& acked_packets,
+ MOCK_METHOD(void, SetFromConfig,
+ (const QuicConfig& config, Perspective perspective), (override));
+ MOCK_METHOD(void, ApplyConnectionOptions,
+ (const QuicTagVector& connection_options), (override));
+ MOCK_METHOD(void, SetInitialCongestionWindowInPackets,
+ (QuicPacketCount packets), (override));
+ MOCK_METHOD(void, OnCongestionEvent,
+ (bool rtt_updated, QuicByteCount bytes_in_flight,
+ QuicTime event_time, const AckedPacketVector& acked_packets,
const LostPacketVector& lost_packets),
(override));
- MOCK_METHOD(void,
- OnPacketSent,
- (QuicTime,
- QuicByteCount,
- QuicPacketNumber,
- QuicByteCount,
+ MOCK_METHOD(void, OnPacketSent,
+ (QuicTime, QuicByteCount, QuicPacketNumber, QuicByteCount,
HasRetransmittableData),
(override));
MOCK_METHOD(void, OnPacketNeutered, (QuicPacketNumber), (override));
@@ -1432,18 +1169,12 @@
MOCK_METHOD(bool, InRecovery, (), (const, override));
MOCK_METHOD(bool, ShouldSendProbingPacket, (), (const, override));
MOCK_METHOD(QuicByteCount, GetSlowStartThreshold, (), (const, override));
- MOCK_METHOD(CongestionControlType,
- GetCongestionControlType,
- (),
+ MOCK_METHOD(CongestionControlType, GetCongestionControlType, (),
(const, override));
- MOCK_METHOD(void,
- AdjustNetworkParameters,
- (const NetworkParams&),
+ MOCK_METHOD(void, AdjustNetworkParameters, (const NetworkParams&),
(override));
MOCK_METHOD(void, OnApplicationLimited, (QuicByteCount), (override));
- MOCK_METHOD(void,
- PopulateConnectionStats,
- (QuicConnectionStats*),
+ MOCK_METHOD(void, PopulateConnectionStats, (QuicConnectionStats*),
(const, override));
};
@@ -1454,28 +1185,19 @@
MockLossAlgorithm& operator=(const MockLossAlgorithm&) = delete;
~MockLossAlgorithm() override;
- MOCK_METHOD(void,
- SetFromConfig,
- (const QuicConfig& config, Perspective perspective),
- (override));
+ MOCK_METHOD(void, SetFromConfig,
+ (const QuicConfig& config, Perspective perspective), (override));
- MOCK_METHOD(DetectionStats,
- DetectLosses,
- (const QuicUnackedPacketMap& unacked_packets,
- QuicTime time,
+ MOCK_METHOD(DetectionStats, DetectLosses,
+ (const QuicUnackedPacketMap& unacked_packets, QuicTime time,
const RttStats& rtt_stats,
QuicPacketNumber largest_recently_acked,
- const AckedPacketVector& packets_acked,
- LostPacketVector*),
+ const AckedPacketVector& packets_acked, LostPacketVector*),
(override));
MOCK_METHOD(QuicTime, GetLossTimeout, (), (const, override));
- MOCK_METHOD(void,
- SpuriousLossDetected,
- (const QuicUnackedPacketMap&,
- const RttStats&,
- QuicTime,
- QuicPacketNumber,
- QuicPacketNumber),
+ MOCK_METHOD(void, SpuriousLossDetected,
+ (const QuicUnackedPacketMap&, const RttStats&, QuicTime,
+ QuicPacketNumber, QuicPacketNumber),
(override));
MOCK_METHOD(void, OnConfigNegotiated, (), (override));
@@ -1491,14 +1213,10 @@
MockAckListener(const MockAckListener&) = delete;
MockAckListener& operator=(const MockAckListener&) = delete;
- MOCK_METHOD(void,
- OnPacketAcked,
- (int acked_bytes, QuicTime::Delta ack_delay_time),
- (override));
+ MOCK_METHOD(void, OnPacketAcked,
+ (int acked_bytes, QuicTime::Delta ack_delay_time), (override));
- MOCK_METHOD(void,
- OnPacketRetransmitted,
- (int retransmitted_bytes),
+ MOCK_METHOD(void, OnPacketRetransmitted, (int retransmitted_bytes),
(override));
protected:
@@ -1523,29 +1241,18 @@
MockQuicConnectionDebugVisitor();
~MockQuicConnectionDebugVisitor() override;
- MOCK_METHOD(void,
- OnPacketSent,
- (QuicPacketNumber,
- QuicPacketLength,
- bool,
- TransmissionType,
- EncryptionLevel,
- const QuicFrames&,
- const QuicFrames&,
- QuicTime),
+ MOCK_METHOD(void, OnPacketSent,
+ (QuicPacketNumber, QuicPacketLength, bool, TransmissionType,
+ EncryptionLevel, const QuicFrames&, const QuicFrames&, QuicTime),
(override));
- MOCK_METHOD(void,
- OnCoalescedPacketSent,
- (const QuicCoalescedPacket&, size_t),
+ MOCK_METHOD(void, OnCoalescedPacketSent, (const QuicCoalescedPacket&, size_t),
(override));
MOCK_METHOD(void, OnPingSent, (), (override));
- MOCK_METHOD(void,
- OnPacketReceived,
- (const QuicSocketAddress&,
- const QuicSocketAddress&,
+ MOCK_METHOD(void, OnPacketReceived,
+ (const QuicSocketAddress&, const QuicSocketAddress&,
const QuicEncryptedPacket&),
(override));
@@ -1553,83 +1260,57 @@
MOCK_METHOD(void, OnProtocolVersionMismatch, (ParsedQuicVersion), (override));
- MOCK_METHOD(void,
- OnPacketHeader,
- (const QuicPacketHeader& header,
- QuicTime receive_time,
+ MOCK_METHOD(void, OnPacketHeader,
+ (const QuicPacketHeader& header, QuicTime receive_time,
EncryptionLevel level),
(override));
- MOCK_METHOD(void,
- OnSuccessfulVersionNegotiation,
- (const ParsedQuicVersion&),
+ MOCK_METHOD(void, OnSuccessfulVersionNegotiation, (const ParsedQuicVersion&),
(override));
MOCK_METHOD(void, OnStreamFrame, (const QuicStreamFrame&), (override));
MOCK_METHOD(void, OnCryptoFrame, (const QuicCryptoFrame&), (override));
- MOCK_METHOD(void,
- OnStopWaitingFrame,
- (const QuicStopWaitingFrame&),
+ MOCK_METHOD(void, OnStopWaitingFrame, (const QuicStopWaitingFrame&),
(override));
MOCK_METHOD(void, OnRstStreamFrame, (const QuicRstStreamFrame&), (override));
- MOCK_METHOD(void,
- OnConnectionCloseFrame,
- (const QuicConnectionCloseFrame&),
+ MOCK_METHOD(void, OnConnectionCloseFrame, (const QuicConnectionCloseFrame&),
(override));
MOCK_METHOD(void, OnBlockedFrame, (const QuicBlockedFrame&), (override));
- MOCK_METHOD(void,
- OnNewConnectionIdFrame,
- (const QuicNewConnectionIdFrame&),
+ MOCK_METHOD(void, OnNewConnectionIdFrame, (const QuicNewConnectionIdFrame&),
(override));
- MOCK_METHOD(void,
- OnRetireConnectionIdFrame,
- (const QuicRetireConnectionIdFrame&),
- (override));
+ MOCK_METHOD(void, OnRetireConnectionIdFrame,
+ (const QuicRetireConnectionIdFrame&), (override));
MOCK_METHOD(void, OnNewTokenFrame, (const QuicNewTokenFrame&), (override));
MOCK_METHOD(void, OnMessageFrame, (const QuicMessageFrame&), (override));
- MOCK_METHOD(void,
- OnStopSendingFrame,
- (const QuicStopSendingFrame&),
+ MOCK_METHOD(void, OnStopSendingFrame, (const QuicStopSendingFrame&),
(override));
- MOCK_METHOD(void,
- OnPathChallengeFrame,
- (const QuicPathChallengeFrame&),
+ MOCK_METHOD(void, OnPathChallengeFrame, (const QuicPathChallengeFrame&),
(override));
- MOCK_METHOD(void,
- OnPathResponseFrame,
- (const QuicPathResponseFrame&),
+ MOCK_METHOD(void, OnPathResponseFrame, (const QuicPathResponseFrame&),
(override));
- MOCK_METHOD(void,
- OnPublicResetPacket,
- (const QuicPublicResetPacket&),
+ MOCK_METHOD(void, OnPublicResetPacket, (const QuicPublicResetPacket&),
(override));
- MOCK_METHOD(void,
- OnVersionNegotiationPacket,
- (const QuicVersionNegotiationPacket&),
+ MOCK_METHOD(void, OnVersionNegotiationPacket,
+ (const QuicVersionNegotiationPacket&), (override));
+
+ MOCK_METHOD(void, OnTransportParametersSent, (const TransportParameters&),
(override));
- MOCK_METHOD(void,
- OnTransportParametersSent,
- (const TransportParameters&),
- (override));
-
- MOCK_METHOD(void,
- OnTransportParametersReceived,
- (const TransportParameters&),
+ MOCK_METHOD(void, OnTransportParametersReceived, (const TransportParameters&),
(override));
MOCK_METHOD(void, OnZeroRttRejected, (int), (override));
@@ -1641,14 +1322,11 @@
explicit MockReceivedPacketManager(QuicConnectionStats* stats);
~MockReceivedPacketManager() override;
- MOCK_METHOD(void,
- RecordPacketReceived,
+ MOCK_METHOD(void, RecordPacketReceived,
(const QuicPacketHeader& header, QuicTime receipt_time),
(override));
MOCK_METHOD(bool, IsMissing, (QuicPacketNumber packet_number), (override));
- MOCK_METHOD(bool,
- IsAwaitingPacket,
- (QuicPacketNumber packet_number),
+ MOCK_METHOD(bool, IsAwaitingPacket, (QuicPacketNumber packet_number),
(const, override));
MOCK_METHOD(bool, HasNewMissingPackets, (), (const, override));
MOCK_METHOD(bool, ack_frame_updated, (), (const, override));
@@ -1664,22 +1342,15 @@
MOCK_METHOD(QuicPacketBuffer, GetPacketBuffer, (), (override));
MOCK_METHOD(void, OnSerializedPacket, (SerializedPacket), (override));
- MOCK_METHOD(void,
- OnUnrecoverableError,
- (QuicErrorCode, const std::string&),
+ MOCK_METHOD(void, OnUnrecoverableError, (QuicErrorCode, const std::string&),
(override));
- MOCK_METHOD(bool,
- ShouldGeneratePacket,
+ MOCK_METHOD(bool, ShouldGeneratePacket,
(HasRetransmittableData retransmittable, IsHandshake handshake),
(override));
- MOCK_METHOD(const QuicFrames,
- MaybeBundleAckOpportunistically,
- (),
+ MOCK_METHOD(const QuicFrames, MaybeBundleAckOpportunistically, (),
(override));
- MOCK_METHOD(SerializedPacketFate,
- GetSerializedPacketFate,
- (bool, EncryptionLevel),
- (override));
+ MOCK_METHOD(SerializedPacketFate, GetSerializedPacketFate,
+ (bool, EncryptionLevel), (override));
};
class MockSessionNotifier : public SessionNotifierInterface {
@@ -1687,19 +1358,13 @@
MockSessionNotifier();
~MockSessionNotifier() override;
- MOCK_METHOD(bool,
- OnFrameAcked,
- (const QuicFrame&, QuicTime::Delta, QuicTime),
+ MOCK_METHOD(bool, OnFrameAcked, (const QuicFrame&, QuicTime::Delta, QuicTime),
(override));
- MOCK_METHOD(void,
- OnStreamFrameRetransmitted,
- (const QuicStreamFrame&),
+ MOCK_METHOD(void, OnStreamFrameRetransmitted, (const QuicStreamFrame&),
(override));
MOCK_METHOD(void, OnFrameLost, (const QuicFrame&), (override));
- MOCK_METHOD(void,
- RetransmitFrames,
- (const QuicFrames&, TransmissionType type),
- (override));
+ MOCK_METHOD(void, RetransmitFrames,
+ (const QuicFrames&, TransmissionType type), (override));
MOCK_METHOD(bool, IsFrameOutstanding, (const QuicFrame&), (const, override));
MOCK_METHOD(bool, HasUnackedCryptoData, (), (const, override));
MOCK_METHOD(bool, HasUnackedStreamData, (), (const, override));
@@ -1711,8 +1376,7 @@
const QuicSocketAddress& peer_address,
const QuicSocketAddress& effective_peer_address,
QuicPacketWriter* writer)
- : QuicPathValidationContext(self_address,
- peer_address,
+ : QuicPathValidationContext(self_address, peer_address,
effective_peer_address),
writer_(writer) {}
QuicPacketWriter* WriterToUse() override { return writer_; }
@@ -1724,15 +1388,11 @@
class MockQuicPathValidationResultDelegate
: public QuicPathValidator::ResultDelegate {
public:
- MOCK_METHOD(void,
- OnPathValidationSuccess,
- (std::unique_ptr<QuicPathValidationContext>),
- (override));
+ MOCK_METHOD(void, OnPathValidationSuccess,
+ (std::unique_ptr<QuicPathValidationContext>), (override));
- MOCK_METHOD(void,
- OnPathValidationFailure,
- (std::unique_ptr<QuicPathValidationContext>),
- (override));
+ MOCK_METHOD(void, OnPathValidationFailure,
+ (std::unique_ptr<QuicPathValidationContext>), (override));
};
class QuicCryptoClientStreamPeer {
@@ -1759,11 +1419,9 @@
// client_session: Pointer reference for the newly created client
// session. The new object will be owned by the caller.
void CreateClientSessionForTest(
- QuicServerId server_id,
- QuicTime::Delta connection_start_time,
+ QuicServerId server_id, QuicTime::Delta connection_start_time,
const ParsedQuicVersionVector& supported_versions,
- MockQuicConnectionHelper* helper,
- MockAlarmFactory* alarm_factory,
+ MockQuicConnectionHelper* helper, MockAlarmFactory* alarm_factory,
QuicCryptoClientConfig* crypto_client_config,
PacketSavingConnection** client_connection,
TestQuicSpdyClientSession** client_session);
@@ -1784,11 +1442,9 @@
// server_session: Pointer reference for the newly created server
// session. The new object will be owned by the caller.
void CreateServerSessionForTest(
- QuicServerId server_id,
- QuicTime::Delta connection_start_time,
+ QuicServerId server_id, QuicTime::Delta connection_start_time,
ParsedQuicVersionVector supported_versions,
- MockQuicConnectionHelper* helper,
- MockAlarmFactory* alarm_factory,
+ MockQuicConnectionHelper* helper, MockAlarmFactory* alarm_factory,
QuicCryptoServerConfig* crypto_server_config,
QuicCompressedCertsCache* compressed_certs_cache,
PacketSavingConnection** server_connection,
@@ -1840,22 +1496,16 @@
// HTTP stream numbering scheme (i.e. whether one or two QUIC streams are used
// per HTTP transaction).
QuicStreamId GetNthClientInitiatedBidirectionalStreamId(
- QuicTransportVersion version,
- int n);
+ QuicTransportVersion version, int n);
QuicStreamId GetNthServerInitiatedBidirectionalStreamId(
- QuicTransportVersion version,
- int n);
+ QuicTransportVersion version, int n);
QuicStreamId GetNthServerInitiatedUnidirectionalStreamId(
- QuicTransportVersion version,
- int n);
+ QuicTransportVersion version, int n);
QuicStreamId GetNthClientInitiatedUnidirectionalStreamId(
- QuicTransportVersion version,
- int n);
+ QuicTransportVersion version, int n);
-StreamType DetermineStreamType(QuicStreamId id,
- ParsedQuicVersion version,
- Perspective perspective,
- bool is_incoming,
+StreamType DetermineStreamType(QuicStreamId id, ParsedQuicVersion version,
+ Perspective perspective, bool is_incoming,
StreamType default_type);
// Creates a MemSlice using a singleton trivial buffer allocator. Performs a
@@ -1871,15 +1521,12 @@
return arg.destination_connection_id == destination_connection_id;
}
-MATCHER_P2(InRange, min, max, "") {
- return arg >= min && arg <= max;
-}
+MATCHER_P2(InRange, min, max, "") { return arg >= min && arg <= max; }
// A GMock matcher that prints expected and actual QuicErrorCode strings
// upon failure. Example usage:
// EXPECT_THAT(stream_->connection_error(), IsError(QUIC_INTERNAL_ERROR));
-MATCHER_P(IsError,
- expected,
+MATCHER_P(IsError, expected,
absl::StrCat(negation ? "isn't equal to " : "is equal to ",
QuicErrorCodeToString(expected))) {
*result_listener << QuicErrorCodeToString(static_cast<QuicErrorCode>(arg));
@@ -1898,8 +1545,7 @@
// A GMock matcher that prints expected and actual QuicRstStreamErrorCode
// strings upon failure. Example usage:
// EXPECT_THAT(stream_->stream_error(), IsStreamError(QUIC_INTERNAL_ERROR));
-MATCHER_P(IsStreamError,
- expected,
+MATCHER_P(IsStreamError, expected,
absl::StrCat(negation ? "isn't equal to " : "is equal to ",
QuicRstStreamErrorCodeToString(expected))) {
*result_listener << QuicRstStreamErrorCodeToString(arg);
@@ -1937,12 +1583,9 @@
return true;
}
- bool EncryptPacket(uint64_t packet_number,
- absl::string_view associated_data,
- absl::string_view plaintext,
- char* output,
- size_t* output_length,
- size_t max_output_length) override;
+ bool EncryptPacket(uint64_t packet_number, absl::string_view associated_data,
+ absl::string_view plaintext, char* output,
+ size_t* output_length, size_t max_output_length) override;
std::string GenerateHeaderProtectionMask(
absl::string_view /*sample*/) override {
@@ -2007,12 +1650,9 @@
return true;
}
- bool DecryptPacket(uint64_t packet_number,
- absl::string_view associated_data,
- absl::string_view ciphertext,
- char* output,
- size_t* output_length,
- size_t max_output_length) override;
+ bool DecryptPacket(uint64_t packet_number, absl::string_view associated_data,
+ absl::string_view ciphertext, char* output,
+ size_t* output_length, size_t max_output_length) override;
std::string GenerateHeaderProtectionMask(
QuicDataReader* /*sample_reader*/) override {
@@ -2069,8 +1709,7 @@
};
public:
- TestPacketWriter(ParsedQuicVersion version,
- MockClock* clock,
+ TestPacketWriter(ParsedQuicVersion version, MockClock* clock,
Perspective perspective);
TestPacketWriter(const TestPacketWriter&) = delete;
@@ -2079,8 +1718,7 @@
~TestPacketWriter() override;
// QuicPacketWriter interface
- WriteResult WritePacket(const char* buffer,
- size_t buf_len,
+ WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
PerPacketOptions* options) override;
@@ -2306,8 +1944,7 @@
// contents of the destination connection ID passed in to
// WriteClientVersionNegotiationProbePacket.
bool ParseClientVersionNegotiationProbePacket(
- const char* packet_bytes,
- size_t packet_length,
+ const char* packet_bytes, size_t packet_length,
char* destination_connection_id_bytes,
uint8_t* destination_connection_id_length_out);
@@ -2320,8 +1957,7 @@
// the source connection ID, and must point to |source_connection_id_length|
// bytes of memory.
bool WriteServerVersionNegotiationProbeResponse(
- char* packet_bytes,
- size_t* packet_length_out,
+ char* packet_bytes, size_t* packet_length_out,
const char* source_connection_id_bytes,
uint8_t source_connection_id_length);
diff --git a/quic/tools/quic_simple_server_session.cc b/quic/tools/quic_simple_server_session.cc
index 688ca9f..52bf79c 100644
--- a/quic/tools/quic_simple_server_session.cc
+++ b/quic/tools/quic_simple_server_session.cc
@@ -18,30 +18,21 @@
namespace quic {
QuicSimpleServerSession::QuicSimpleServerSession(
- const QuicConfig& config,
- const ParsedQuicVersionVector& supported_versions,
- QuicConnection* connection,
- QuicSession::Visitor* visitor,
+ const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
+ QuicConnection* connection, QuicSession::Visitor* visitor,
QuicCryptoServerStreamBase::Helper* helper,
const QuicCryptoServerConfig* crypto_config,
QuicCompressedCertsCache* compressed_certs_cache,
QuicSimpleServerBackend* quic_simple_server_backend)
- : QuicServerSessionBase(config,
- supported_versions,
- connection,
- visitor,
- helper,
- crypto_config,
- compressed_certs_cache),
+ : QuicServerSessionBase(config, supported_versions, connection, visitor,
+ helper, crypto_config, compressed_certs_cache),
highest_promised_stream_id_(
QuicUtils::GetInvalidStreamId(connection->transport_version())),
quic_simple_server_backend_(quic_simple_server_backend) {
QUICHE_DCHECK(quic_simple_server_backend_);
}
-QuicSimpleServerSession::~QuicSimpleServerSession() {
- DeleteConnection();
-}
+QuicSimpleServerSession::~QuicSimpleServerSession() { DeleteConnection(); }
std::unique_ptr<QuicCryptoServerStreamBase>
QuicSimpleServerSession::CreateQuicCryptoServerStream(
@@ -151,8 +142,7 @@
}
spdy::Http2HeaderBlock QuicSimpleServerSession::SynthesizePushRequestHeaders(
- std::string request_url,
- QuicBackendResponse::ServerPushInfo resource,
+ std::string request_url, QuicBackendResponse::ServerPushInfo resource,
const spdy::Http2HeaderBlock& original_request_headers) {
QuicUrl push_request_url = resource.request_url;
diff --git a/quic/tools/quic_simple_server_stream_test.cc b/quic/tools/quic_simple_server_stream_test.cc
index 5c9cd22..50b20b2 100644
--- a/quic/tools/quic_simple_server_stream_test.cc
+++ b/quic/tools/quic_simple_server_stream_test.cc
@@ -48,13 +48,9 @@
class TestStream : public QuicSimpleServerStream {
public:
- TestStream(QuicStreamId stream_id,
- QuicSpdySession* session,
- StreamType type,
+ TestStream(QuicStreamId stream_id, QuicSpdySession* session, StreamType type,
QuicSimpleServerBackend* quic_simple_server_backend)
- : QuicSimpleServerStream(stream_id,
- session,
- type,
+ : QuicSimpleServerStream(stream_id, session, type,
quic_simple_server_backend) {}
~TestStream() override = default;
@@ -62,8 +58,7 @@
MOCK_METHOD(void, WriteHeadersMock, (bool fin), ());
MOCK_METHOD(void, WriteEarlyHintsHeadersMock, (bool fin), ());
- size_t WriteHeaders(spdy::Http2HeaderBlock header_block,
- bool fin,
+ size_t WriteHeaders(spdy::Http2HeaderBlock header_block, bool fin,
QuicReferenceCountedPointer<QuicAckListenerInterface>
/*ack_listener*/) override {
if (header_block[":status"] == "103") {
@@ -116,18 +111,13 @@
const size_t kMaxStreamsForTest = 100;
MockQuicSimpleServerSession(
- QuicConnection* connection,
- MockQuicSessionVisitor* owner,
+ QuicConnection* connection, MockQuicSessionVisitor* owner,
MockQuicCryptoServerStreamHelper* helper,
QuicCryptoServerConfig* crypto_config,
QuicCompressedCertsCache* compressed_certs_cache,
QuicSimpleServerBackend* quic_simple_server_backend)
- : QuicSimpleServerSession(DefaultQuicConfig(),
- CurrentSupportedVersions(),
- connection,
- owner,
- helper,
- crypto_config,
+ : QuicSimpleServerSession(DefaultQuicConfig(), CurrentSupportedVersions(),
+ connection, owner, helper, crypto_config,
compressed_certs_cache,
quic_simple_server_backend) {
if (VersionHasIetfQuicFrames(connection->transport_version())) {
@@ -148,47 +138,36 @@
delete;
~MockQuicSimpleServerSession() override = default;
- MOCK_METHOD(void,
- OnConnectionClosed,
+ MOCK_METHOD(void, OnConnectionClosed,
(const QuicConnectionCloseFrame& frame,
ConnectionCloseSource source),
(override));
- MOCK_METHOD(QuicSpdyStream*,
- CreateIncomingStream,
- (QuicStreamId id),
+ MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (QuicStreamId id),
(override));
MOCK_METHOD(QuicConsumedData, WritevData,
(QuicStreamId id, size_t write_length, QuicStreamOffset offset,
StreamSendingState state, TransmissionType type,
EncryptionLevel level),
(override));
- MOCK_METHOD(void,
- OnStreamHeaderList,
- (QuicStreamId stream_id,
- bool fin,
- size_t frame_len,
+ MOCK_METHOD(void, OnStreamHeaderList,
+ (QuicStreamId stream_id, bool fin, size_t frame_len,
const QuicHeaderList& header_list),
(override));
- MOCK_METHOD(void,
- OnStreamHeadersPriority,
+ MOCK_METHOD(void, OnStreamHeadersPriority,
(QuicStreamId stream_id,
const spdy::SpdyStreamPrecedence& precedence),
(override));
- MOCK_METHOD(void,
- MaybeSendRstStreamFrame,
- (QuicStreamId stream_id,
- QuicRstStreamErrorCode error,
+ MOCK_METHOD(void, MaybeSendRstStreamFrame,
+ (QuicStreamId stream_id, QuicRstStreamErrorCode error,
QuicStreamOffset bytes_written),
(override));
- MOCK_METHOD(void,
- MaybeSendStopSendingFrame,
+ MOCK_METHOD(void, MaybeSendStopSendingFrame,
(QuicStreamId stream_id, QuicRstStreamErrorCode error),
(override));
using QuicSession::ActivateStream;
- QuicConsumedData ConsumeData(QuicStreamId id,
- size_t write_length,
+ QuicConsumedData ConsumeData(QuicStreamId id, size_t write_length,
QuicStreamOffset offset,
StreamSendingState state,
TransmissionType /*type*/,
@@ -211,23 +190,17 @@
class QuicSimpleServerStreamTest : public QuicTestWithParam<ParsedQuicVersion> {
public:
QuicSimpleServerStreamTest()
- : connection_(
- new StrictMock<MockQuicConnection>(&helper_,
- &alarm_factory_,
- Perspective::IS_SERVER,
- SupportedVersions(GetParam()))),
+ : connection_(new StrictMock<MockQuicConnection>(
+ &helper_, &alarm_factory_, Perspective::IS_SERVER,
+ SupportedVersions(GetParam()))),
crypto_config_(new QuicCryptoServerConfig(
- QuicCryptoServerConfig::TESTING,
- QuicRandom::GetInstance(),
+ QuicCryptoServerConfig::TESTING, QuicRandom::GetInstance(),
crypto_test_utils::ProofSourceForTesting(),
KeyExchangeSource::Default())),
compressed_certs_cache_(
QuicCompressedCertsCache::kQuicCompressedCertsCacheSize),
- session_(connection_,
- &session_owner_,
- &session_helper_,
- crypto_config_.get(),
- &compressed_certs_cache_,
+ session_(connection_, &session_owner_, &session_helper_,
+ crypto_config_.get(), &compressed_certs_cache_,
&memory_cache_backend_),
quic_response_(new QuicBackendResponse),
body_("hello world") {
@@ -298,8 +271,7 @@
QuicHeaderList header_list_;
};
-INSTANTIATE_TEST_SUITE_P(Tests,
- QuicSimpleServerStreamTest,
+INSTANTIATE_TEST_SUITE_P(Tests, QuicSimpleServerStreamTest,
::testing::ValuesIn(AllSupportedVersions()),
::testing::PrintToStringParamName());
