clang-format QUICHE
Run clang-format on *.h and *.cc file in QUICHE.
PiperOrigin-RevId: 441164393
Change-Id: Id0429dd8c7a9a5b16d858c4d45a37e3567c61fdc
diff --git a/quiche/quic/test_tools/bad_packet_writer.cc b/quiche/quic/test_tools/bad_packet_writer.cc
index 114e136..1e146c4 100644
--- a/quiche/quic/test_tools/bad_packet_writer.cc
+++ b/quiche/quic/test_tools/bad_packet_writer.cc
@@ -14,8 +14,7 @@
BadPacketWriter::~BadPacketWriter() {}
-WriteResult BadPacketWriter::WritePacket(const char* buffer,
- size_t buf_len,
+WriteResult BadPacketWriter::WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
PerPacketOptions* options) {
diff --git a/quiche/quic/test_tools/bad_packet_writer.h b/quiche/quic/test_tools/bad_packet_writer.h
index 7ba8383..bcf12f5 100644
--- a/quiche/quic/test_tools/bad_packet_writer.h
+++ b/quiche/quic/test_tools/bad_packet_writer.h
@@ -18,8 +18,7 @@
~BadPacketWriter() override;
- 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;
diff --git a/quiche/quic/test_tools/crypto_test_utils.cc b/quiche/quic/test_tools/crypto_test_utils.cc
index 89c254b..e2f5c8c 100644
--- a/quiche/quic/test_tools/crypto_test_utils.cc
+++ b/quiche/quic/test_tools/crypto_test_utils.cc
@@ -157,8 +157,7 @@
public:
explicit ProcessClientHelloCallback(FullChloGenerator* generator)
: generator_(generator) {}
- void Run(QuicErrorCode error,
- const std::string& error_details,
+ void Run(QuicErrorCode error, const std::string& error_details,
std::unique_ptr<CryptoHandshakeMessage> message,
std::unique_ptr<DiversificationNonce> /*diversification_nonce*/,
std::unique_ptr<ProofSource::Details> /*proof_source_details*/)
@@ -338,8 +337,7 @@
return client_session.GetCryptoStream()->num_sent_client_hellos();
}
-void SetupCryptoServerConfigForTest(const QuicClock* clock,
- QuicRandom* rand,
+void SetupCryptoServerConfigForTest(const QuicClock* clock, QuicRandom* rand,
QuicCryptoServerConfig* crypto_config) {
QuicCryptoServerConfig::ConfigOptions options;
options.channel_id_enabled = true;
@@ -562,8 +560,7 @@
}
void CompareCrypters(const QuicEncrypter* encrypter,
- const QuicDecrypter* decrypter,
- std::string label) {
+ const QuicDecrypter* decrypter, std::string label) {
if (encrypter == nullptr || decrypter == nullptr) {
ADD_FAILURE() << "Expected non-null crypters; have " << encrypter << " and "
<< decrypter << " for " << label;
@@ -702,8 +699,7 @@
}
void MovePackets(PacketSavingConnection* source_conn,
- size_t* inout_packet_index,
- QuicCryptoStream* dest_stream,
+ size_t* inout_packet_index, QuicCryptoStream* dest_stream,
PacketSavingConnection* dest_conn,
Perspective dest_perspective) {
SimpleQuicFramer framer(source_conn->supported_versions(), dest_perspective);
@@ -795,8 +791,7 @@
}
CryptoHandshakeMessage GenerateDefaultInchoateCHLO(
- const QuicClock* clock,
- QuicTransportVersion version,
+ const QuicClock* clock, QuicTransportVersion version,
QuicCryptoServerConfig* crypto_config) {
// clang-format off
return CreateCHLO(
diff --git a/quiche/quic/test_tools/crypto_test_utils.h b/quiche/quic/test_tools/crypto_test_utils.h
index db54d5c..a1cd35e 100644
--- a/quiche/quic/test_tools/crypto_test_utils.h
+++ b/quiche/quic/test_tools/crypto_test_utils.h
@@ -86,13 +86,11 @@
PacketSavingConnection* server_conn,
QuicCryptoServerStreamBase* server,
const QuicServerId& server_id,
- const FakeClientOptions& options,
- std::string alpn);
+ const FakeClientOptions& options, std::string alpn);
// SetupCryptoServerConfigForTest configures |crypto_config|
// with sensible defaults for testing.
-void SetupCryptoServerConfigForTest(const QuicClock* clock,
- QuicRandom* rand,
+void SetupCryptoServerConfigForTest(const QuicClock* clock, QuicRandom* rand,
QuicCryptoServerConfig* crypto_config);
// Sends the handshake message |message| to stream |stream| with the perspective
@@ -177,15 +175,13 @@
// to decrypt) and has |dest_stream| process them. |*inout_packet_index| is
// updated with an index one greater than the last packet processed.
void MovePackets(PacketSavingConnection* source_conn,
- size_t* inout_packet_index,
- QuicCryptoStream* dest_stream,
+ size_t* inout_packet_index, QuicCryptoStream* dest_stream,
PacketSavingConnection* dest_conn,
Perspective dest_perspective);
// Return an inchoate CHLO with some basic tag value pairs.
CryptoHandshakeMessage GenerateDefaultInchoateCHLO(
- const QuicClock* clock,
- QuicTransportVersion version,
+ const QuicClock* clock, QuicTransportVersion version,
QuicCryptoServerConfig* crypto_config);
// Takes a inchoate CHLO, returns a full CHLO in |out| which can pass
diff --git a/quiche/quic/test_tools/crypto_test_utils_test.cc b/quiche/quic/test_tools/crypto_test_utils_test.cc
index 200f5be..0522175 100644
--- a/quiche/quic/test_tools/crypto_test_utils_test.cc
+++ b/quiche/quic/test_tools/crypto_test_utils_test.cc
@@ -72,8 +72,7 @@
public:
explicit ProcessClientHelloCallback(ShloVerifier* shlo_verifier)
: shlo_verifier_(shlo_verifier) {}
- void Run(QuicErrorCode /*error*/,
- const std::string& /*error_details*/,
+ void Run(QuicErrorCode /*error*/, const std::string& /*error_details*/,
std::unique_ptr<CryptoHandshakeMessage> message,
std::unique_ptr<DiversificationNonce> /*diversification_nonce*/,
std::unique_ptr<ProofSource::Details> /*proof_source_details*/)
diff --git a/quiche/quic/test_tools/failing_proof_source.cc b/quiche/quic/test_tools/failing_proof_source.cc
index b16ef50..55ae06e 100644
--- a/quiche/quic/test_tools/failing_proof_source.cc
+++ b/quiche/quic/test_tools/failing_proof_source.cc
@@ -31,10 +31,8 @@
void FailingProofSource::ComputeTlsSignature(
const QuicSocketAddress& /*server_address*/,
const QuicSocketAddress& /*client_address*/,
- const std::string& /*hostname*/,
- uint16_t /*signature_algorithm*/,
- absl::string_view /*in*/,
- std::unique_ptr<SignatureCallback> callback) {
+ const std::string& /*hostname*/, uint16_t /*signature_algorithm*/,
+ absl::string_view /*in*/, std::unique_ptr<SignatureCallback> callback) {
callback->Run(false, "", nullptr);
}
diff --git a/quiche/quic/test_tools/failing_proof_source.h b/quiche/quic/test_tools/failing_proof_source.h
index 6ab29ac..f9fe973 100644
--- a/quiche/quic/test_tools/failing_proof_source.h
+++ b/quiche/quic/test_tools/failing_proof_source.h
@@ -15,8 +15,7 @@
public:
void GetProof(const QuicSocketAddress& server_address,
const QuicSocketAddress& client_address,
- const std::string& hostname,
- const std::string& server_config,
+ const std::string& hostname, const std::string& server_config,
QuicTransportVersion transport_version,
absl::string_view chlo_hash,
std::unique_ptr<Callback> callback) override;
@@ -28,10 +27,8 @@
void ComputeTlsSignature(
const QuicSocketAddress& server_address,
- const QuicSocketAddress& client_address,
- const std::string& hostname,
- uint16_t signature_algorithm,
- absl::string_view in,
+ const QuicSocketAddress& client_address, const std::string& hostname,
+ uint16_t signature_algorithm, absl::string_view in,
std::unique_ptr<SignatureCallback> callback) override;
absl::InlinedVector<uint16_t, 8> SupportedTlsSignatureAlgorithms()
diff --git a/quiche/quic/test_tools/fake_proof_source.cc b/quiche/quic/test_tools/fake_proof_source.cc
index 8ae9592..43c5a72 100644
--- a/quiche/quic/test_tools/fake_proof_source.cc
+++ b/quiche/quic/test_tools/fake_proof_source.cc
@@ -22,12 +22,9 @@
FakeProofSource::GetProofOp::GetProofOp(
const QuicSocketAddress& server_addr,
- const QuicSocketAddress& client_address,
- std::string hostname,
- std::string server_config,
- QuicTransportVersion transport_version,
- std::string chlo_hash,
- std::unique_ptr<ProofSource::Callback> callback,
+ const QuicSocketAddress& client_address, std::string hostname,
+ std::string server_config, QuicTransportVersion transport_version,
+ std::string chlo_hash, std::unique_ptr<ProofSource::Callback> callback,
ProofSource* delegate)
: server_address_(server_addr),
client_address_(client_address),
@@ -49,10 +46,8 @@
FakeProofSource::ComputeSignatureOp::ComputeSignatureOp(
const QuicSocketAddress& server_address,
- const QuicSocketAddress& client_address,
- std::string hostname,
- uint16_t sig_alg,
- absl::string_view in,
+ const QuicSocketAddress& client_address, std::string hostname,
+ uint16_t sig_alg, absl::string_view in,
std::unique_ptr<ProofSource::SignatureCallback> callback,
ProofSource* delegate)
: server_address_(server_address),
@@ -70,16 +65,12 @@
sig_alg_, in_, std::move(callback_));
}
-void FakeProofSource::Activate() {
- active_ = true;
-}
+void FakeProofSource::Activate() { active_ = true; }
void FakeProofSource::GetProof(
const QuicSocketAddress& server_address,
- const QuicSocketAddress& client_address,
- const std::string& hostname,
- const std::string& server_config,
- QuicTransportVersion transport_version,
+ const QuicSocketAddress& client_address, const std::string& hostname,
+ const std::string& server_config, QuicTransportVersion transport_version,
absl::string_view chlo_hash,
std::unique_ptr<ProofSource::Callback> callback) {
if (!active_) {
@@ -105,10 +96,8 @@
void FakeProofSource::ComputeTlsSignature(
const QuicSocketAddress& server_address,
- const QuicSocketAddress& client_address,
- const std::string& hostname,
- uint16_t signature_algorithm,
- absl::string_view in,
+ const QuicSocketAddress& client_address, const std::string& hostname,
+ uint16_t signature_algorithm, absl::string_view in,
std::unique_ptr<ProofSource::SignatureCallback> callback) {
QUIC_LOG(INFO) << "FakeProofSource::ComputeTlsSignature";
if (!active_) {
@@ -142,9 +131,7 @@
ticket_crypter_ = std::move(ticket_crypter);
}
-int FakeProofSource::NumPendingCallbacks() const {
- return pending_ops_.size();
-}
+int FakeProofSource::NumPendingCallbacks() const { return pending_ops_.size(); }
void FakeProofSource::InvokePendingCallback(int n) {
QUICHE_CHECK(NumPendingCallbacks() > n);
diff --git a/quiche/quic/test_tools/fake_proof_source.h b/quiche/quic/test_tools/fake_proof_source.h
index f2f5cc6..b0069af 100644
--- a/quiche/quic/test_tools/fake_proof_source.h
+++ b/quiche/quic/test_tools/fake_proof_source.h
@@ -36,8 +36,7 @@
// ProofSource interface
void GetProof(const QuicSocketAddress& server_address,
const QuicSocketAddress& client_address,
- const std::string& hostname,
- const std::string& server_config,
+ const std::string& hostname, const std::string& server_config,
QuicTransportVersion transport_version,
absl::string_view chlo_hash,
std::unique_ptr<ProofSource::Callback> callback) override;
@@ -47,10 +46,8 @@
bool* cert_matched_sni) override;
void ComputeTlsSignature(
const QuicSocketAddress& server_address,
- const QuicSocketAddress& client_address,
- const std::string& hostname,
- uint16_t signature_algorithm,
- absl::string_view in,
+ const QuicSocketAddress& client_address, const std::string& hostname,
+ uint16_t signature_algorithm, absl::string_view in,
std::unique_ptr<ProofSource::SignatureCallback> callback) override;
absl::InlinedVector<uint16_t, 8> SupportedTlsSignatureAlgorithms()
const override;
@@ -81,11 +78,9 @@
class GetProofOp : public PendingOp {
public:
GetProofOp(const QuicSocketAddress& server_addr,
- const QuicSocketAddress& client_address,
- std::string hostname,
+ const QuicSocketAddress& client_address, std::string hostname,
std::string server_config,
- QuicTransportVersion transport_version,
- std::string chlo_hash,
+ QuicTransportVersion transport_version, std::string chlo_hash,
std::unique_ptr<ProofSource::Callback> callback,
ProofSource* delegate);
~GetProofOp() override;
@@ -107,8 +102,7 @@
public:
ComputeSignatureOp(const QuicSocketAddress& server_address,
const QuicSocketAddress& client_address,
- std::string hostname,
- uint16_t sig_alg,
+ std::string hostname, uint16_t sig_alg,
absl::string_view in,
std::unique_ptr<ProofSource::SignatureCallback> callback,
ProofSource* delegate);
diff --git a/quiche/quic/test_tools/fake_proof_source_handle.cc b/quiche/quic/test_tools/fake_proof_source_handle.cc
index 0736b99..07c78fc 100644
--- a/quiche/quic/test_tools/fake_proof_source_handle.cc
+++ b/quiche/quic/test_tools/fake_proof_source_handle.cc
@@ -3,6 +3,7 @@
// found in the LICENSE file.
#include "quiche/quic/test_tools/fake_proof_source_handle.h"
+
#include "quiche/quic/core/quic_types.h"
#include "quiche/quic/platform/api/quic_bug_tracker.h"
@@ -24,8 +25,7 @@
: result_(result) {
QUICHE_DCHECK(!result_->has_value());
}
- void Run(bool ok,
- std::string signature,
+ void Run(bool ok, std::string signature,
std::unique_ptr<ProofSource::Details> details) override {
result_->emplace(
ComputeSignatureResult{ok, std::move(signature), std::move(details)});
@@ -36,12 +36,9 @@
};
ComputeSignatureResult ComputeSignatureNow(
- ProofSource* delegate,
- const QuicSocketAddress& server_address,
- const QuicSocketAddress& client_address,
- const std::string& hostname,
- uint16_t signature_algorithm,
- absl::string_view in) {
+ ProofSource* delegate, const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address, const std::string& hostname,
+ uint16_t signature_algorithm, absl::string_view in) {
absl::optional<ComputeSignatureResult> result;
delegate->ComputeTlsSignature(
server_address, client_address, hostname, signature_algorithm, in,
@@ -71,12 +68,9 @@
QuicAsyncStatus FakeProofSourceHandle::SelectCertificate(
const QuicSocketAddress& server_address,
- const QuicSocketAddress& client_address,
- absl::string_view ssl_capabilities,
- const std::string& hostname,
- absl::string_view client_hello,
- const std::string& alpn,
- absl::optional<std::string> alps,
+ const QuicSocketAddress& client_address, absl::string_view ssl_capabilities,
+ const std::string& hostname, absl::string_view client_hello,
+ const std::string& alpn, absl::optional<std::string> alps,
const std::vector<uint8_t>& quic_transport_params,
const absl::optional<std::vector<uint8_t>>& early_data_context,
const QuicSSLConfig& ssl_config) {
@@ -119,10 +113,8 @@
QuicAsyncStatus FakeProofSourceHandle::ComputeSignature(
const QuicSocketAddress& server_address,
- const QuicSocketAddress& client_address,
- const std::string& hostname,
- uint16_t signature_algorithm,
- absl::string_view in,
+ const QuicSocketAddress& client_address, const std::string& hostname,
+ uint16_t signature_algorithm, absl::string_view in,
size_t max_signature_size) {
if (compute_signature_action_ != Action::FAIL_SYNC_DO_NOT_CHECK_CLOSED) {
QUICHE_CHECK(!closed_);
@@ -213,9 +205,7 @@
}
FakeProofSourceHandle::ComputeSignatureOperation::ComputeSignatureOperation(
- ProofSource* delegate,
- ProofSourceHandleCallback* callback,
- Action action,
+ ProofSource* delegate, ProofSourceHandleCallback* callback, Action action,
ComputeSignatureArgs args)
: PendingOperation(delegate, callback, action), args_(std::move(args)) {}
diff --git a/quiche/quic/test_tools/fake_proof_source_handle.h b/quiche/quic/test_tools/fake_proof_source_handle.h
index ac0d184..25a7e27 100644
--- a/quiche/quic/test_tools/fake_proof_source_handle.h
+++ b/quiche/quic/test_tools/fake_proof_source_handle.h
@@ -43,10 +43,8 @@
QuicAsyncStatus SelectCertificate(
const QuicSocketAddress& server_address,
const QuicSocketAddress& client_address,
- absl::string_view ssl_capabilities,
- const std::string& hostname,
- absl::string_view client_hello,
- const std::string& alpn,
+ absl::string_view ssl_capabilities, const std::string& hostname,
+ absl::string_view client_hello, const std::string& alpn,
absl::optional<std::string> alps,
const std::vector<uint8_t>& quic_transport_params,
const absl::optional<std::vector<uint8_t>>& early_data_context,
@@ -68,10 +66,8 @@
struct SelectCertArgs {
SelectCertArgs(QuicSocketAddress server_address,
QuicSocketAddress client_address,
- absl::string_view ssl_capabilities,
- std::string hostname,
- absl::string_view client_hello,
- std::string alpn,
+ absl::string_view ssl_capabilities, std::string hostname,
+ absl::string_view client_hello, std::string alpn,
absl::optional<std::string> alps,
std::vector<uint8_t> quic_transport_params,
absl::optional<std::vector<uint8_t>> early_data_context,
@@ -101,10 +97,8 @@
struct ComputeSignatureArgs {
ComputeSignatureArgs(QuicSocketAddress server_address,
- QuicSocketAddress client_address,
- std::string hostname,
- uint16_t signature_algorithm,
- absl::string_view in,
+ QuicSocketAddress client_address, std::string hostname,
+ uint16_t signature_algorithm, absl::string_view in,
size_t max_signature_size)
: server_address(server_address),
client_address(client_address),
@@ -132,8 +126,7 @@
private:
class PendingOperation {
public:
- PendingOperation(ProofSource* delegate,
- ProofSourceHandleCallback* callback,
+ PendingOperation(ProofSource* delegate, ProofSourceHandleCallback* callback,
Action action)
: delegate_(delegate), callback_(callback), action_(action) {}
virtual ~PendingOperation() = default;
@@ -165,8 +158,7 @@
public:
ComputeSignatureOperation(ProofSource* delegate,
ProofSourceHandleCallback* callback,
- Action action,
- ComputeSignatureArgs args);
+ Action action, ComputeSignatureArgs args);
~ComputeSignatureOperation() override = default;
diff --git a/quiche/quic/test_tools/first_flight.cc b/quiche/quic/test_tools/first_flight.cc
index 2f70943..5965734 100644
--- a/quiche/quic/test_tools/first_flight.cc
+++ b/quiche/quic/test_tools/first_flight.cc
@@ -70,8 +70,7 @@
session_->CryptoConnect();
}
- void OnDelegatedPacket(const char* buffer,
- size_t buf_len,
+ void OnDelegatedPacket(const char* buffer, size_t buf_len,
const QuicIpAddress& /*self_client_address*/,
const QuicSocketAddress& /*peer_client_address*/,
PerPacketOptions* /*options*/) override {
@@ -114,8 +113,7 @@
}
std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
- const ParsedQuicVersion& version,
- const QuicConfig& config,
+ const ParsedQuicVersion& version, const QuicConfig& config,
const QuicConnectionId& server_connection_id,
const QuicConnectionId& client_connection_id) {
FirstFlightExtractor first_flight_extractor(
@@ -125,16 +123,14 @@
}
std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
- const ParsedQuicVersion& version,
- const QuicConfig& config,
+ const ParsedQuicVersion& version, const QuicConfig& config,
const QuicConnectionId& server_connection_id) {
return GetFirstFlightOfPackets(version, config, server_connection_id,
EmptyQuicConnectionId());
}
std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
- const ParsedQuicVersion& version,
- const QuicConfig& config) {
+ const ParsedQuicVersion& version, const QuicConfig& config) {
return GetFirstFlightOfPackets(version, config, TestConnectionId());
}
diff --git a/quiche/quic/test_tools/first_flight.h b/quiche/quic/test_tools/first_flight.h
index b6118ba..bc82657 100644
--- a/quiche/quic/test_tools/first_flight.h
+++ b/quiche/quic/test_tools/first_flight.h
@@ -28,8 +28,7 @@
virtual ~Delegate() {}
// Note that |buffer| may be released after this call completes so overrides
// that want to use the data after the call is complete MUST copy it.
- virtual void OnDelegatedPacket(const char* buffer,
- size_t buf_len,
+ virtual void OnDelegatedPacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_client_address,
const QuicSocketAddress& peer_client_address,
PerPacketOptions* options) = 0;
@@ -60,8 +59,7 @@
}
WriteResult Flush() override { return WriteResult(WRITE_STATUS_OK, 0); }
- WriteResult WritePacket(const char* buffer,
- size_t buf_len,
+ WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_client_address,
const QuicSocketAddress& peer_client_address,
PerPacketOptions* options) override {
@@ -96,8 +94,7 @@
const QuicConnectionId& client_connection_id);
std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
- const ParsedQuicVersion& version,
- const QuicConfig& config,
+ const ParsedQuicVersion& version, const QuicConfig& config,
const QuicConnectionId& server_connection_id);
std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
@@ -110,8 +107,7 @@
const QuicConnectionId& server_connection_id);
std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
- const ParsedQuicVersion& version,
- const QuicConfig& config);
+ const ParsedQuicVersion& version, const QuicConfig& config);
std::vector<std::unique_ptr<QuicReceivedPacket>> GetFirstFlightOfPackets(
const ParsedQuicVersion& version);
diff --git a/quiche/quic/test_tools/limited_mtu_test_writer.cc b/quiche/quic/test_tools/limited_mtu_test_writer.cc
index ff009ee..fa46be1 100644
--- a/quiche/quic/test_tools/limited_mtu_test_writer.cc
+++ b/quiche/quic/test_tools/limited_mtu_test_writer.cc
@@ -12,11 +12,8 @@
LimitedMtuTestWriter::~LimitedMtuTestWriter() = default;
WriteResult LimitedMtuTestWriter::WritePacket(
- const char* buffer,
- size_t buf_len,
- const QuicIpAddress& self_address,
- const QuicSocketAddress& peer_address,
- PerPacketOptions* options) {
+ const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address, PerPacketOptions* options) {
if (buf_len > mtu_) {
// Drop the packet.
return WriteResult(WRITE_STATUS_OK, buf_len);
diff --git a/quiche/quic/test_tools/limited_mtu_test_writer.h b/quiche/quic/test_tools/limited_mtu_test_writer.h
index f3fdc05..96cc828 100644
--- a/quiche/quic/test_tools/limited_mtu_test_writer.h
+++ b/quiche/quic/test_tools/limited_mtu_test_writer.h
@@ -21,8 +21,7 @@
~LimitedMtuTestWriter() override;
// Inherited from QuicPacketWriterWrapper.
- 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;
diff --git a/quiche/quic/test_tools/mock_clock.cc b/quiche/quic/test_tools/mock_clock.cc
index 6aced9e..da5f604 100644
--- a/quiche/quic/test_tools/mock_clock.cc
+++ b/quiche/quic/test_tools/mock_clock.cc
@@ -10,21 +10,13 @@
MockClock::~MockClock() {}
-void MockClock::AdvanceTime(QuicTime::Delta delta) {
- now_ = now_ + delta;
-}
+void MockClock::AdvanceTime(QuicTime::Delta delta) { now_ = now_ + delta; }
-void MockClock::Reset() {
- now_ = QuicTime::Zero();
-}
+void MockClock::Reset() { now_ = QuicTime::Zero(); }
-QuicTime MockClock::Now() const {
- return now_;
-}
+QuicTime MockClock::Now() const { return now_; }
-QuicTime MockClock::ApproximateNow() const {
- return now_;
-}
+QuicTime MockClock::ApproximateNow() const { return now_; }
QuicWallTime MockClock::WallNow() const {
return QuicWallTime::FromUNIXSeconds((now_ - QuicTime::Zero()).ToSeconds());
diff --git a/quiche/quic/test_tools/mock_quic_client_promised_info.cc b/quiche/quic/test_tools/mock_quic_client_promised_info.cc
index 9d3a29b..6729819 100644
--- a/quiche/quic/test_tools/mock_quic_client_promised_info.cc
+++ b/quiche/quic/test_tools/mock_quic_client_promised_info.cc
@@ -8,9 +8,7 @@
namespace test {
MockQuicClientPromisedInfo::MockQuicClientPromisedInfo(
- QuicSpdyClientSessionBase* session,
- QuicStreamId id,
- std::string url)
+ QuicSpdyClientSessionBase* session, QuicStreamId id, std::string url)
: QuicClientPromisedInfo(session, id, url) {}
MockQuicClientPromisedInfo::~MockQuicClientPromisedInfo() {}
diff --git a/quiche/quic/test_tools/mock_quic_client_promised_info.h b/quiche/quic/test_tools/mock_quic_client_promised_info.h
index 42c2100..3dca99e 100644
--- a/quiche/quic/test_tools/mock_quic_client_promised_info.h
+++ b/quiche/quic/test_tools/mock_quic_client_promised_info.h
@@ -17,12 +17,10 @@
class MockQuicClientPromisedInfo : public QuicClientPromisedInfo {
public:
MockQuicClientPromisedInfo(QuicSpdyClientSessionBase* session,
- QuicStreamId id,
- std::string url);
+ QuicStreamId id, std::string url);
~MockQuicClientPromisedInfo() override;
- MOCK_METHOD(QuicAsyncStatus,
- HandleClientRequest,
+ MOCK_METHOD(QuicAsyncStatus, HandleClientRequest,
(const spdy::SpdyHeaderBlock& headers,
QuicClientPushPromiseIndex::Delegate*),
(override));
diff --git a/quiche/quic/test_tools/mock_quic_dispatcher.cc b/quiche/quic/test_tools/mock_quic_dispatcher.cc
index 501516c..fd91281 100644
--- a/quiche/quic/test_tools/mock_quic_dispatcher.cc
+++ b/quiche/quic/test_tools/mock_quic_dispatcher.cc
@@ -10,20 +10,15 @@
namespace test {
MockQuicDispatcher::MockQuicDispatcher(
- const QuicConfig* config,
- const QuicCryptoServerConfig* crypto_config,
+ const QuicConfig* config, const QuicCryptoServerConfig* crypto_config,
QuicVersionManager* version_manager,
std::unique_ptr<QuicConnectionHelperInterface> helper,
std::unique_ptr<QuicCryptoServerStreamBase::Helper> session_helper,
std::unique_ptr<QuicAlarmFactory> alarm_factory,
QuicSimpleServerBackend* quic_simple_server_backend)
- : QuicSimpleDispatcher(config,
- crypto_config,
- version_manager,
- std::move(helper),
- std::move(session_helper),
- std::move(alarm_factory),
- quic_simple_server_backend,
+ : QuicSimpleDispatcher(config, crypto_config, version_manager,
+ std::move(helper), std::move(session_helper),
+ std::move(alarm_factory), quic_simple_server_backend,
kQuicDefaultConnectionIdLength) {}
MockQuicDispatcher::~MockQuicDispatcher() {}
diff --git a/quiche/quic/test_tools/mock_quic_dispatcher.h b/quiche/quic/test_tools/mock_quic_dispatcher.h
index 2080d32..4e152e7 100644
--- a/quiche/quic/test_tools/mock_quic_dispatcher.h
+++ b/quiche/quic/test_tools/mock_quic_dispatcher.h
@@ -18,8 +18,7 @@
class MockQuicDispatcher : public QuicSimpleDispatcher {
public:
MockQuicDispatcher(
- const QuicConfig* config,
- const QuicCryptoServerConfig* crypto_config,
+ const QuicConfig* config, const QuicCryptoServerConfig* crypto_config,
QuicVersionManager* version_manager,
std::unique_ptr<QuicConnectionHelperInterface> helper,
std::unique_ptr<QuicCryptoServerStreamBase::Helper> session_helper,
@@ -30,8 +29,7 @@
~MockQuicDispatcher() override;
- MOCK_METHOD(void,
- ProcessPacket,
+ MOCK_METHOD(void, ProcessPacket,
(const QuicSocketAddress& server_address,
const QuicSocketAddress& client_address,
const QuicReceivedPacket& packet),
diff --git a/quiche/quic/test_tools/mock_quic_session_visitor.h b/quiche/quic/test_tools/mock_quic_session_visitor.h
index 6713851..53c09d8 100644
--- a/quiche/quic/test_tools/mock_quic_session_visitor.h
+++ b/quiche/quic/test_tools/mock_quic_session_visitor.h
@@ -18,35 +18,23 @@
MockQuicSessionVisitor(const MockQuicSessionVisitor&) = delete;
MockQuicSessionVisitor& operator=(const MockQuicSessionVisitor&) = delete;
~MockQuicSessionVisitor() override;
- MOCK_METHOD(void,
- OnConnectionClosed,
- (QuicConnectionId connection_id,
- QuicErrorCode error,
- const std::string& error_details,
- ConnectionCloseSource source),
+ MOCK_METHOD(void, OnConnectionClosed,
+ (QuicConnectionId connection_id, QuicErrorCode error,
+ const std::string& error_details, ConnectionCloseSource source),
(override));
MOCK_METHOD(void, OnWriteBlocked, (QuicBlockedWriterInterface*), (override));
- MOCK_METHOD(void,
- OnRstStreamReceived,
- (const QuicRstStreamFrame& frame),
+ MOCK_METHOD(void, OnRstStreamReceived, (const QuicRstStreamFrame& frame),
(override));
- MOCK_METHOD(void,
- OnStopSendingReceived,
- (const QuicStopSendingFrame& frame),
+ MOCK_METHOD(void, OnStopSendingReceived, (const QuicStopSendingFrame& frame),
(override));
- MOCK_METHOD(void,
- OnNewConnectionIdSent,
+ MOCK_METHOD(void, OnNewConnectionIdSent,
(const QuicConnectionId& server_connection_id,
const QuicConnectionId& new_connection_id),
(override));
- MOCK_METHOD(void,
- OnConnectionIdRetired,
- (const quic::QuicConnectionId& server_connection_id),
- (override));
- MOCK_METHOD(void,
- OnConnectionAddedToTimeWaitList,
- (QuicConnectionId connection_id),
- (override));
+ MOCK_METHOD(void, OnConnectionIdRetired,
+ (const quic::QuicConnectionId& server_connection_id), (override));
+ MOCK_METHOD(void, OnConnectionAddedToTimeWaitList,
+ (QuicConnectionId connection_id), (override));
};
class MockQuicCryptoServerStreamHelper
@@ -58,13 +46,11 @@
MockQuicCryptoServerStreamHelper& operator=(
const MockQuicCryptoServerStreamHelper&) = delete;
~MockQuicCryptoServerStreamHelper() override;
- MOCK_METHOD(bool,
- CanAcceptClientHello,
+ MOCK_METHOD(bool, CanAcceptClientHello,
(const CryptoHandshakeMessage& message,
const QuicSocketAddress& client_address,
const QuicSocketAddress& peer_address,
- const QuicSocketAddress& self_address,
- std::string*),
+ const QuicSocketAddress& self_address, std::string*),
(const, override));
};
diff --git a/quiche/quic/test_tools/mock_quic_spdy_client_stream.cc b/quiche/quic/test_tools/mock_quic_spdy_client_stream.cc
index d82d8f5..ac9604f 100644
--- a/quiche/quic/test_tools/mock_quic_spdy_client_stream.cc
+++ b/quiche/quic/test_tools/mock_quic_spdy_client_stream.cc
@@ -8,9 +8,7 @@
namespace test {
MockQuicSpdyClientStream::MockQuicSpdyClientStream(
- QuicStreamId id,
- QuicSpdyClientSession* session,
- StreamType type)
+ QuicStreamId id, QuicSpdyClientSession* session, StreamType type)
: QuicSpdyClientStream(id, session, type) {}
MockQuicSpdyClientStream::~MockQuicSpdyClientStream() {}
diff --git a/quiche/quic/test_tools/mock_quic_spdy_client_stream.h b/quiche/quic/test_tools/mock_quic_spdy_client_stream.h
index cc4d87e..10c9c6d 100644
--- a/quiche/quic/test_tools/mock_quic_spdy_client_stream.h
+++ b/quiche/quic/test_tools/mock_quic_spdy_client_stream.h
@@ -15,16 +15,13 @@
class MockQuicSpdyClientStream : public QuicSpdyClientStream {
public:
- MockQuicSpdyClientStream(QuicStreamId id,
- QuicSpdyClientSession* session,
+ MockQuicSpdyClientStream(QuicStreamId id, QuicSpdyClientSession* session,
StreamType type);
~MockQuicSpdyClientStream() override;
MOCK_METHOD(void, OnStreamFrame, (const QuicStreamFrame& frame), (override));
- MOCK_METHOD(void,
- OnPromiseHeaderList,
- (QuicStreamId promised_stream_id,
- size_t frame_len,
+ MOCK_METHOD(void, OnPromiseHeaderList,
+ (QuicStreamId promised_stream_id, size_t frame_len,
const QuicHeaderList& list),
(override));
MOCK_METHOD(void, OnDataAvailable, (), (override));
diff --git a/quiche/quic/test_tools/mock_quic_time_wait_list_manager.cc b/quiche/quic/test_tools/mock_quic_time_wait_list_manager.cc
index 81486d1..c345bf3 100644
--- a/quiche/quic/test_tools/mock_quic_time_wait_list_manager.cc
+++ b/quiche/quic/test_tools/mock_quic_time_wait_list_manager.cc
@@ -11,9 +11,7 @@
namespace test {
MockTimeWaitListManager::MockTimeWaitListManager(
- QuicPacketWriter* writer,
- Visitor* visitor,
- const QuicClock* clock,
+ QuicPacketWriter* writer, Visitor* visitor, const QuicClock* clock,
QuicAlarmFactory* alarm_factory)
: QuicTimeWaitListManager(writer, visitor, clock, alarm_factory) {
// Though AddConnectionIdToTimeWait is mocked, we want to retain its
diff --git a/quiche/quic/test_tools/mock_quic_time_wait_list_manager.h b/quiche/quic/test_tools/mock_quic_time_wait_list_manager.h
index 571c8fa..5218f2f 100644
--- a/quiche/quic/test_tools/mock_quic_time_wait_list_manager.h
+++ b/quiche/quic/test_tools/mock_quic_time_wait_list_manager.h
@@ -13,8 +13,7 @@
class MockTimeWaitListManager : public QuicTimeWaitListManager {
public:
- MockTimeWaitListManager(QuicPacketWriter* writer,
- Visitor* visitor,
+ MockTimeWaitListManager(QuicPacketWriter* writer, Visitor* visitor,
const QuicClock* clock,
QuicAlarmFactory* alarm_factory);
~MockTimeWaitListManager() override;
@@ -30,21 +29,15 @@
QuicTimeWaitListManager::AddConnectionIdToTimeWait(action, std::move(info));
}
- MOCK_METHOD(void,
- ProcessPacket,
- (const QuicSocketAddress&,
- const QuicSocketAddress&,
- QuicConnectionId,
- PacketHeaderFormat,
- size_t,
+ MOCK_METHOD(void, ProcessPacket,
+ (const QuicSocketAddress&, const QuicSocketAddress&,
+ QuicConnectionId, PacketHeaderFormat, size_t,
std::unique_ptr<QuicPerPacketContext>),
(override));
- MOCK_METHOD(void,
- SendVersionNegotiationPacket,
+ MOCK_METHOD(void, SendVersionNegotiationPacket,
(QuicConnectionId server_connection_id,
- QuicConnectionId client_connection_id,
- bool ietf_quic,
+ QuicConnectionId client_connection_id, bool ietf_quic,
bool has_length_prefix,
const ParsedQuicVersionVector& supported_versions,
const QuicSocketAddress& server_address,
@@ -52,20 +45,14 @@
std::unique_ptr<QuicPerPacketContext> packet_context),
(override));
- MOCK_METHOD(void,
- SendPublicReset,
- (const QuicSocketAddress&,
- const QuicSocketAddress&,
- QuicConnectionId,
- bool,
- size_t,
+ MOCK_METHOD(void, SendPublicReset,
+ (const QuicSocketAddress&, const QuicSocketAddress&,
+ QuicConnectionId, bool, size_t,
std::unique_ptr<QuicPerPacketContext>),
(override));
- MOCK_METHOD(void,
- SendPacket,
- (const QuicSocketAddress&,
- const QuicSocketAddress&,
+ MOCK_METHOD(void, SendPacket,
+ (const QuicSocketAddress&, const QuicSocketAddress&,
const QuicEncryptedPacket&),
(override));
};
diff --git a/quiche/quic/test_tools/mock_random.cc b/quiche/quic/test_tools/mock_random.cc
index 0a61a1c..2bea7c6 100644
--- a/quiche/quic/test_tools/mock_random.cc
+++ b/quiche/quic/test_tools/mock_random.cc
@@ -17,21 +17,15 @@
memset(data, increment_ + static_cast<uint8_t>('r'), len);
}
-uint64_t MockRandom::RandUint64() {
- return base_ + increment_;
-}
+uint64_t MockRandom::RandUint64() { return base_ + increment_; }
void MockRandom::InsecureRandBytes(void* data, size_t len) {
RandBytes(data, len);
}
-uint64_t MockRandom::InsecureRandUint64() {
- return RandUint64();
-}
+uint64_t MockRandom::InsecureRandUint64() { return RandUint64(); }
-void MockRandom::ChangeValue() {
- increment_++;
-}
+void MockRandom::ChangeValue() { increment_++; }
void MockRandom::ResetBase(uint32_t base) {
base_ = base;
diff --git a/quiche/quic/test_tools/packet_dropping_test_writer.cc b/quiche/quic/test_tools/packet_dropping_test_writer.cc
index f90128c..03b6500 100644
--- a/quiche/quic/test_tools/packet_dropping_test_writer.cc
+++ b/quiche/quic/test_tools/packet_dropping_test_writer.cc
@@ -78,8 +78,7 @@
}
void PacketDroppingTestWriter::Initialize(
- QuicConnectionHelperInterface* helper,
- QuicAlarmFactory* alarm_factory,
+ QuicConnectionHelperInterface* helper, QuicAlarmFactory* alarm_factory,
std::unique_ptr<Delegate> on_can_write) {
clock_ = helper->GetClock();
write_unblocked_alarm_.reset(
@@ -89,11 +88,8 @@
}
WriteResult PacketDroppingTestWriter::WritePacket(
- const char* buffer,
- size_t buf_len,
- const QuicIpAddress& self_address,
- const QuicSocketAddress& peer_address,
- PerPacketOptions* options) {
+ const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address, PerPacketOptions* options) {
++num_calls_to_write_;
ReleaseOldPackets();
@@ -239,17 +235,12 @@
delay_alarm_->Set(new_deadline);
}
-void PacketDroppingTestWriter::OnCanWrite() {
- on_can_write_->OnCanWrite();
-}
+void PacketDroppingTestWriter::OnCanWrite() { on_can_write_->OnCanWrite(); }
PacketDroppingTestWriter::DelayedWrite::DelayedWrite(
- const char* buffer,
- size_t buf_len,
- const QuicIpAddress& self_address,
+ const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- std::unique_ptr<PerPacketOptions> options,
- QuicTime send_time)
+ std::unique_ptr<PerPacketOptions> options, QuicTime send_time)
: buffer(buffer, buf_len),
self_address(self_address),
peer_address(peer_address),
diff --git a/quiche/quic/test_tools/packet_dropping_test_writer.h b/quiche/quic/test_tools/packet_dropping_test_writer.h
index 40204d9..0cc684e 100644
--- a/quiche/quic/test_tools/packet_dropping_test_writer.h
+++ b/quiche/quic/test_tools/packet_dropping_test_writer.h
@@ -44,8 +44,7 @@
std::unique_ptr<Delegate> on_can_write);
// QuicPacketWriter methods:
- 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;
@@ -138,12 +137,10 @@
// A single packet which will be sent at the supplied send_time.
struct DelayedWrite {
public:
- DelayedWrite(const char* buffer,
- size_t buf_len,
+ DelayedWrite(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- std::unique_ptr<PerPacketOptions> options,
- QuicTime send_time);
+ std::unique_ptr<PerPacketOptions> options, QuicTime send_time);
DelayedWrite(const DelayedWrite&) = delete;
DelayedWrite(DelayedWrite&&) = default;
DelayedWrite& operator=(const DelayedWrite&) = delete;
diff --git a/quiche/quic/test_tools/packet_reordering_writer.cc b/quiche/quic/test_tools/packet_reordering_writer.cc
index 66073ea..8eb8573 100644
--- a/quiche/quic/test_tools/packet_reordering_writer.cc
+++ b/quiche/quic/test_tools/packet_reordering_writer.cc
@@ -12,11 +12,8 @@
PacketReorderingWriter::~PacketReorderingWriter() = default;
WriteResult PacketReorderingWriter::WritePacket(
- const char* buffer,
- size_t buf_len,
- const QuicIpAddress& self_address,
- const QuicSocketAddress& peer_address,
- PerPacketOptions* options) {
+ const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address, PerPacketOptions* options) {
if (!delay_next_) {
QUIC_VLOG(2) << "Writing a non-delayed packet";
WriteResult wr = QuicPacketWriterWrapper::WritePacket(
diff --git a/quiche/quic/test_tools/packet_reordering_writer.h b/quiche/quic/test_tools/packet_reordering_writer.h
index 9906cd0..53204c5 100644
--- a/quiche/quic/test_tools/packet_reordering_writer.h
+++ b/quiche/quic/test_tools/packet_reordering_writer.h
@@ -22,8 +22,7 @@
~PacketReorderingWriter() override;
- 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;
diff --git a/quiche/quic/test_tools/quic_config_peer.cc b/quiche/quic/test_tools/quic_config_peer.cc
index 9d1b1be..444859b 100644
--- a/quiche/quic/test_tools/quic_config_peer.cc
+++ b/quiche/quic/test_tools/quic_config_peer.cc
@@ -12,48 +12,42 @@
// static
void QuicConfigPeer::SetReceivedInitialStreamFlowControlWindow(
- QuicConfig* config,
- uint32_t window_bytes) {
+ QuicConfig* config, uint32_t window_bytes) {
config->initial_stream_flow_control_window_bytes_.SetReceivedValue(
window_bytes);
}
// static
void QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesIncomingBidirectional(
- QuicConfig* config,
- uint32_t window_bytes) {
+ QuicConfig* config, uint32_t window_bytes) {
config->initial_max_stream_data_bytes_incoming_bidirectional_
.SetReceivedValue(window_bytes);
}
// static
void QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesOutgoingBidirectional(
- QuicConfig* config,
- uint32_t window_bytes) {
+ QuicConfig* config, uint32_t window_bytes) {
config->initial_max_stream_data_bytes_outgoing_bidirectional_
.SetReceivedValue(window_bytes);
}
// static
void QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesUnidirectional(
- QuicConfig* config,
- uint32_t window_bytes) {
+ QuicConfig* config, uint32_t window_bytes) {
config->initial_max_stream_data_bytes_unidirectional_.SetReceivedValue(
window_bytes);
}
// static
void QuicConfigPeer::SetReceivedInitialSessionFlowControlWindow(
- QuicConfig* config,
- uint32_t window_bytes) {
+ QuicConfig* config, uint32_t window_bytes) {
config->initial_session_flow_control_window_bytes_.SetReceivedValue(
window_bytes);
}
// static
void QuicConfigPeer::SetReceivedConnectionOptions(
- QuicConfig* config,
- const QuicTagVector& options) {
+ QuicConfig* config, const QuicTagVector& options) {
config->connection_options_.SetReceivedValues(options);
}
@@ -88,8 +82,7 @@
// static
void QuicConfigPeer::SetReceivedStatelessResetToken(
- QuicConfig* config,
- const StatelessResetToken& token) {
+ QuicConfig* config, const StatelessResetToken& token) {
config->stateless_reset_token_.SetReceivedValue(token);
}
@@ -120,22 +113,19 @@
// static
void QuicConfigPeer::SetReceivedInitialSourceConnectionId(
- QuicConfig* config,
- const QuicConnectionId& initial_source_connection_id) {
+ QuicConfig* config, const QuicConnectionId& initial_source_connection_id) {
config->received_initial_source_connection_id_ = initial_source_connection_id;
}
// static
void QuicConfigPeer::SetReceivedRetrySourceConnectionId(
- QuicConfig* config,
- const QuicConnectionId& retry_source_connection_id) {
+ QuicConfig* config, const QuicConnectionId& retry_source_connection_id) {
config->received_retry_source_connection_id_ = retry_source_connection_id;
}
// static
void QuicConfigPeer::SetReceivedMaxDatagramFrameSize(
- QuicConfig* config,
- uint64_t max_datagram_frame_size) {
+ QuicConfig* config, uint64_t max_datagram_frame_size) {
config->max_datagram_frame_size_.SetReceivedValue(max_datagram_frame_size);
}
diff --git a/quiche/quic/test_tools/quic_config_peer.h b/quiche/quic/test_tools/quic_config_peer.h
index ef106b0..afcc219 100644
--- a/quiche/quic/test_tools/quic_config_peer.h
+++ b/quiche/quic/test_tools/quic_config_peer.h
@@ -24,16 +24,13 @@
uint32_t window_bytes);
static void SetReceivedInitialMaxStreamDataBytesIncomingBidirectional(
- QuicConfig* config,
- uint32_t window_bytes);
+ QuicConfig* config, uint32_t window_bytes);
static void SetReceivedInitialMaxStreamDataBytesOutgoingBidirectional(
- QuicConfig* config,
- uint32_t window_bytes);
+ QuicConfig* config, uint32_t window_bytes);
static void SetReceivedInitialMaxStreamDataBytesUnidirectional(
- QuicConfig* config,
- uint32_t window_bytes);
+ QuicConfig* config, uint32_t window_bytes);
static void SetReceivedInitialSessionFlowControlWindow(QuicConfig* config,
uint32_t window_bytes);
@@ -70,12 +67,10 @@
const QuicConnectionId& original_destination_connection_id);
static void SetReceivedInitialSourceConnectionId(
- QuicConfig* config,
- const QuicConnectionId& initial_source_connection_id);
+ QuicConfig* config, const QuicConnectionId& initial_source_connection_id);
static void SetReceivedRetrySourceConnectionId(
- QuicConfig* config,
- const QuicConnectionId& retry_source_connection_id);
+ QuicConfig* config, const QuicConnectionId& retry_source_connection_id);
static void SetReceivedMaxDatagramFrameSize(QuicConfig* config,
uint64_t max_datagram_frame_size);
diff --git a/quiche/quic/test_tools/quic_connection_peer.cc b/quiche/quic/test_tools/quic_connection_peer.cc
index 73ec27c..e124580 100644
--- a/quiche/quic/test_tools/quic_connection_peer.cc
+++ b/quiche/quic/test_tools/quic_connection_peer.cc
@@ -19,22 +19,19 @@
// static
void QuicConnectionPeer::SetSendAlgorithm(
- QuicConnection* connection,
- SendAlgorithmInterface* send_algorithm) {
+ QuicConnection* connection, SendAlgorithmInterface* send_algorithm) {
GetSentPacketManager(connection)->SetSendAlgorithm(send_algorithm);
}
// static
void QuicConnectionPeer::SetLossAlgorithm(
- QuicConnection* connection,
- LossDetectionInterface* loss_algorithm) {
+ QuicConnection* connection, LossDetectionInterface* loss_algorithm) {
GetSentPacketManager(connection)->loss_algorithm_ = loss_algorithm;
}
// static
void QuicConnectionPeer::PopulateStopWaitingFrame(
- QuicConnection* connection,
- QuicStopWaitingFrame* stop_waiting) {
+ QuicConnection* connection, QuicStopWaitingFrame* stop_waiting) {
connection->PopulateStopWaitingFrame(stop_waiting);
}
@@ -83,8 +80,7 @@
// static
void QuicConnectionPeer::SetDirectPeerAddress(
- QuicConnection* connection,
- const QuicSocketAddress& direct_peer_address) {
+ QuicConnection* connection, const QuicSocketAddress& direct_peer_address) {
connection->direct_peer_address_ = direct_peer_address;
}
@@ -196,8 +192,7 @@
// static
void QuicConnectionPeer::SetWriter(QuicConnection* connection,
- QuicPacketWriter* writer,
- bool owns_writer) {
+ QuicPacketWriter* writer, bool owns_writer) {
if (connection->owns_writer_) {
delete connection->writer_;
}
@@ -240,8 +235,7 @@
// static
void QuicConnectionPeer::ReInitializeMtuDiscoverer(
- QuicConnection* connection,
- QuicPacketCount packets_between_probes_base,
+ QuicConnection* connection, QuicPacketCount packets_between_probes_base,
QuicPacketNumber next_probe_at) {
connection->mtu_discoverer_ =
QuicConnectionMtuDiscoverer(packets_between_probes_base, next_probe_at);
@@ -276,8 +270,7 @@
// static
void QuicConnectionPeer::SetMaxTrackedPackets(
- QuicConnection* connection,
- QuicPacketCount max_tracked_packets) {
+ QuicConnection* connection, QuicPacketCount max_tracked_packets) {
connection->max_tracked_packets_ = max_tracked_packets;
}
@@ -293,8 +286,7 @@
// static
void QuicConnectionPeer::SetMaxConsecutiveNumPacketsWithNoRetransmittableFrames(
- QuicConnection* connection,
- size_t new_value) {
+ QuicConnection* connection, size_t new_value) {
connection->max_consecutive_num_packets_with_no_retransmittable_frames_ =
new_value;
}
@@ -332,10 +324,8 @@
// static
void QuicConnectionPeer::SendConnectionClosePacket(
- QuicConnection* connection,
- QuicIetfTransportErrorCodes ietf_error,
- QuicErrorCode error,
- const std::string& details) {
+ QuicConnection* connection, QuicIetfTransportErrorCodes ietf_error,
+ QuicErrorCode error, const std::string& details) {
connection->SendConnectionClosePacket(error, ietf_error, details);
}
@@ -402,8 +392,7 @@
// static
void QuicConnectionPeer::SetServerConnectionId(
- QuicConnection* connection,
- const QuicConnectionId& server_connection_id) {
+ QuicConnection* connection, const QuicConnectionId& server_connection_id) {
connection->default_path_.server_connection_id = server_connection_id;
connection->InstallInitialCrypters(server_connection_id);
}
@@ -424,8 +413,7 @@
// static
void QuicConnectionPeer::SetLastPacketDestinationAddress(
- QuicConnection* connection,
- const QuicSocketAddress& address) {
+ QuicConnection* connection, const QuicSocketAddress& address) {
connection->last_received_packet_info_.destination_address = address;
}
@@ -467,8 +455,7 @@
// static
bool QuicConnectionPeer::IsAlternativePath(
- QuicConnection* connection,
- const QuicSocketAddress& self_address,
+ QuicConnection* connection, const QuicSocketAddress& self_address,
const QuicSocketAddress& peer_address) {
return connection->IsAlternativePath(self_address, peer_address);
}
diff --git a/quiche/quic/test_tools/quic_connection_peer.h b/quiche/quic/test_tools/quic_connection_peer.h
index b9ca8a3..ffe3b3c 100644
--- a/quiche/quic/test_tools/quic_connection_peer.h
+++ b/quiche/quic/test_tools/quic_connection_peer.h
@@ -6,6 +6,7 @@
#define QUICHE_QUIC_TEST_TOOLS_QUIC_CONNECTION_PEER_H_
#include <cstddef>
+
#include "absl/strings/string_view.h"
#include "quiche/quic/core/quic_connection.h"
#include "quiche/quic/core/quic_connection_id.h"
@@ -62,8 +63,7 @@
const QuicSocketAddress& peer_address);
static void SetDirectPeerAddress(
- QuicConnection* connection,
- const QuicSocketAddress& direct_peer_address);
+ QuicConnection* connection, const QuicSocketAddress& direct_peer_address);
static void SetEffectivePeerAddress(
QuicConnection* connection,
@@ -98,8 +98,7 @@
static QuicPacketWriter* GetWriter(QuicConnection* connection);
// If |owns_writer| is true, takes ownership of |writer|.
- static void SetWriter(QuicConnection* connection,
- QuicPacketWriter* writer,
+ static void SetWriter(QuicConnection* connection, QuicPacketWriter* writer,
bool owns_writer);
static void TearDownLocalConnectionState(QuicConnection* connection);
static QuicEncryptedPacket* GetConnectionClosePacket(
@@ -112,8 +111,7 @@
static QuicPacketCount GetPacketsBetweenMtuProbes(QuicConnection* connection);
static void ReInitializeMtuDiscoverer(
- QuicConnection* connection,
- QuicPacketCount packets_between_probes_base,
+ QuicConnection* connection, QuicPacketCount packets_between_probes_base,
QuicPacketNumber next_probe_at);
static void SetAckDecimationDelay(QuicConnection* connection,
float ack_decimation_delay);
@@ -126,8 +124,7 @@
QuicPacketCount max_tracked_packets);
static void SetNegotiatedVersion(QuicConnection* connection);
static void SetMaxConsecutiveNumPacketsWithNoRetransmittableFrames(
- QuicConnection* connection,
- size_t new_value);
+ QuicConnection* connection, size_t new_value);
static bool SupportsReleaseTime(QuicConnection* connection);
static QuicConnection::PacketContent GetCurrentPacketContent(
QuicConnection* connection);
@@ -163,8 +160,7 @@
QuicConnection* connection);
static void SetServerConnectionId(
- QuicConnection* connection,
- const QuicConnectionId& server_connection_id);
+ QuicConnection* connection, const QuicConnectionId& server_connection_id);
static size_t NumUndecryptablePackets(QuicConnection* connection);
diff --git a/quiche/quic/test_tools/quic_crypto_server_config_peer.cc b/quiche/quic/test_tools/quic_crypto_server_config_peer.cc
index f09c0cf..48c8aed 100644
--- a/quiche/quic/test_tools/quic_crypto_server_config_peer.cc
+++ b/quiche/quic/test_tools/quic_crypto_server_config_peer.cc
@@ -40,11 +40,8 @@
}
std::string QuicCryptoServerConfigPeer::NewSourceAddressToken(
- std::string config_id,
- SourceAddressTokens previous_tokens,
- const QuicIpAddress& ip,
- QuicRandom* rand,
- QuicWallTime now,
+ std::string config_id, SourceAddressTokens previous_tokens,
+ const QuicIpAddress& ip, QuicRandom* rand, QuicWallTime now,
CachedNetworkParameters* cached_network_params) {
return server_config_->NewSourceAddressToken(
*GetConfig(config_id)->source_address_token_boxer, previous_tokens, ip,
@@ -52,11 +49,8 @@
}
HandshakeFailureReason QuicCryptoServerConfigPeer::ValidateSourceAddressTokens(
- std::string config_id,
- absl::string_view srct,
- const QuicIpAddress& ip,
- QuicWallTime now,
- CachedNetworkParameters* cached_network_params) {
+ std::string config_id, absl::string_view srct, const QuicIpAddress& ip,
+ QuicWallTime now, CachedNetworkParameters* cached_network_params) {
SourceAddressTokens tokens;
HandshakeFailureReason reason = server_config_->ParseSourceAddressToken(
*GetConfig(config_id)->source_address_token_boxer, srct, tokens);
@@ -70,9 +64,7 @@
HandshakeFailureReason
QuicCryptoServerConfigPeer::ValidateSingleSourceAddressToken(
- absl::string_view token,
- const QuicIpAddress& ip,
- QuicWallTime now) {
+ absl::string_view token, const QuicIpAddress& ip, QuicWallTime now) {
SourceAddressTokens tokens;
HandshakeFailureReason parse_status = server_config_->ParseSourceAddressToken(
*GetPrimaryConfig()->source_address_token_boxer, token, tokens);
diff --git a/quiche/quic/test_tools/quic_crypto_server_config_peer.h b/quiche/quic/test_tools/quic_crypto_server_config_peer.h
index 463a403..f8a1ee5 100644
--- a/quiche/quic/test_tools/quic_crypto_server_config_peer.h
+++ b/quiche/quic/test_tools/quic_crypto_server_config_peer.h
@@ -33,11 +33,8 @@
// Generates a new valid source address token.
std::string NewSourceAddressToken(
- std::string config_id,
- SourceAddressTokens previous_tokens,
- const QuicIpAddress& ip,
- QuicRandom* rand,
- QuicWallTime now,
+ std::string config_id, SourceAddressTokens previous_tokens,
+ const QuicIpAddress& ip, QuicRandom* rand, QuicWallTime now,
CachedNetworkParameters* cached_network_params);
// Attempts to validate the tokens in |srct|.
@@ -47,9 +44,7 @@
// Attempts to validate the single source address token in |token|.
HandshakeFailureReason ValidateSingleSourceAddressToken(
- absl::string_view token,
- const QuicIpAddress& ip,
- QuicWallTime now);
+ absl::string_view token, const QuicIpAddress& ip, QuicWallTime now);
// CheckConfigs compares the state of the Configs in |server_config_| to the
// description given as arguments.
diff --git a/quiche/quic/test_tools/quic_dispatcher_peer.cc b/quiche/quic/test_tools/quic_dispatcher_peer.cc
index e281952..8a803c5 100644
--- a/quiche/quic/test_tools/quic_dispatcher_peer.cc
+++ b/quiche/quic/test_tools/quic_dispatcher_peer.cc
@@ -75,19 +75,15 @@
// static
void QuicDispatcherPeer::set_new_sessions_allowed_per_event_loop(
- QuicDispatcher* dispatcher,
- size_t num_session_allowed) {
+ QuicDispatcher* dispatcher, size_t num_session_allowed) {
dispatcher->new_sessions_allowed_per_event_loop_ = num_session_allowed;
}
// static
void QuicDispatcherPeer::SendPublicReset(
- QuicDispatcher* dispatcher,
- const QuicSocketAddress& self_address,
- const QuicSocketAddress& peer_address,
- QuicConnectionId connection_id,
- bool ietf_quic,
- size_t received_packet_length,
+ QuicDispatcher* dispatcher, const QuicSocketAddress& self_address,
+ const QuicSocketAddress& peer_address, QuicConnectionId connection_id,
+ bool ietf_quic, size_t received_packet_length,
std::unique_ptr<QuicPerPacketContext> packet_context) {
dispatcher->time_wait_list_manager()->SendPublicReset(
self_address, peer_address, connection_id, ietf_quic,
@@ -102,15 +98,13 @@
// static
void QuicDispatcherPeer::RestorePerPacketContext(
- QuicDispatcher* dispatcher,
- std::unique_ptr<QuicPerPacketContext> context) {
+ QuicDispatcher* dispatcher, std::unique_ptr<QuicPerPacketContext> context) {
dispatcher->RestorePerPacketContext(std::move(context));
}
// static
std::string QuicDispatcherPeer::SelectAlpn(
- QuicDispatcher* dispatcher,
- const std::vector<std::string>& alpns) {
+ QuicDispatcher* dispatcher, const std::vector<std::string>& alpns) {
return dispatcher->SelectAlpn(alpns);
}
@@ -125,8 +119,7 @@
// static
const QuicSession* QuicDispatcherPeer::FindSession(
- const QuicDispatcher* dispatcher,
- QuicConnectionId id) {
+ const QuicDispatcher* dispatcher, QuicConnectionId id) {
auto it = dispatcher->reference_counted_session_map_.find(id);
return (it == dispatcher->reference_counted_session_map_.end())
? nullptr
diff --git a/quiche/quic/test_tools/quic_dispatcher_peer.h b/quiche/quic/test_tools/quic_dispatcher_peer.h
index 57c3c83..1238a89 100644
--- a/quiche/quic/test_tools/quic_dispatcher_peer.h
+++ b/quiche/quic/test_tools/quic_dispatcher_peer.h
@@ -48,16 +48,12 @@
QuicDispatcher* dispatcher);
static void set_new_sessions_allowed_per_event_loop(
- QuicDispatcher* dispatcher,
- size_t num_session_allowed);
+ QuicDispatcher* dispatcher, size_t num_session_allowed);
static void SendPublicReset(
- QuicDispatcher* dispatcher,
- const QuicSocketAddress& self_address,
- const QuicSocketAddress& peer_address,
- QuicConnectionId connection_id,
- bool ietf_quic,
- size_t received_packet_length,
+ QuicDispatcher* dispatcher, const QuicSocketAddress& self_address,
+ const QuicSocketAddress& peer_address, QuicConnectionId connection_id,
+ bool ietf_quic, size_t received_packet_length,
std::unique_ptr<QuicPerPacketContext> packet_context);
static std::unique_ptr<QuicPerPacketContext> GetPerPacketContext(
diff --git a/quiche/quic/test_tools/quic_flow_controller_peer.cc b/quiche/quic/test_tools/quic_flow_controller_peer.cc
index 1356082..70b3007 100644
--- a/quiche/quic/test_tools/quic_flow_controller_peer.cc
+++ b/quiche/quic/test_tools/quic_flow_controller_peer.cc
@@ -14,22 +14,19 @@
// static
void QuicFlowControllerPeer::SetSendWindowOffset(
- QuicFlowController* flow_controller,
- QuicStreamOffset offset) {
+ QuicFlowController* flow_controller, QuicStreamOffset offset) {
flow_controller->send_window_offset_ = offset;
}
// static
void QuicFlowControllerPeer::SetReceiveWindowOffset(
- QuicFlowController* flow_controller,
- QuicStreamOffset offset) {
+ QuicFlowController* flow_controller, QuicStreamOffset offset) {
flow_controller->receive_window_offset_ = offset;
}
// static
void QuicFlowControllerPeer::SetMaxReceiveWindow(
- QuicFlowController* flow_controller,
- QuicByteCount window_size) {
+ QuicFlowController* flow_controller, QuicByteCount window_size) {
flow_controller->receive_window_size_ = window_size;
}
diff --git a/quiche/quic/test_tools/quic_framer_peer.cc b/quiche/quic/test_tools/quic_framer_peer.cc
index 60ccff8..9819a8a 100644
--- a/quiche/quic/test_tools/quic_framer_peer.cc
+++ b/quiche/quic/test_tools/quic_framer_peer.cc
@@ -12,32 +12,27 @@
// static
uint64_t QuicFramerPeer::CalculatePacketNumberFromWire(
- QuicFramer* framer,
- QuicPacketNumberLength packet_number_length,
- QuicPacketNumber last_packet_number,
- uint64_t packet_number) {
+ QuicFramer* framer, QuicPacketNumberLength packet_number_length,
+ QuicPacketNumber last_packet_number, uint64_t packet_number) {
return framer->CalculatePacketNumberFromWire(
packet_number_length, last_packet_number, packet_number);
}
// static
void QuicFramerPeer::SetLastSerializedServerConnectionId(
- QuicFramer* framer,
- QuicConnectionId server_connection_id) {
+ QuicFramer* framer, QuicConnectionId server_connection_id) {
framer->last_serialized_server_connection_id_ = server_connection_id;
}
// static
void QuicFramerPeer::SetLastSerializedClientConnectionId(
- QuicFramer* framer,
- QuicConnectionId client_connection_id) {
+ QuicFramer* framer, QuicConnectionId client_connection_id) {
framer->last_serialized_client_connection_id_ = client_connection_id;
}
// static
void QuicFramerPeer::SetLastWrittenPacketNumberLength(
- QuicFramer* framer,
- size_t packet_number_length) {
+ QuicFramer* framer, size_t packet_number_length) {
framer->last_written_packet_number_length_ = packet_number_length;
}
@@ -95,29 +90,24 @@
// static
void QuicFramerPeer::SetExpectedServerConnectionIDLength(
- QuicFramer* framer,
- uint8_t expected_server_connection_id_length) {
+ QuicFramer* framer, uint8_t expected_server_connection_id_length) {
*const_cast<uint8_t*>(&framer->expected_server_connection_id_length_) =
expected_server_connection_id_length;
}
// static
QuicPacketNumber QuicFramerPeer::GetLargestDecryptedPacketNumber(
- QuicFramer* framer,
- PacketNumberSpace packet_number_space) {
+ QuicFramer* framer, PacketNumberSpace packet_number_space) {
return framer->largest_decrypted_packet_numbers_[packet_number_space];
}
// static
bool QuicFramerPeer::ProcessAndValidateIetfConnectionIdLength(
- QuicDataReader* reader,
- ParsedQuicVersion version,
- Perspective perspective,
+ QuicDataReader* reader, ParsedQuicVersion version, Perspective perspective,
bool should_update_expected_server_connection_id_length,
uint8_t* expected_server_connection_id_length,
uint8_t* destination_connection_id_length,
- uint8_t* source_connection_id_length,
- std::string* detailed_error) {
+ uint8_t* source_connection_id_length, std::string* detailed_error) {
return QuicFramer::ProcessAndValidateIetfConnectionIdLength(
reader, version, perspective,
should_update_expected_server_connection_id_length,
diff --git a/quiche/quic/test_tools/quic_framer_peer.h b/quiche/quic/test_tools/quic_framer_peer.h
index 3b898d1..aa38394 100644
--- a/quiche/quic/test_tools/quic_framer_peer.h
+++ b/quiche/quic/test_tools/quic_framer_peer.h
@@ -18,16 +18,12 @@
QuicFramerPeer() = delete;
static uint64_t CalculatePacketNumberFromWire(
- QuicFramer* framer,
- QuicPacketNumberLength packet_number_length,
- QuicPacketNumber last_packet_number,
- uint64_t packet_number);
+ QuicFramer* framer, QuicPacketNumberLength packet_number_length,
+ QuicPacketNumber last_packet_number, uint64_t packet_number);
static void SetLastSerializedServerConnectionId(
- QuicFramer* framer,
- QuicConnectionId server_connection_id);
+ QuicFramer* framer, QuicConnectionId server_connection_id);
static void SetLastSerializedClientConnectionId(
- QuicFramer* framer,
- QuicConnectionId client_connection_id);
+ QuicFramer* framer, QuicConnectionId client_connection_id);
static void SetLastWrittenPacketNumberLength(QuicFramer* framer,
size_t packet_number_length);
static void SetLargestPacketNumber(QuicFramer* framer,
@@ -44,25 +40,20 @@
static void SetFirstSendingPacketNumber(QuicFramer* framer,
uint64_t packet_number);
static void SetExpectedServerConnectionIDLength(
- QuicFramer* framer,
- uint8_t expected_server_connection_id_length);
+ QuicFramer* framer, uint8_t expected_server_connection_id_length);
static QuicPacketNumber GetLargestDecryptedPacketNumber(
- QuicFramer* framer,
- PacketNumberSpace packet_number_space);
+ QuicFramer* framer, PacketNumberSpace packet_number_space);
static bool ProcessAndValidateIetfConnectionIdLength(
- QuicDataReader* reader,
- ParsedQuicVersion version,
+ QuicDataReader* reader, ParsedQuicVersion version,
Perspective perspective,
bool should_update_expected_server_connection_id_length,
uint8_t* expected_server_connection_id_length,
uint8_t* destination_connection_id_length,
- uint8_t* source_connection_id_length,
- std::string* detailed_error);
+ uint8_t* source_connection_id_length, std::string* detailed_error);
static void set_current_received_frame_type(
- QuicFramer* framer,
- uint64_t current_received_frame_type) {
+ QuicFramer* framer, uint64_t current_received_frame_type) {
framer->current_received_frame_type_ = current_received_frame_type;
}
diff --git a/quiche/quic/test_tools/quic_mock_syscall_wrapper.h b/quiche/quic/test_tools/quic_mock_syscall_wrapper.h
index 31f7770..58b021d 100644
--- a/quiche/quic/test_tools/quic_mock_syscall_wrapper.h
+++ b/quiche/quic/test_tools/quic_mock_syscall_wrapper.h
@@ -20,15 +20,11 @@
// default.
explicit MockQuicSyscallWrapper(QuicSyscallWrapper* delegate);
- MOCK_METHOD(ssize_t,
- Sendmsg,
- (int sockfd, const msghdr*, int flags),
+ MOCK_METHOD(ssize_t, Sendmsg, (int sockfd, const msghdr*, int flags),
(override));
- MOCK_METHOD(int,
- Sendmmsg,
- (int sockfd, mmsghdr*, unsigned int vlen, int flags),
- (override));
+ MOCK_METHOD(int, Sendmmsg,
+ (int sockfd, mmsghdr*, unsigned int vlen, int flags), (override));
};
} // namespace test
diff --git a/quiche/quic/test_tools/quic_packet_creator_peer.cc b/quiche/quic/test_tools/quic_packet_creator_peer.cc
index fa62e14..507de25 100644
--- a/quiche/quic/test_tools/quic_packet_creator_peer.cc
+++ b/quiche/quic/test_tools/quic_packet_creator_peer.cc
@@ -18,8 +18,7 @@
// static
void QuicPacketCreatorPeer::SetSendVersionInPacket(
- QuicPacketCreator* creator,
- bool send_version_in_packet) {
+ QuicPacketCreator* creator, bool send_version_in_packet) {
ParsedQuicVersion version = creator->framer_->version();
if (!VersionHasIetfQuicFrames(version.transport_version) &&
version.handshake_protocol != PROTOCOL_TLS1_3) {
@@ -35,8 +34,7 @@
// static
void QuicPacketCreatorPeer::SetPacketNumberLength(
- QuicPacketCreator* creator,
- QuicPacketNumberLength packet_number_length) {
+ QuicPacketCreator* creator, QuicPacketNumberLength packet_number_length) {
creator->packet_.packet_number_length = packet_number_length;
}
@@ -84,8 +82,7 @@
void QuicPacketCreatorPeer::CreateStreamFrame(QuicPacketCreator* creator,
QuicStreamId id,
size_t data_length,
- QuicStreamOffset offset,
- bool fin,
+ QuicStreamOffset offset, bool fin,
QuicFrame* frame) {
creator->CreateStreamFrame(id, data_length, offset, fin, frame);
}
@@ -101,9 +98,7 @@
// static
SerializedPacket QuicPacketCreatorPeer::SerializeAllFrames(
- QuicPacketCreator* creator,
- const QuicFrames& frames,
- char* buffer,
+ QuicPacketCreator* creator, const QuicFrames& frames, char* buffer,
size_t buffer_len) {
QUICHE_DCHECK(creator->queued_frames_.empty());
QUICHE_DCHECK(!frames.empty());
@@ -131,8 +126,7 @@
// static
std::unique_ptr<SerializedPacket>
QuicPacketCreatorPeer::SerializePathChallengeConnectivityProbingPacket(
- QuicPacketCreator* creator,
- const QuicPathFrameBuffer& payload) {
+ QuicPacketCreator* creator, const QuicPathFrameBuffer& payload) {
return creator->SerializePathChallengeConnectivityProbingPacket(payload);
}
diff --git a/quiche/quic/test_tools/quic_packet_creator_peer.h b/quiche/quic/test_tools/quic_packet_creator_peer.h
index 8af1a30..0c9ce77 100644
--- a/quiche/quic/test_tools/quic_packet_creator_peer.h
+++ b/quiche/quic/test_tools/quic_packet_creator_peer.h
@@ -23,8 +23,7 @@
static void SetSendVersionInPacket(QuicPacketCreator* creator,
bool send_version_in_packet);
static void SetPacketNumberLength(
- QuicPacketCreator* creator,
- QuicPacketNumberLength packet_number_length);
+ QuicPacketCreator* creator, QuicPacketNumberLength packet_number_length);
static QuicPacketNumberLength GetPacketNumberLength(
QuicPacketCreator* creator);
static QuicVariableLengthIntegerLength GetRetryTokenLengthLength(
@@ -36,27 +35,20 @@
static void ClearPacketNumber(QuicPacketCreator* creator);
static void FillPacketHeader(QuicPacketCreator* creator,
QuicPacketHeader* header);
- static void CreateStreamFrame(QuicPacketCreator* creator,
- QuicStreamId id,
- size_t data_length,
- QuicStreamOffset offset,
- bool fin,
- QuicFrame* frame);
+ static void CreateStreamFrame(QuicPacketCreator* creator, QuicStreamId id,
+ size_t data_length, QuicStreamOffset offset,
+ bool fin, QuicFrame* frame);
static bool CreateCryptoFrame(QuicPacketCreator* creator,
- EncryptionLevel level,
- size_t write_length,
- QuicStreamOffset offset,
- QuicFrame* frame);
+ EncryptionLevel level, size_t write_length,
+ QuicStreamOffset offset, QuicFrame* frame);
static SerializedPacket SerializeAllFrames(QuicPacketCreator* creator,
const QuicFrames& frames,
- char* buffer,
- size_t buffer_len);
+ char* buffer, size_t buffer_len);
static std::unique_ptr<SerializedPacket> SerializeConnectivityProbingPacket(
QuicPacketCreator* creator);
static std::unique_ptr<SerializedPacket>
SerializePathChallengeConnectivityProbingPacket(
- QuicPacketCreator* creator,
- const QuicPathFrameBuffer& payload);
+ QuicPacketCreator* creator, const QuicPathFrameBuffer& payload);
static EncryptionLevel GetEncryptionLevel(QuicPacketCreator* creator);
static QuicFramer* framer(QuicPacketCreator* creator);
diff --git a/quiche/quic/test_tools/quic_sent_packet_manager_peer.cc b/quiche/quic/test_tools/quic_sent_packet_manager_peer.cc
index 06588a4..dc41041 100644
--- a/quiche/quic/test_tools/quic_sent_packet_manager_peer.cc
+++ b/quiche/quic/test_tools/quic_sent_packet_manager_peer.cc
@@ -21,8 +21,7 @@
// static
void QuicSentPacketManagerPeer::SetMaxTailLossProbes(
- QuicSentPacketManager* sent_packet_manager,
- size_t max_tail_loss_probes) {
+ QuicSentPacketManager* sent_packet_manager, size_t max_tail_loss_probes) {
sent_packet_manager->max_tail_loss_probes_ = max_tail_loss_probes;
}
@@ -34,8 +33,7 @@
// static
void QuicSentPacketManagerPeer::SetPerspective(
- QuicSentPacketManager* sent_packet_manager,
- Perspective perspective) {
+ QuicSentPacketManager* sent_packet_manager, Perspective perspective) {
QuicUnackedPacketMapPeer::SetPerspective(
&sent_packet_manager->unacked_packets_, perspective);
}
@@ -74,8 +72,7 @@
// static
bool QuicSentPacketManagerPeer::IsRetransmission(
- QuicSentPacketManager* sent_packet_manager,
- uint64_t packet_number) {
+ QuicSentPacketManager* sent_packet_manager, uint64_t packet_number) {
QUICHE_DCHECK(HasRetransmittableFrames(sent_packet_manager, packet_number));
if (!HasRetransmittableFrames(sent_packet_manager, packet_number)) {
return false;
@@ -87,8 +84,7 @@
// static
void QuicSentPacketManagerPeer::MarkForRetransmission(
- QuicSentPacketManager* sent_packet_manager,
- uint64_t packet_number,
+ QuicSentPacketManager* sent_packet_manager, uint64_t packet_number,
TransmissionType transmission_type) {
sent_packet_manager->MarkForRetransmission(QuicPacketNumber(packet_number),
transmission_type);
@@ -121,15 +117,13 @@
// static
void QuicSentPacketManagerPeer::SetConsecutiveRtoCount(
- QuicSentPacketManager* sent_packet_manager,
- size_t count) {
+ QuicSentPacketManager* sent_packet_manager, size_t count) {
sent_packet_manager->consecutive_rto_count_ = count;
}
// static
void QuicSentPacketManagerPeer::SetConsecutiveTlpCount(
- QuicSentPacketManager* sent_packet_manager,
- size_t count) {
+ QuicSentPacketManager* sent_packet_manager, size_t count) {
sent_packet_manager->consecutive_tlp_count_ = count;
}
@@ -147,15 +141,13 @@
// static
void QuicSentPacketManagerPeer::SetUsingPacing(
- QuicSentPacketManager* sent_packet_manager,
- bool using_pacing) {
+ QuicSentPacketManager* sent_packet_manager, bool using_pacing) {
sent_packet_manager->using_pacing_ = using_pacing;
}
// static
bool QuicSentPacketManagerPeer::HasRetransmittableFrames(
- QuicSentPacketManager* sent_packet_manager,
- uint64_t packet_number) {
+ QuicSentPacketManager* sent_packet_manager, uint64_t packet_number) {
return sent_packet_manager->unacked_packets_.HasRetransmittableFrames(
QuicPacketNumber(packet_number));
}
@@ -181,8 +173,7 @@
// static
void QuicSentPacketManagerPeer::SetNextPacedPacketTime(
- QuicSentPacketManager* sent_packet_manager,
- QuicTime time) {
+ QuicSentPacketManager* sent_packet_manager, QuicTime time) {
sent_packet_manager->pacing_sender_.ideal_next_packet_send_time_ = time;
}
diff --git a/quiche/quic/test_tools/quic_sent_packet_manager_peer.h b/quiche/quic/test_tools/quic_sent_packet_manager_peer.h
index 6e32b6b..be2a7bd 100644
--- a/quiche/quic/test_tools/quic_sent_packet_manager_peer.h
+++ b/quiche/quic/test_tools/quic_sent_packet_manager_peer.h
@@ -74,8 +74,7 @@
static bool UsingPacing(const QuicSentPacketManager* sent_packet_manager);
static bool HasRetransmittableFrames(
- QuicSentPacketManager* sent_packet_manager,
- uint64_t packet_number);
+ QuicSentPacketManager* sent_packet_manager, uint64_t packet_number);
static QuicUnackedPacketMap* GetUnackedPacketMap(
QuicSentPacketManager* sent_packet_manager);
diff --git a/quiche/quic/test_tools/quic_server_session_base_peer.h b/quiche/quic/test_tools/quic_server_session_base_peer.h
index 5a2bd2d..c6b60c0 100644
--- a/quiche/quic/test_tools/quic_server_session_base_peer.h
+++ b/quiche/quic/test_tools/quic_server_session_base_peer.h
@@ -6,7 +6,6 @@
#define QUICHE_QUIC_TEST_TOOLS_QUIC_SERVER_SESSION_BASE_PEER_H_
#include "quiche/quic/core/http/quic_server_session_base.h"
-
#include "quiche/quic/core/quic_utils.h"
namespace quic {
diff --git a/quiche/quic/test_tools/quic_session_peer.cc b/quiche/quic/test_tools/quic_session_peer.cc
index bb03bd2..ed12e8f 100644
--- a/quiche/quic/test_tools/quic_session_peer.cc
+++ b/quiche/quic/test_tools/quic_session_peer.cc
@@ -52,8 +52,7 @@
// static
void QuicSessionPeer::SetMaxOpenIncomingBidirectionalStreams(
- QuicSession* session,
- uint32_t max_streams) {
+ QuicSession* session, uint32_t max_streams) {
QUICHE_DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
<< "SetmaxOpenIncomingBidirectionalStreams not supported for Google "
"QUIC";
@@ -62,8 +61,7 @@
}
// static
void QuicSessionPeer::SetMaxOpenIncomingUnidirectionalStreams(
- QuicSession* session,
- uint32_t max_streams) {
+ QuicSession* session, uint32_t max_streams) {
QUICHE_DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
<< "SetmaxOpenIncomingUnidirectionalStreams not supported for Google "
"QUIC";
@@ -84,8 +82,7 @@
// static
void QuicSessionPeer::SetMaxOpenOutgoingBidirectionalStreams(
- QuicSession* session,
- uint32_t max_streams) {
+ QuicSession* session, uint32_t max_streams) {
QUICHE_DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
<< "SetmaxOpenOutgoingBidirectionalStreams not supported for Google "
"QUIC";
@@ -94,8 +91,7 @@
}
// static
void QuicSessionPeer::SetMaxOpenOutgoingUnidirectionalStreams(
- QuicSession* session,
- uint32_t max_streams) {
+ QuicSession* session, uint32_t max_streams) {
QUICHE_DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
<< "SetmaxOpenOutgoingUnidirectionalStreams not supported for Google "
"QUIC";
diff --git a/quiche/quic/test_tools/quic_stream_id_manager_peer.cc b/quiche/quic/test_tools/quic_stream_id_manager_peer.cc
index 0bec142..eaf3b00 100644
--- a/quiche/quic/test_tools/quic_stream_id_manager_peer.cc
+++ b/quiche/quic/test_tools/quic_stream_id_manager_peer.cc
@@ -14,15 +14,13 @@
// static
void QuicStreamIdManagerPeer::set_incoming_actual_max_streams(
- QuicStreamIdManager* stream_id_manager,
- QuicStreamCount count) {
+ QuicStreamIdManager* stream_id_manager, QuicStreamCount count) {
stream_id_manager->incoming_actual_max_streams_ = count;
}
// static
void QuicStreamIdManagerPeer::set_outgoing_max_streams(
- QuicStreamIdManager* stream_id_manager,
- QuicStreamCount count) {
+ QuicStreamIdManager* stream_id_manager, QuicStreamCount count) {
stream_id_manager->outgoing_max_streams_ = count;
}
diff --git a/quiche/quic/test_tools/quic_stream_id_manager_peer.h b/quiche/quic/test_tools/quic_stream_id_manager_peer.h
index 2dcde94..509d062 100644
--- a/quiche/quic/test_tools/quic_stream_id_manager_peer.h
+++ b/quiche/quic/test_tools/quic_stream_id_manager_peer.h
@@ -21,8 +21,7 @@
QuicStreamIdManagerPeer() = delete;
static void set_incoming_actual_max_streams(
- QuicStreamIdManager* stream_id_manager,
- QuicStreamCount count);
+ QuicStreamIdManager* stream_id_manager, QuicStreamCount count);
static void set_outgoing_max_streams(QuicStreamIdManager* stream_id_manager,
QuicStreamCount count);
diff --git a/quiche/quic/test_tools/quic_stream_peer.cc b/quiche/quic/test_tools/quic_stream_peer.cc
index 594cb89..0fdaa58 100644
--- a/quiche/quic/test_tools/quic_stream_peer.cc
+++ b/quiche/quic/test_tools/quic_stream_peer.cc
@@ -21,8 +21,7 @@
// static
void QuicStreamPeer::SetStreamBytesWritten(
- QuicStreamOffset stream_bytes_written,
- QuicStream* stream) {
+ QuicStreamOffset stream_bytes_written, QuicStream* stream) {
stream->send_buffer_.stream_bytes_written_ = stream_bytes_written;
stream->send_buffer_.stream_bytes_outstanding_ = stream_bytes_written;
QuicStreamSendBufferPeer::SetStreamOffset(&stream->send_buffer_,
diff --git a/quiche/quic/test_tools/quic_stream_send_buffer_peer.cc b/quiche/quic/test_tools/quic_stream_send_buffer_peer.cc
index e4554fa..c81b45e 100644
--- a/quiche/quic/test_tools/quic_stream_send_buffer_peer.cc
+++ b/quiche/quic/test_tools/quic_stream_send_buffer_peer.cc
@@ -3,6 +3,7 @@
// found in the LICENSE file.
#include "quiche/quic/test_tools/quic_stream_send_buffer_peer.h"
+
#include "quiche/quic/test_tools/quic_interval_deque_peer.h"
namespace quic {
@@ -11,8 +12,7 @@
// static
void QuicStreamSendBufferPeer::SetStreamOffset(
- QuicStreamSendBuffer* send_buffer,
- QuicStreamOffset stream_offset) {
+ QuicStreamSendBuffer* send_buffer, QuicStreamOffset stream_offset) {
send_buffer->stream_offset_ = stream_offset;
}
diff --git a/quiche/quic/test_tools/quic_stream_sequencer_buffer_peer.cc b/quiche/quic/test_tools/quic_stream_sequencer_buffer_peer.cc
index 63d8a4b..679bd91 100644
--- a/quiche/quic/test_tools/quic_stream_sequencer_buffer_peer.cc
+++ b/quiche/quic/test_tools/quic_stream_sequencer_buffer_peer.cc
@@ -3,6 +3,7 @@
// found in the LICENSE file.
#include "quiche/quic/test_tools/quic_stream_sequencer_buffer_peer.h"
+
#include <cstddef>
#include "quiche/quic/platform/api/quic_flags.h"
diff --git a/quiche/quic/test_tools/quic_stream_sequencer_peer.cc b/quiche/quic/test_tools/quic_stream_sequencer_peer.cc
index 100f38e..3ba4f62 100644
--- a/quiche/quic/test_tools/quic_stream_sequencer_peer.cc
+++ b/quiche/quic/test_tools/quic_stream_sequencer_peer.cc
@@ -31,8 +31,7 @@
// static
void QuicStreamSequencerPeer::SetFrameBufferTotalBytesRead(
- QuicStreamSequencer* sequencer,
- QuicStreamOffset total_bytes_read) {
+ QuicStreamSequencer* sequencer, QuicStreamOffset total_bytes_read) {
QuicStreamSequencerBufferPeer buffer_peer(&(sequencer->buffered_frames_));
buffer_peer.set_total_bytes_read(total_bytes_read);
}
diff --git a/quiche/quic/test_tools/quic_test_client.cc b/quiche/quic/test_tools/quic_test_client.cc
index 89b149f..cffcfa2 100644
--- a/quiche/quic/test_tools/quic_test_client.cc
+++ b/quiche/quic/test_tools/quic_test_client.cc
@@ -45,16 +45,11 @@
// ProofVerifier interface.
QuicAsyncStatus VerifyProof(
- const std::string& hostname,
- const uint16_t port,
- const std::string& server_config,
- QuicTransportVersion transport_version,
- absl::string_view chlo_hash,
- const std::vector<std::string>& certs,
- const std::string& cert_sct,
- const std::string& signature,
- const ProofVerifyContext* context,
- std::string* error_details,
+ const std::string& hostname, const uint16_t port,
+ const std::string& server_config, QuicTransportVersion transport_version,
+ absl::string_view chlo_hash, const std::vector<std::string>& certs,
+ const std::string& cert_sct, const std::string& signature,
+ const ProofVerifyContext* context, std::string* error_details,
std::unique_ptr<ProofVerifyDetails>* details,
std::unique_ptr<ProofVerifierCallback> callback) override {
QuicAsyncStatus process_certs_result = ProcessCerts(certs, cert_sct);
@@ -73,15 +68,11 @@
}
QuicAsyncStatus VerifyCertChain(
- const std::string& /*hostname*/,
- const uint16_t /*port*/,
+ const std::string& /*hostname*/, const uint16_t /*port*/,
const std::vector<std::string>& certs,
- const std::string& /*ocsp_response*/,
- const std::string& cert_sct,
- const ProofVerifyContext* /*context*/,
- std::string* /*error_details*/,
- std::unique_ptr<ProofVerifyDetails>* /*details*/,
- uint8_t* /*out_alert*/,
+ const std::string& /*ocsp_response*/, const std::string& cert_sct,
+ const ProofVerifyContext* /*context*/, std::string* /*error_details*/,
+ std::unique_ptr<ProofVerifyDetails>* /*details*/, uint8_t* /*out_alert*/,
std::unique_ptr<ProofVerifierCallback> /*callback*/) override {
return ProcessCerts(certs, cert_sct);
}
@@ -195,58 +186,35 @@
};
MockableQuicClient::MockableQuicClient(
- QuicSocketAddress server_address,
- const QuicServerId& server_id,
+ QuicSocketAddress server_address, const QuicServerId& server_id,
const ParsedQuicVersionVector& supported_versions,
QuicEpollServer* epoll_server)
- : MockableQuicClient(server_address,
- server_id,
- QuicConfig(),
- supported_versions,
- epoll_server) {}
+ : MockableQuicClient(server_address, server_id, QuicConfig(),
+ supported_versions, epoll_server) {}
MockableQuicClient::MockableQuicClient(
- QuicSocketAddress server_address,
- const QuicServerId& server_id,
- const QuicConfig& config,
- const ParsedQuicVersionVector& supported_versions,
+ QuicSocketAddress server_address, const QuicServerId& server_id,
+ const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
QuicEpollServer* epoll_server)
- : MockableQuicClient(server_address,
- server_id,
- config,
- supported_versions,
- epoll_server,
- nullptr) {}
+ : MockableQuicClient(server_address, server_id, config, supported_versions,
+ epoll_server, nullptr) {}
MockableQuicClient::MockableQuicClient(
- QuicSocketAddress server_address,
- const QuicServerId& server_id,
- const QuicConfig& config,
- const ParsedQuicVersionVector& supported_versions,
+ QuicSocketAddress server_address, const QuicServerId& server_id,
+ const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
QuicEpollServer* epoll_server,
std::unique_ptr<ProofVerifier> proof_verifier)
- : MockableQuicClient(server_address,
- server_id,
- config,
- supported_versions,
- epoll_server,
- std::move(proof_verifier),
- nullptr) {}
+ : MockableQuicClient(server_address, server_id, config, supported_versions,
+ epoll_server, std::move(proof_verifier), nullptr) {}
MockableQuicClient::MockableQuicClient(
- QuicSocketAddress server_address,
- const QuicServerId& server_id,
- const QuicConfig& config,
- const ParsedQuicVersionVector& supported_versions,
+ QuicSocketAddress server_address, const QuicServerId& server_id,
+ const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
QuicEpollServer* epoll_server,
std::unique_ptr<ProofVerifier> proof_verifier,
std::unique_ptr<SessionCache> session_cache)
: QuicClient(
- server_address,
- server_id,
- supported_versions,
- config,
- epoll_server,
+ server_address, server_id, supported_versions, config, epoll_server,
std::make_unique<MockableQuicClientEpollNetworkHelper>(epoll_server,
this),
std::make_unique<RecordingProofVerifier>(std::move(proof_verifier)),
@@ -338,58 +306,41 @@
}
QuicTestClient::QuicTestClient(
- QuicSocketAddress server_address,
- const std::string& server_hostname,
+ QuicSocketAddress server_address, const std::string& server_hostname,
const ParsedQuicVersionVector& supported_versions)
- : QuicTestClient(server_address,
- server_hostname,
- QuicConfig(),
+ : QuicTestClient(server_address, server_hostname, QuicConfig(),
supported_versions) {}
QuicTestClient::QuicTestClient(
- QuicSocketAddress server_address,
- const std::string& server_hostname,
- const QuicConfig& config,
- const ParsedQuicVersionVector& supported_versions)
+ QuicSocketAddress server_address, const std::string& server_hostname,
+ const QuicConfig& config, const ParsedQuicVersionVector& supported_versions)
: client_(new MockableQuicClient(
server_address,
- QuicServerId(server_hostname, server_address.port(), false),
- config,
- supported_versions,
- &epoll_server_)) {
+ QuicServerId(server_hostname, server_address.port(), false), config,
+ supported_versions, &epoll_server_)) {
Initialize();
}
QuicTestClient::QuicTestClient(
- QuicSocketAddress server_address,
- const std::string& server_hostname,
- const QuicConfig& config,
- const ParsedQuicVersionVector& supported_versions,
+ QuicSocketAddress server_address, const std::string& server_hostname,
+ const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
std::unique_ptr<ProofVerifier> proof_verifier)
: client_(new MockableQuicClient(
server_address,
- QuicServerId(server_hostname, server_address.port(), false),
- config,
- supported_versions,
- &epoll_server_,
- std::move(proof_verifier))) {
+ QuicServerId(server_hostname, server_address.port(), false), config,
+ supported_versions, &epoll_server_, std::move(proof_verifier))) {
Initialize();
}
QuicTestClient::QuicTestClient(
- QuicSocketAddress server_address,
- const std::string& server_hostname,
- const QuicConfig& config,
- const ParsedQuicVersionVector& supported_versions,
+ QuicSocketAddress server_address, const std::string& server_hostname,
+ const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
std::unique_ptr<ProofVerifier> proof_verifier,
std::unique_ptr<SessionCache> session_cache)
: client_(new MockableQuicClient(
server_address,
- QuicServerId(server_hostname, server_address.port(), false),
- config,
- supported_versions,
- &epoll_server_,
- std::move(proof_verifier),
+ QuicServerId(server_hostname, server_address.port(), false), config,
+ supported_versions, &epoll_server_, std::move(proof_verifier),
std::move(session_cache))) {
Initialize();
}
@@ -462,8 +413,7 @@
QuicClientPushPromiseIndex::TryHandle* handle;
QuicAsyncStatus rv =
client()->push_promise_index()->Try(*headers, this, &handle);
- if (rv == QUIC_SUCCESS)
- return 1;
+ if (rv == QUIC_SUCCESS) return 1;
if (rv == QUIC_PENDING) {
// May need to retry request if asynchronous rendezvous fails.
std::unique_ptr<spdy::SpdyHeaderBlock> new_headers(
@@ -504,14 +454,12 @@
}
ssize_t QuicTestClient::SendMessage(const spdy::SpdyHeaderBlock& headers,
- absl::string_view body,
- bool fin) {
+ absl::string_view body, bool fin) {
return SendMessage(headers, body, fin, /*flush=*/true);
}
ssize_t QuicTestClient::SendMessage(const spdy::SpdyHeaderBlock& headers,
- absl::string_view body,
- bool fin,
+ absl::string_view body, bool fin,
bool flush) {
// Always force creation of a stream for SendMessage.
latest_created_stream_ = nullptr;
@@ -536,29 +484,22 @@
last_data, std::move(ack_listener));
}
-bool QuicTestClient::response_complete() const {
- return response_complete_;
-}
+bool QuicTestClient::response_complete() const { return response_complete_; }
int64_t QuicTestClient::response_body_size() const {
return response_body_size_;
}
-bool QuicTestClient::buffer_body() const {
- return buffer_body_;
-}
+bool QuicTestClient::buffer_body() const { return buffer_body_; }
void QuicTestClient::set_buffer_body(bool buffer_body) {
buffer_body_ = buffer_body;
}
-const std::string& QuicTestClient::response_body() const {
- return response_;
-}
+const std::string& QuicTestClient::response_body() const { return response_; }
std::string QuicTestClient::SendCustomSynchronousRequest(
- const spdy::SpdyHeaderBlock& headers,
- const std::string& body) {
+ const spdy::SpdyHeaderBlock& headers, const std::string& body) {
// Clear connection state here and only track this synchronous request.
ClearPerConnectionState();
if (SendMessage(headers, body) == 0) {
@@ -639,9 +580,7 @@
return handshake_msg->tag_value_map();
}
-bool QuicTestClient::connected() const {
- return client_->connected();
-}
+bool QuicTestClient::connected() const { return client_->connected(); }
void QuicTestClient::Connect() {
if (connected()) {
@@ -761,9 +700,7 @@
return response_trailers_;
}
-int64_t QuicTestClient::response_size() const {
- return bytes_read();
-}
+int64_t QuicTestClient::response_size() const { return bytes_read(); }
size_t QuicTestClient::bytes_read() const {
for (std::pair<QuicStreamId, QuicSpdyClientStream*> stream : open_streams_) {
@@ -872,8 +809,7 @@
}
bool QuicTestClient::MigrateSocketWithSpecifiedPort(
- const QuicIpAddress& new_host,
- int port) {
+ const QuicIpAddress& new_host, int port) {
client_->set_local_port(port);
return client_->MigrateSocket(new_host);
}
@@ -926,16 +862,12 @@
response_body_size(other.response_body_size) {}
QuicTestClient::PerStreamState::PerStreamState(
- QuicRstStreamErrorCode stream_error,
- bool response_complete,
+ QuicRstStreamErrorCode stream_error, bool response_complete,
bool response_headers_complete,
const spdy::SpdyHeaderBlock& response_headers,
const spdy::SpdyHeaderBlock& preliminary_headers,
- const std::string& response,
- const spdy::SpdyHeaderBlock& response_trailers,
- uint64_t bytes_read,
- uint64_t bytes_written,
- int64_t response_body_size)
+ const std::string& response, const spdy::SpdyHeaderBlock& response_trailers,
+ uint64_t bytes_read, uint64_t bytes_written, int64_t response_body_size)
: stream_error(stream_error),
response_complete(response_complete),
response_headers_complete(response_headers_complete),
@@ -950,8 +882,7 @@
QuicTestClient::PerStreamState::~PerStreamState() = default;
bool QuicTestClient::PopulateHeaderBlockFromUrl(
- const std::string& uri,
- spdy::SpdyHeaderBlock* headers) {
+ const std::string& uri, spdy::SpdyHeaderBlock* headers) {
std::string url;
if (absl::StartsWith(uri, "https://") || absl::StartsWith(uri, "http://")) {
url = uri;
diff --git a/quiche/quic/test_tools/quic_test_client.h b/quiche/quic/test_tools/quic_test_client.h
index 2878f9b..078f96b 100644
--- a/quiche/quic/test_tools/quic_test_client.h
+++ b/quiche/quic/test_tools/quic_test_client.h
@@ -37,21 +37,18 @@
QuicEpollServer* epoll_server);
MockableQuicClient(QuicSocketAddress server_address,
- const QuicServerId& server_id,
- const QuicConfig& config,
+ const QuicServerId& server_id, const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
QuicEpollServer* epoll_server);
MockableQuicClient(QuicSocketAddress server_address,
- const QuicServerId& server_id,
- const QuicConfig& config,
+ const QuicServerId& server_id, const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
QuicEpollServer* epoll_server,
std::unique_ptr<ProofVerifier> proof_verifier);
MockableQuicClient(QuicSocketAddress server_address,
- const QuicServerId& server_id,
- const QuicConfig& config,
+ const QuicServerId& server_id, const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
QuicEpollServer* epoll_server,
std::unique_ptr<ProofVerifier> proof_verifier,
@@ -99,17 +96,14 @@
const std::string& server_hostname,
const ParsedQuicVersionVector& supported_versions);
QuicTestClient(QuicSocketAddress server_address,
- const std::string& server_hostname,
- const QuicConfig& config,
+ const std::string& server_hostname, const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions);
QuicTestClient(QuicSocketAddress server_address,
- const std::string& server_hostname,
- const QuicConfig& config,
+ const std::string& server_hostname, const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
std::unique_ptr<ProofVerifier> proof_verifier);
QuicTestClient(QuicSocketAddress server_address,
- const std::string& server_hostname,
- const QuicConfig& config,
+ const std::string& server_hostname, const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
std::unique_ptr<ProofVerifier> proof_verifier,
std::unique_ptr<SessionCache> session_cache);
@@ -145,16 +139,13 @@
// |fin| and returns the number of bytes sent (the size of the serialized
// request headers and body).
ssize_t SendMessage(const spdy::SpdyHeaderBlock& headers,
- absl::string_view body,
- bool fin);
+ absl::string_view body, bool fin);
// Sends a request containing |headers| and |body| with the fin bit set to
// |fin| and returns the number of bytes sent (the size of the serialized
// request headers and body). If |flush| is true, will wait for the message to
// be flushed before returning.
ssize_t SendMessage(const spdy::SpdyHeaderBlock& headers,
- absl::string_view body,
- bool fin,
- bool flush);
+ absl::string_view body, bool fin, bool flush);
// Sends a request containing |headers| and |body|, waits for the response,
// and returns the response body.
std::string SendCustomSynchronousRequest(const spdy::SpdyHeaderBlock& headers,
@@ -357,15 +348,13 @@
// PerStreamState of a stream is updated when it is closed.
struct PerStreamState {
PerStreamState(const PerStreamState& other);
- PerStreamState(QuicRstStreamErrorCode stream_error,
- bool response_complete,
+ PerStreamState(QuicRstStreamErrorCode stream_error, bool response_complete,
bool response_headers_complete,
const spdy::SpdyHeaderBlock& response_headers,
const spdy::SpdyHeaderBlock& preliminary_headers,
const std::string& response,
const spdy::SpdyHeaderBlock& response_trailers,
- uint64_t bytes_read,
- uint64_t bytes_written,
+ uint64_t bytes_read, uint64_t bytes_written,
int64_t response_body_size);
~PerStreamState();
diff --git a/quiche/quic/test_tools/quic_test_server.cc b/quiche/quic/test_tools/quic_test_server.cc
index b19afc6..53068df 100644
--- a/quiche/quic/test_tools/quic_test_server.cc
+++ b/quiche/quic/test_tools/quic_test_server.cc
@@ -23,21 +23,15 @@
CustomStreamSession(
const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
- QuicConnection* connection,
- QuicSession::Visitor* visitor,
+ QuicConnection* connection, QuicSession::Visitor* visitor,
QuicCryptoServerStreamBase::Helper* helper,
const QuicCryptoServerConfig* crypto_config,
QuicCompressedCertsCache* compressed_certs_cache,
QuicTestServer::StreamFactory* stream_factory,
QuicTestServer::CryptoStreamFactory* crypto_stream_factory,
QuicSimpleServerBackend* quic_simple_server_backend)
- : QuicSimpleServerSession(config,
- supported_versions,
- connection,
- visitor,
- helper,
- crypto_config,
- compressed_certs_cache,
+ : QuicSimpleServerSession(config, supported_versions, connection, visitor,
+ helper, crypto_config, compressed_certs_cache,
quic_simple_server_backend),
stream_factory_(stream_factory),
crypto_stream_factory_(crypto_stream_factory) {}
@@ -73,22 +67,17 @@
class QuicTestDispatcher : public QuicSimpleDispatcher {
public:
QuicTestDispatcher(
- const QuicConfig* config,
- const QuicCryptoServerConfig* crypto_config,
+ const QuicConfig* config, const QuicCryptoServerConfig* crypto_config,
QuicVersionManager* version_manager,
std::unique_ptr<QuicConnectionHelperInterface> helper,
std::unique_ptr<QuicCryptoServerStreamBase::Helper> session_helper,
std::unique_ptr<QuicAlarmFactory> alarm_factory,
QuicSimpleServerBackend* quic_simple_server_backend,
uint8_t expected_server_connection_id_length)
- : QuicSimpleDispatcher(config,
- crypto_config,
- version_manager,
- std::move(helper),
- std::move(session_helper),
- std::move(alarm_factory),
- quic_simple_server_backend,
- expected_server_connection_id_length),
+ : QuicSimpleDispatcher(
+ config, crypto_config, version_manager, std::move(helper),
+ std::move(session_helper), std::move(alarm_factory),
+ quic_simple_server_backend, expected_server_connection_id_length),
session_factory_(nullptr),
stream_factory_(nullptr),
crypto_stream_factory_(nullptr) {}
@@ -169,26 +158,20 @@
: QuicServer(std::move(proof_source), quic_simple_server_backend) {}
QuicTestServer::QuicTestServer(
- std::unique_ptr<ProofSource> proof_source,
- const QuicConfig& config,
+ std::unique_ptr<ProofSource> proof_source, const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
QuicSimpleServerBackend* quic_simple_server_backend)
- : QuicTestServer(std::move(proof_source),
- config,
- supported_versions,
+ : QuicTestServer(std::move(proof_source), config, supported_versions,
quic_simple_server_backend,
kQuicDefaultConnectionIdLength) {}
QuicTestServer::QuicTestServer(
- std::unique_ptr<ProofSource> proof_source,
- const QuicConfig& config,
+ std::unique_ptr<ProofSource> proof_source, const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
QuicSimpleServerBackend* quic_simple_server_backend,
uint8_t expected_server_connection_id_length)
- : QuicServer(std::move(proof_source),
- config,
- QuicCryptoServerConfig::ConfigOptions(),
- supported_versions,
+ : QuicServer(std::move(proof_source), config,
+ QuicCryptoServerConfig::ConfigOptions(), supported_versions,
quic_simple_server_backend,
expected_server_connection_id_length) {}
@@ -220,21 +203,14 @@
/////////////////////////// TEST SESSIONS ///////////////////////////////
ImmediateGoAwaySession::ImmediateGoAwaySession(
- const QuicConfig& config,
- QuicConnection* connection,
- QuicSession::Visitor* visitor,
- QuicCryptoServerStreamBase::Helper* helper,
+ const QuicConfig& config, QuicConnection* connection,
+ QuicSession::Visitor* visitor, QuicCryptoServerStreamBase::Helper* helper,
const QuicCryptoServerConfig* crypto_config,
QuicCompressedCertsCache* compressed_certs_cache,
QuicSimpleServerBackend* quic_simple_server_backend)
- : QuicSimpleServerSession(config,
- CurrentSupportedVersions(),
- connection,
- visitor,
- helper,
- crypto_config,
- compressed_certs_cache,
- quic_simple_server_backend) {}
+ : QuicSimpleServerSession(
+ config, CurrentSupportedVersions(), connection, visitor, helper,
+ crypto_config, compressed_certs_cache, quic_simple_server_backend) {}
void ImmediateGoAwaySession::OnStreamFrame(const QuicStreamFrame& frame) {
if (VersionUsesHttp3(transport_version())) {
@@ -256,8 +232,7 @@
}
void ImmediateGoAwaySession::OnNewEncryptionKeyAvailable(
- EncryptionLevel level,
- std::unique_ptr<QuicEncrypter> encrypter) {
+ EncryptionLevel level, std::unique_ptr<QuicEncrypter> encrypter) {
QuicSimpleServerSession::OnNewEncryptionKeyAvailable(level,
std::move(encrypter));
if (VersionUsesHttp3(transport_version())) {
diff --git a/quiche/quic/test_tools/quic_test_server.h b/quiche/quic/test_tools/quic_test_server.h
index 277dade..f986bdc 100644
--- a/quiche/quic/test_tools/quic_test_server.h
+++ b/quiche/quic/test_tools/quic_test_server.h
@@ -28,8 +28,7 @@
// Returns a new session owned by the caller.
virtual std::unique_ptr<QuicServerSessionBase> CreateSession(
- const QuicConfig& config,
- QuicConnection* connection,
+ const QuicConfig& config, QuicConnection* connection,
QuicSession::Visitor* visitor,
QuicCryptoServerStreamBase::Helper* helper,
const QuicCryptoServerConfig* crypto_config,
@@ -44,8 +43,7 @@
// Returns a new stream owned by the caller.
virtual QuicSimpleServerStream* CreateStream(
- QuicStreamId id,
- QuicSpdySession* session,
+ QuicStreamId id, QuicSpdySession* session,
QuicSimpleServerBackend* quic_simple_server_backend) = 0;
virtual QuicSimpleServerStream* CreateStream(
@@ -98,8 +96,7 @@
// credentials have even been established.
class ImmediateGoAwaySession : public QuicSimpleServerSession {
public:
- ImmediateGoAwaySession(const QuicConfig& config,
- QuicConnection* connection,
+ ImmediateGoAwaySession(const QuicConfig& config, QuicConnection* connection,
QuicSession::Visitor* visitor,
QuicCryptoServerStreamBase::Helper* helper,
const QuicCryptoServerConfig* crypto_config,
@@ -110,8 +107,7 @@
void OnStreamFrame(const QuicStreamFrame& frame) override;
void OnCryptoFrame(const QuicCryptoFrame& frame) override;
void OnNewEncryptionKeyAvailable(
- EncryptionLevel level,
- std::unique_ptr<QuicEncrypter> encrypter) override;
+ EncryptionLevel level, std::unique_ptr<QuicEncrypter> encrypter) override;
};
} // namespace test
diff --git a/quiche/quic/test_tools/quic_test_utils.cc b/quiche/quic/test_tools/quic_test_utils.cc
index 5720241..b182dc5 100644
--- a/quiche/quic/test_tools/quic_test_utils.cc
+++ b/quiche/quic/test_tools/quic_test_utils.cc
@@ -89,9 +89,7 @@
std::string TestHostname() { return "test.example.com"; }
-QuicServerId TestServerId() {
- return QuicServerId(TestHostname(), kTestPort);
-}
+QuicServerId TestServerId() { return QuicServerId(TestHostname(), kTestPort); }
QuicAckFrame InitAckFrame(const std::vector<QuicAckBlock>& ack_blocks) {
QUICHE_DCHECK_GT(ack_blocks.size(), 0u);
@@ -130,8 +128,7 @@
return ack;
}
-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) {
QuicAckFrame ack;
ack.largest_acked = QuicPacketNumber(largest_acked);
@@ -160,8 +157,7 @@
}
std::unique_ptr<QuicPacket> BuildUnsizedDataPacket(
- QuicFramer* framer,
- const QuicPacketHeader& header,
+ QuicFramer* framer, const QuicPacketHeader& header,
const QuicFrames& frames) {
const size_t max_plaintext_size =
framer->GetMaxPlaintextSize(kMaxOutgoingPacketSize);
@@ -180,10 +176,8 @@
}
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) {
char* buffer = new char[packet_size];
EncryptionLevel level = HeaderToEncryptionLevel(header);
size_t length =
@@ -246,9 +240,7 @@
RandBytes(data, len);
}
-uint64_t SimpleRandom::InsecureRandUint64() {
- return RandUint64();
-}
+uint64_t SimpleRandom::InsecureRandUint64() { return RandUint64(); }
void SimpleRandom::FillBuffer() {
uint8_t nonce[12];
@@ -330,8 +322,7 @@
const QuicEncryptedPacket& /*packet*/) {}
void NoOpFramerVisitor::OnUndecryptablePacket(
- const QuicEncryptedPacket& /*packet*/,
- EncryptionLevel /*decryption_level*/,
+ const QuicEncryptedPacket& /*packet*/, EncryptionLevel /*decryption_level*/,
bool /*has_decryption_key*/) {}
bool NoOpFramerVisitor::OnStreamFrame(const QuicStreamFrame& /*frame*/) {
@@ -462,9 +453,7 @@
MockQuicConnectionHelper::~MockQuicConnectionHelper() {}
-const QuicClock* MockQuicConnectionHelper::GetClock() const {
- return &clock_;
-}
+const QuicClock* MockQuicConnectionHelper::GetClock() const { return &clock_; }
QuicRandom* MockQuicConnectionHelper::GetRandomGenerator() {
return &random_generator_;
@@ -499,19 +488,14 @@
Perspective perspective)
: MockQuicConnection(TestConnectionId(),
QuicSocketAddress(TestPeerIPAddress(), kTestPort),
- helper,
- alarm_factory,
- perspective,
+ helper, alarm_factory, perspective,
ParsedVersionOfIndex(CurrentSupportedVersions(), 0)) {}
MockQuicConnection::MockQuicConnection(QuicSocketAddress address,
MockQuicConnectionHelper* helper,
MockAlarmFactory* alarm_factory,
Perspective perspective)
- : MockQuicConnection(TestConnectionId(),
- address,
- helper,
- alarm_factory,
+ : MockQuicConnection(TestConnectionId(), address, helper, alarm_factory,
perspective,
ParsedVersionOfIndex(CurrentSupportedVersions(), 0)) {}
@@ -521,40 +505,26 @@
Perspective perspective)
: MockQuicConnection(connection_id,
QuicSocketAddress(TestPeerIPAddress(), kTestPort),
- helper,
- alarm_factory,
- perspective,
+ helper, alarm_factory, perspective,
ParsedVersionOfIndex(CurrentSupportedVersions(), 0)) {}
MockQuicConnection::MockQuicConnection(
- MockQuicConnectionHelper* helper,
- MockAlarmFactory* alarm_factory,
- Perspective perspective,
- const ParsedQuicVersionVector& supported_versions)
- : MockQuicConnection(TestConnectionId(),
- QuicSocketAddress(TestPeerIPAddress(), kTestPort),
- helper,
- alarm_factory,
- perspective,
- supported_versions) {}
+ MockQuicConnectionHelper* helper, MockAlarmFactory* alarm_factory,
+ Perspective perspective, const ParsedQuicVersionVector& supported_versions)
+ : MockQuicConnection(
+ TestConnectionId(), QuicSocketAddress(TestPeerIPAddress(), kTestPort),
+ helper, alarm_factory, perspective, supported_versions) {}
MockQuicConnection::MockQuicConnection(
- QuicConnectionId connection_id,
- QuicSocketAddress initial_peer_address,
- MockQuicConnectionHelper* helper,
- MockAlarmFactory* alarm_factory,
- Perspective perspective,
- const ParsedQuicVersionVector& supported_versions)
+ QuicConnectionId connection_id, QuicSocketAddress initial_peer_address,
+ MockQuicConnectionHelper* helper, MockAlarmFactory* alarm_factory,
+ Perspective perspective, const ParsedQuicVersionVector& supported_versions)
: QuicConnection(
connection_id,
/*initial_self_address=*/QuicSocketAddress(QuicIpAddress::Any4(), 5),
- initial_peer_address,
- helper,
- alarm_factory,
+ initial_peer_address, helper, alarm_factory,
new testing::NiceMock<MockPacketWriter>(),
- /* owns_writer= */ true,
- perspective,
- supported_versions) {
+ /* owns_writer= */ true, perspective, supported_versions) {
ON_CALL(*this, OnError(_))
.WillByDefault(
Invoke(this, &PacketSavingConnection::QuicConnection_OnError));
@@ -582,13 +552,9 @@
: MockQuicConnection(helper, alarm_factory, perspective) {}
PacketSavingConnection::PacketSavingConnection(
- MockQuicConnectionHelper* helper,
- MockAlarmFactory* alarm_factory,
- Perspective perspective,
- const ParsedQuicVersionVector& supported_versions)
- : MockQuicConnection(helper,
- alarm_factory,
- perspective,
+ MockQuicConnectionHelper* helper, MockAlarmFactory* alarm_factory,
+ Perspective perspective, const ParsedQuicVersionVector& supported_versions)
+ : MockQuicConnection(helper, alarm_factory, perspective,
supported_versions) {}
PacketSavingConnection::~PacketSavingConnection() {}
@@ -610,9 +576,7 @@
MockQuicSession::MockQuicSession(QuicConnection* connection,
bool create_mock_crypto_stream)
- : QuicSession(connection,
- nullptr,
- DefaultQuicConfig(),
+ : QuicSession(connection, nullptr, DefaultQuicConfig(),
connection->supported_versions(),
/*num_expected_unidirectional_static_streams = */ 0) {
if (create_mock_crypto_stream) {
@@ -622,9 +586,7 @@
.WillByDefault(testing::Return(QuicConsumedData(0, false)));
}
-MockQuicSession::~MockQuicSession() {
- DeleteConnection();
-}
+MockQuicSession::~MockQuicSession() { DeleteConnection(); }
QuicCryptoStream* MockQuicSession::GetMutableCryptoStream() {
return crypto_stream_.get();
@@ -639,11 +601,8 @@
}
QuicConsumedData MockQuicSession::ConsumeData(
- QuicStreamId id,
- size_t write_length,
- QuicStreamOffset offset,
- StreamSendingState state,
- TransmissionType /*type*/,
+ QuicStreamId id, size_t write_length, QuicStreamOffset offset,
+ StreamSendingState state, TransmissionType /*type*/,
absl::optional<EncryptionLevel> /*level*/) {
if (write_length > 0) {
auto buf = std::make_unique<char[]>(write_length);
@@ -666,13 +625,9 @@
return ssl_early_data_unknown;
}
-bool MockQuicCryptoStream::encryption_established() const {
- return false;
-}
+bool MockQuicCryptoStream::encryption_established() const { return false; }
-bool MockQuicCryptoStream::one_rtt_keys_available() const {
- return false;
-}
+bool MockQuicCryptoStream::one_rtt_keys_available() const { return false; }
const QuicCryptoNegotiatedParameters&
MockQuicCryptoStream::crypto_negotiated_params() const {
@@ -688,9 +643,7 @@
MockQuicSpdySession::MockQuicSpdySession(QuicConnection* connection,
bool create_mock_crypto_stream)
- : QuicSpdySession(connection,
- nullptr,
- DefaultQuicConfig(),
+ : QuicSpdySession(connection, nullptr, DefaultQuicConfig(),
connection->supported_versions()) {
if (create_mock_crypto_stream) {
crypto_stream_ = std::make_unique<MockQuicCryptoStream>(this);
@@ -711,9 +664,7 @@
ON_CALL(*this, OnCongestionWindowChange(_)).WillByDefault(testing::Return());
}
-MockQuicSpdySession::~MockQuicSpdySession() {
- DeleteConnection();
-}
+MockQuicSpdySession::~MockQuicSpdySession() { DeleteConnection(); }
QuicCryptoStream* MockQuicSpdySession::GetMutableCryptoStream() {
return crypto_stream_.get();
@@ -728,11 +679,8 @@
}
QuicConsumedData MockQuicSpdySession::ConsumeData(
- QuicStreamId id,
- size_t write_length,
- QuicStreamOffset offset,
- StreamSendingState state,
- TransmissionType /*type*/,
+ QuicStreamId id, size_t write_length, QuicStreamOffset offset,
+ StreamSendingState state, TransmissionType /*type*/,
absl::optional<EncryptionLevel> /*level*/) {
if (write_length > 0) {
auto buf = std::make_unique<char[]>(write_length);
@@ -747,25 +695,17 @@
}
TestQuicSpdyServerSession::TestQuicSpdyServerSession(
- QuicConnection* connection,
- const QuicConfig& config,
+ QuicConnection* connection, const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
const QuicCryptoServerConfig* crypto_config,
QuicCompressedCertsCache* compressed_certs_cache)
- : QuicServerSessionBase(config,
- supported_versions,
- connection,
- &visitor_,
- &helper_,
- crypto_config,
- compressed_certs_cache) {
+ : QuicServerSessionBase(config, supported_versions, connection, &visitor_,
+ &helper_, crypto_config, compressed_certs_cache) {
ON_CALL(helper_, CanAcceptClientHello(_, _, _, _, _))
.WillByDefault(testing::Return(true));
}
-TestQuicSpdyServerSession::~TestQuicSpdyServerSession() {
- DeleteConnection();
-}
+TestQuicSpdyServerSession::~TestQuicSpdyServerSession() { DeleteConnection(); }
std::unique_ptr<QuicCryptoServerStreamBase>
TestQuicSpdyServerSession::CreateQuicCryptoServerStream(
@@ -786,14 +726,10 @@
}
TestQuicSpdyClientSession::TestQuicSpdyClientSession(
- QuicConnection* connection,
- const QuicConfig& config,
+ QuicConnection* connection, const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
- const QuicServerId& server_id,
- QuicCryptoClientConfig* crypto_config)
- : QuicSpdyClientSessionBase(connection,
- &push_promise_index_,
- config,
+ const QuicServerId& server_id, QuicCryptoClientConfig* crypto_config)
+ : QuicSpdyClientSessionBase(connection, &push_promise_index_, config,
supported_versions) {
// TODO(b/153726130): Consider adding SetServerApplicationStateForResumption
// calls in tests and set |has_application_state| to true.
@@ -875,17 +811,11 @@
MockNetworkChangeVisitor::~MockNetworkChangeVisitor() {}
-QuicIpAddress TestPeerIPAddress() {
- return QuicIpAddress::Loopback4();
-}
+QuicIpAddress TestPeerIPAddress() { return QuicIpAddress::Loopback4(); }
-ParsedQuicVersion QuicVersionMax() {
- return AllSupportedVersions().front();
-}
+ParsedQuicVersion QuicVersionMax() { return AllSupportedVersions().front(); }
-ParsedQuicVersion QuicVersionMin() {
- return AllSupportedVersions().back();
-}
+ParsedQuicVersion QuicVersionMin() { return AllSupportedVersions().back(); }
void DisableQuicVersionsWithTls() {
for (const ParsedQuicVersion& version : AllSupportedVersionsWithTls()) {
@@ -895,11 +825,8 @@
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) {
return ConstructEncryptedPacket(
destination_connection_id, source_connection_id, version_flag, reset_flag,
packet_number, data, CONNECTION_ID_PRESENT, CONNECTION_ID_ABSENT,
@@ -908,11 +835,8 @@
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) {
@@ -924,11 +848,8 @@
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,
@@ -942,12 +863,8 @@
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,
@@ -961,17 +878,12 @@
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) {
QuicPacketHeader header;
header.destination_connection_id = destination_connection_id;
header.destination_connection_id_included =
@@ -1082,8 +994,7 @@
}
QuicReceivedPacket* ConstructReceivedPacket(
- const QuicEncryptedPacket& encrypted_packet,
- QuicTime receipt_time) {
+ const QuicEncryptedPacket& encrypted_packet, QuicTime receipt_time) {
char* buffer = new char[encrypted_packet.length()];
memcpy(buffer, encrypted_packet.data(), encrypted_packet.length());
return new QuicReceivedPacket(buffer, encrypted_packet.length(), receipt_time,
@@ -1092,15 +1003,11 @@
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) {
QuicPacketHeader header;
header.destination_connection_id = destination_connection_id;
@@ -1210,11 +1117,9 @@
}
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) {
@@ -1235,11 +1140,9 @@
}
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* server_crypto_config,
QuicCompressedCertsCache* compressed_certs_cache,
PacketSavingConnection** server_connection,
@@ -1265,8 +1168,7 @@
}
QuicStreamId GetNthClientInitiatedBidirectionalStreamId(
- QuicTransportVersion version,
- int n) {
+ QuicTransportVersion version, int n) {
int num = n;
if (!VersionUsesHttp3(version)) {
num++;
@@ -1277,33 +1179,28 @@
}
QuicStreamId GetNthServerInitiatedBidirectionalStreamId(
- QuicTransportVersion version,
- int n) {
+ QuicTransportVersion version, int n) {
return QuicUtils::GetFirstBidirectionalStreamId(version,
Perspective::IS_SERVER) +
QuicUtils::StreamIdDelta(version) * n;
}
QuicStreamId GetNthServerInitiatedUnidirectionalStreamId(
- QuicTransportVersion version,
- int n) {
+ QuicTransportVersion version, int n) {
return QuicUtils::GetFirstUnidirectionalStreamId(version,
Perspective::IS_SERVER) +
QuicUtils::StreamIdDelta(version) * n;
}
QuicStreamId GetNthClientInitiatedUnidirectionalStreamId(
- QuicTransportVersion version,
- int n) {
+ QuicTransportVersion version, int n) {
return QuicUtils::GetFirstUnidirectionalStreamId(version,
Perspective::IS_CLIENT) +
QuicUtils::StreamIdDelta(version) * 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) {
return version.HasIetfQuicFrames()
? QuicUtils::GetStreamType(id, perspective, is_incoming, version)
@@ -1322,8 +1219,7 @@
bool TaggingEncrypter::EncryptPacket(uint64_t /*packet_number*/,
absl::string_view /*associated_data*/,
- absl::string_view plaintext,
- char* output,
+ absl::string_view plaintext, char* output,
size_t* output_length,
size_t max_output_length) {
const size_t len = plaintext.size() + kTagSize;
@@ -1340,8 +1236,7 @@
bool TaggingDecrypter::DecryptPacket(uint64_t /*packet_number*/,
absl::string_view /*associated_data*/,
- absl::string_view ciphertext,
- char* output,
+ absl::string_view ciphertext, char* output,
size_t* output_length,
size_t /*max_output_length*/) {
if (ciphertext.size() < kTagSize) {
@@ -1365,8 +1260,7 @@
return true;
}
-TestPacketWriter::TestPacketWriter(ParsedQuicVersion version,
- MockClock* clock,
+TestPacketWriter::TestPacketWriter(ParsedQuicVersion version, MockClock* clock,
Perspective perspective)
: version_(version),
framer_(SupportedVersions(version_),
@@ -1394,8 +1288,7 @@
}
}
-WriteResult TestPacketWriter::WritePacket(const char* buffer,
- size_t buf_len,
+WriteResult TestPacketWriter::WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
PerPacketOptions* /*options*/) {
@@ -1521,8 +1414,7 @@
}
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) {
if (packet_bytes == nullptr) {
@@ -1556,8 +1448,7 @@
}
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) {
if (packet_bytes == nullptr) {
diff --git a/quiche/quic/test_tools/quic_time_wait_list_manager_peer.cc b/quiche/quic/test_tools/quic_time_wait_list_manager_peer.cc
index 5199282..b8c38ca 100644
--- a/quiche/quic/test_tools/quic_time_wait_list_manager_peer.cc
+++ b/quiche/quic/test_tools/quic_time_wait_list_manager_peer.cc
@@ -8,8 +8,7 @@
namespace test {
bool QuicTimeWaitListManagerPeer::ShouldSendResponse(
- QuicTimeWaitListManager* manager,
- int received_packet_count) {
+ QuicTimeWaitListManager* manager, int received_packet_count) {
return manager->ShouldSendResponse(received_packet_count);
}
diff --git a/quiche/quic/test_tools/quic_unacked_packet_map_peer.cc b/quiche/quic/test_tools/quic_unacked_packet_map_peer.cc
index d253cc2..4df89b0 100644
--- a/quiche/quic/test_tools/quic_unacked_packet_map_peer.cc
+++ b/quiche/quic/test_tools/quic_unacked_packet_map_peer.cc
@@ -15,8 +15,7 @@
// static
void QuicUnackedPacketMapPeer::SetPerspective(
- QuicUnackedPacketMap* unacked_packets,
- Perspective perspective) {
+ QuicUnackedPacketMap* unacked_packets, Perspective perspective) {
*const_cast<Perspective*>(&unacked_packets->perspective_) = perspective;
}
diff --git a/quiche/quic/test_tools/simple_data_producer.cc b/quiche/quic/test_tools/simple_data_producer.cc
index cf899c5..f0adc68 100644
--- a/quiche/quic/test_tools/simple_data_producer.cc
+++ b/quiche/quic/test_tools/simple_data_producer.cc
@@ -38,9 +38,7 @@
}
WriteStreamDataResult SimpleDataProducer::WriteStreamData(
- QuicStreamId id,
- QuicStreamOffset offset,
- QuicByteCount data_length,
+ QuicStreamId id, QuicStreamOffset offset, QuicByteCount data_length,
QuicDataWriter* writer) {
auto iter = send_buffer_map_.find(id);
if (iter == send_buffer_map_.end()) {
diff --git a/quiche/quic/test_tools/simple_data_producer.h b/quiche/quic/test_tools/simple_data_producer.h
index 938c87e..dd312d9 100644
--- a/quiche/quic/test_tools/simple_data_producer.h
+++ b/quiche/quic/test_tools/simple_data_producer.h
@@ -28,8 +28,7 @@
// that stream.
void SaveStreamData(QuicStreamId id, absl::string_view data);
- void SaveCryptoData(EncryptionLevel level,
- QuicStreamOffset offset,
+ void SaveCryptoData(EncryptionLevel level, QuicStreamOffset offset,
absl::string_view data);
// QuicStreamFrameDataProducer
@@ -37,8 +36,7 @@
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;
diff --git a/quiche/quic/test_tools/simple_quic_framer.cc b/quiche/quic/test_tools/simple_quic_framer.cc
index 9f1910f..793afc4 100644
--- a/quiche/quic/test_tools/simple_quic_framer.cc
+++ b/quiche/quic/test_tools/simple_quic_framer.cc
@@ -319,24 +319,17 @@
};
SimpleQuicFramer::SimpleQuicFramer()
- : framer_(AllSupportedVersions(),
- QuicTime::Zero(),
- Perspective::IS_SERVER,
+ : framer_(AllSupportedVersions(), QuicTime::Zero(), Perspective::IS_SERVER,
kQuicDefaultConnectionIdLength) {}
SimpleQuicFramer::SimpleQuicFramer(
const ParsedQuicVersionVector& supported_versions)
- : framer_(supported_versions,
- QuicTime::Zero(),
- Perspective::IS_SERVER,
+ : framer_(supported_versions, QuicTime::Zero(), Perspective::IS_SERVER,
kQuicDefaultConnectionIdLength) {}
SimpleQuicFramer::SimpleQuicFramer(
- const ParsedQuicVersionVector& supported_versions,
- Perspective perspective)
- : framer_(supported_versions,
- QuicTime::Zero(),
- perspective,
+ const ParsedQuicVersionVector& supported_versions, Perspective perspective)
+ : framer_(supported_versions, QuicTime::Zero(), perspective,
kQuicDefaultConnectionIdLength) {}
SimpleQuicFramer::~SimpleQuicFramer() {}
@@ -364,9 +357,7 @@
return visitor_->last_decrypted_level();
}
-QuicFramer* SimpleQuicFramer::framer() {
- return &framer_;
-}
+QuicFramer* SimpleQuicFramer::framer() { return &framer_; }
size_t SimpleQuicFramer::num_frames() const {
return ack_frames().size() + goaway_frames().size() +
diff --git a/quiche/quic/test_tools/simple_session_cache.cc b/quiche/quic/test_tools/simple_session_cache.cc
index eafead3..05f433d 100644
--- a/quiche/quic/test_tools/simple_session_cache.cc
+++ b/quiche/quic/test_tools/simple_session_cache.cc
@@ -3,7 +3,9 @@
// found in the LICENSE file.
#include "quiche/quic/test_tools/simple_session_cache.h"
+
#include <memory>
+
#include "quiche/quic/core/crypto/quic_crypto_client_config.h"
namespace quic {
diff --git a/quiche/quic/test_tools/simple_session_cache.h b/quiche/quic/test_tools/simple_session_cache.h
index 343303a..9055800 100644
--- a/quiche/quic/test_tools/simple_session_cache.h
+++ b/quiche/quic/test_tools/simple_session_cache.h
@@ -6,6 +6,7 @@
#define QUICHE_QUIC_TEST_TOOLS_SIMPLE_SESSION_CACHE_H_
#include <memory>
+
#include "quiche/quic/core/crypto/quic_crypto_client_config.h"
#include "quiche/quic/core/crypto/transport_parameters.h"
diff --git a/quiche/quic/test_tools/simple_session_notifier.cc b/quiche/quic/test_tools/simple_session_notifier.cc
index acd249e..123eb6e 100644
--- a/quiche/quic/test_tools/simple_session_notifier.cc
+++ b/quiche/quic/test_tools/simple_session_notifier.cc
@@ -36,9 +36,7 @@
SimpleSessionNotifier::StreamState::~StreamState() {}
QuicConsumedData SimpleSessionNotifier::WriteOrBufferData(
- QuicStreamId id,
- QuicByteCount data_length,
- StreamSendingState state) {
+ QuicStreamId id, QuicByteCount data_length, StreamSendingState state) {
if (!stream_map_.contains(id)) {
stream_map_[id] = StreamState();
}
@@ -91,8 +89,7 @@
}
void SimpleSessionNotifier::WriteOrBufferRstStream(
- QuicStreamId id,
- QuicRstStreamErrorCode error,
+ QuicStreamId id, QuicRstStreamErrorCode error,
QuicStreamOffset bytes_written) {
QUIC_DVLOG(1) << "Writing RST_STREAM_FRAME";
const bool had_buffered_data =
@@ -494,8 +491,7 @@
bool SimpleSessionNotifier::HasUnackedStreamData() const {
for (const auto& it : stream_map_) {
- if (StreamIsWaitingForAcks(it.first))
- return true;
+ if (StreamIsWaitingForAcks(it.first)) return true;
}
return false;
}
diff --git a/quiche/quic/test_tools/simple_session_notifier.h b/quiche/quic/test_tools/simple_session_notifier.h
index a78fe1c..e846499 100644
--- a/quiche/quic/test_tools/simple_session_notifier.h
+++ b/quiche/quic/test_tools/simple_session_notifier.h
@@ -26,13 +26,11 @@
~SimpleSessionNotifier() override;
// Tries to write stream data and returns data consumed.
- QuicConsumedData WriteOrBufferData(QuicStreamId id,
- QuicByteCount data_length,
+ QuicConsumedData WriteOrBufferData(QuicStreamId id, QuicByteCount data_length,
StreamSendingState state);
// Tries to write RST_STREAM_FRAME.
- void WriteOrBufferRstStream(QuicStreamId id,
- QuicRstStreamErrorCode error,
+ void WriteOrBufferRstStream(QuicStreamId id, QuicRstStreamErrorCode error,
QuicStreamOffset bytes_written);
// Tries to write WINDOW_UPDATE.
@@ -46,8 +44,7 @@
const QuicAckFrequencyFrame& ack_frequency_frame);
// Tries to write CRYPTO data and returns the number of bytes written.
- size_t WriteCryptoData(EncryptionLevel level,
- QuicByteCount data_length,
+ size_t WriteCryptoData(EncryptionLevel level, QuicByteCount data_length,
QuicStreamOffset offset);
// Neuters unencrypted data of crypto stream.
@@ -78,8 +75,7 @@
bool StreamIsWaitingForAcks(QuicStreamId id) const;
// 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;
@@ -114,10 +110,8 @@
using StreamMap = absl::flat_hash_map<QuicStreamId, StreamState>;
- void OnStreamDataConsumed(QuicStreamId id,
- QuicStreamOffset offset,
- QuicByteCount data_length,
- bool fin);
+ void OnStreamDataConsumed(QuicStreamId id, QuicStreamOffset offset,
+ QuicByteCount data_length, bool fin);
bool OnControlFrameAcked(const QuicFrame& frame);
diff --git a/quiche/quic/test_tools/simple_session_notifier_test.cc b/quiche/quic/test_tools/simple_session_notifier_test.cc
index 77e3bf7..2aa35e5 100644
--- a/quiche/quic/test_tools/simple_session_notifier_test.cc
+++ b/quiche/quic/test_tools/simple_session_notifier_test.cc
@@ -29,11 +29,8 @@
Perspective perspective)
: MockQuicConnection(helper, alarm_factory, perspective) {}
- MOCK_METHOD(QuicConsumedData,
- SendStreamData,
- (QuicStreamId id,
- size_t write_length,
- QuicStreamOffset offset,
+ MOCK_METHOD(QuicConsumedData, SendStreamData,
+ (QuicStreamId id, size_t write_length, QuicStreamOffset offset,
StreamSendingState state),
(override));
};
diff --git a/quiche/quic/test_tools/test_certificates.cc b/quiche/quic/test_tools/test_certificates.cc
index 67ef981..6d450a8 100644
--- a/quiche/quic/test_tools/test_certificates.cc
+++ b/quiche/quic/test_tools/test_certificates.cc
@@ -117,8 +117,7 @@
'\xa1', '\xa9', '\x51', '\x51', '\x0f', '\xad', '\x60'};
ABSL_CONST_INIT const absl::string_view kTestCertificate(
- kTestCertificateRaw,
- sizeof(kTestCertificateRaw));
+ kTestCertificateRaw, sizeof(kTestCertificateRaw));
ABSL_CONST_INIT const char kTestCertificatePem[] =
R"(Certificate:
@@ -416,8 +415,7 @@
'\x59'};
ABSL_CONST_INIT const absl::string_view kTestCertificatePrivateKey(
- kTestCertificatePrivateKeyRaw,
- sizeof(kTestCertificatePrivateKeyRaw));
+ kTestCertificatePrivateKeyRaw, sizeof(kTestCertificatePrivateKeyRaw));
ABSL_CONST_INIT const char kTestCertificatePrivateKeyPem[] =
R"(-----BEGIN PRIVATE KEY-----
@@ -575,8 +573,7 @@
'\x93', '\x5f', '\x35'};
ABSL_CONST_INIT const absl::string_view kWildcardCertificate(
- kWildcardCertificateRaw,
- sizeof(kWildcardCertificateRaw));
+ kWildcardCertificateRaw, sizeof(kWildcardCertificateRaw));
ABSL_CONST_INIT const char kWildcardCertificatePrivateKeyRaw[] = {
'\x30', '\x82', '\x04', '\xbe', '\x02', '\x01', '\x00', '\x30', '\x0d',
diff --git a/quiche/quic/test_tools/test_ticket_crypter.cc b/quiche/quic/test_tools/test_ticket_crypter.cc
index 7c4a54e..b886dde 100644
--- a/quiche/quic/test_tools/test_ticket_crypter.cc
+++ b/quiche/quic/test_tools/test_ticket_crypter.cc
@@ -33,9 +33,7 @@
ticket_prefix_.data() + ABSL_ARRAYSIZE(kTicketPrefix), 16);
}
-size_t TestTicketCrypter::MaxOverhead() {
- return ticket_prefix_.size();
-}
+size_t TestTicketCrypter::MaxOverhead() { return ticket_prefix_.size(); }
std::vector<uint8_t> TestTicketCrypter::Encrypt(
absl::string_view in, absl::string_view /* encryption_key */) {
