Move QuicReferenceCounted into QUICHE and rename it into QuicheReferenceCounted.
PiperOrigin-RevId: 433215748
diff --git a/common/platform/api/quiche_reference_counted.h b/common/platform/api/quiche_reference_counted.h
new file mode 100644
index 0000000..82fce6d
--- /dev/null
+++ b/common/platform/api/quiche_reference_counted.h
@@ -0,0 +1,169 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_PLATFORM_API_QUIC_REFERENCE_COUNTED_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_REFERENCE_COUNTED_H_
+
+#include "common/platform/api/quiche_export.h"
+#include "net/quiche/common/platform/impl/quiche_reference_counted_impl.h"
+
+namespace quiche {
+
+// Base class for explicitly reference-counted objects in QUIC.
+class QUICHE_EXPORT_PRIVATE QuicheReferenceCounted
+ : public QuicheReferenceCountedImpl {
+ public:
+ QuicheReferenceCounted() {}
+
+ protected:
+ ~QuicheReferenceCounted() override {}
+};
+
+// A class representing a reference counted pointer in QUIC.
+//
+// Construct or initialize QuicheReferenceCountedPointer from raw pointer. Here
+// raw pointer MUST be a newly created object. Reference count of a newly
+// created object is undefined, but that will be 1 after being added to
+// QuicheReferenceCountedPointer.
+// QuicheReferenceCountedPointer is used as a local variable.
+// QuicheReferenceCountedPointer<T> r_ptr(new T());
+// or, equivalently:
+// QuicheReferenceCountedPointer<T> r_ptr;
+// T* p = new T();
+// r_ptr = T;
+//
+// QuicheReferenceCountedPointer is used as a member variable:
+// MyClass::MyClass() : r_ptr(new T()) {}
+//
+// This is WRONG, since *p is not guaranteed to be newly created:
+// MyClass::MyClass(T* p) : r_ptr(p) {}
+//
+// Given an existing QuicheReferenceCountedPointer, create a duplicate that has
+// its own reference on the object:
+// QuicheReferenceCountedPointer<T> r_ptr_b(r_ptr_a);
+// or, equivalently:
+// QuicheReferenceCountedPointer<T> r_ptr_b = r_ptr_a;
+//
+// Given an existing QuicheReferenceCountedPointer, create a
+// QuicheReferenceCountedPointer that adopts the reference:
+// QuicheReferenceCountedPointer<T> r_ptr_b(std::move(r_ptr_a));
+// or, equivalently:
+// QuicheReferenceCountedPointer<T> r_ptr_b = std::move(r_ptr_a);
+
+template <class T>
+class QUICHE_NO_EXPORT QuicheReferenceCountedPointer {
+ public:
+ QuicheReferenceCountedPointer() = default;
+
+ // Constructor from raw pointer |p|. This guarantees that the reference count
+ // of *p is 1. This should be only called when a new object is created.
+ // Calling this on an already existent object does not increase its reference
+ // count.
+ explicit QuicheReferenceCountedPointer(T* p) : impl_(p) {}
+
+ // Allows implicit conversion from nullptr.
+ QuicheReferenceCountedPointer(std::nullptr_t) : impl_(nullptr) {} // NOLINT
+
+ // Copy and copy conversion constructors. It does not take the reference away
+ // from |other| and they each end up with their own reference.
+ template <typename U>
+ QuicheReferenceCountedPointer( // NOLINT
+ const QuicheReferenceCountedPointer<U>& other)
+ : impl_(other.impl()) {}
+ QuicheReferenceCountedPointer(const QuicheReferenceCountedPointer& other)
+ : impl_(other.impl()) {}
+
+ // Move constructors. After move, it adopts the reference from |other|.
+ template <typename U>
+ QuicheReferenceCountedPointer(
+ QuicheReferenceCountedPointer<U>&& other) // NOLINT
+ : impl_(std::move(other.impl())) {}
+ QuicheReferenceCountedPointer(QuicheReferenceCountedPointer&& other)
+ : impl_(std::move(other.impl())) {}
+
+ ~QuicheReferenceCountedPointer() = default;
+
+ // Copy assignments.
+ QuicheReferenceCountedPointer& operator=(
+ const QuicheReferenceCountedPointer& other) {
+ impl_ = other.impl();
+ return *this;
+ }
+ template <typename U>
+ QuicheReferenceCountedPointer<T>& operator=(
+ const QuicheReferenceCountedPointer<U>& other) {
+ impl_ = other.impl();
+ return *this;
+ }
+
+ // Move assignments.
+ QuicheReferenceCountedPointer& operator=(
+ QuicheReferenceCountedPointer&& other) {
+ impl_ = std::move(other.impl());
+ return *this;
+ }
+ template <typename U>
+ QuicheReferenceCountedPointer<T>& operator=(
+ QuicheReferenceCountedPointer<U>&& other) {
+ impl_ = std::move(other.impl());
+ return *this;
+ }
+
+ // Accessors for the referenced object.
+ // operator*() and operator->() will assert() if there is no current object.
+ T& operator*() const { return *impl_; }
+ T* operator->() const { return impl_.get(); }
+
+ explicit operator bool() const { return static_cast<bool>(impl_); }
+
+ // Assignment operator on raw pointer. Drops a reference to current pointee,
+ // if any, and replaces it with |p|. This guarantees that the reference count
+ // of *p is 1. This should only be used when a new object is created. Calling
+ // this on an already existent object is undefined behavior.
+ QuicheReferenceCountedPointer<T>& operator=(T* p) {
+ impl_ = p;
+ return *this;
+ }
+
+ // Returns the raw pointer with no change in reference count.
+ T* get() const { return impl_.get(); }
+
+ QuicheReferenceCountedPointerImpl<T>& impl() { return impl_; }
+ const QuicheReferenceCountedPointerImpl<T>& impl() const { return impl_; }
+
+ // Comparisons against same type.
+ friend bool operator==(const QuicheReferenceCountedPointer& a,
+ const QuicheReferenceCountedPointer& b) {
+ return a.get() == b.get();
+ }
+ friend bool operator!=(const QuicheReferenceCountedPointer& a,
+ const QuicheReferenceCountedPointer& b) {
+ return a.get() != b.get();
+ }
+
+ // Comparisons against nullptr.
+ friend bool operator==(const QuicheReferenceCountedPointer& a,
+ std::nullptr_t) {
+ return a.get() == nullptr;
+ }
+ friend bool operator==(std::nullptr_t,
+ const QuicheReferenceCountedPointer& b) {
+ return nullptr == b.get();
+ }
+ friend bool operator!=(const QuicheReferenceCountedPointer& a,
+ std::nullptr_t) {
+ return a.get() != nullptr;
+ }
+ friend bool operator!=(std::nullptr_t,
+ const QuicheReferenceCountedPointer& b) {
+ return nullptr != b.get();
+ }
+
+ private:
+ QuicheReferenceCountedPointerImpl<T> impl_;
+};
+
+} // namespace quiche
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_REFERENCE_COUNTED_H_
diff --git a/common/platform/api/quiche_reference_counted_test.cc b/common/platform/api/quiche_reference_counted_test.cc
new file mode 100644
index 0000000..bb4dc4f
--- /dev/null
+++ b/common/platform/api/quiche_reference_counted_test.cc
@@ -0,0 +1,173 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "common/platform/api/quiche_reference_counted.h"
+
+#include "quic/platform/api/quic_test.h"
+
+namespace quiche {
+namespace test {
+namespace {
+
+class Base : public QuicheReferenceCounted {
+ public:
+ explicit Base(bool* destroyed) : destroyed_(destroyed) {
+ *destroyed_ = false;
+ }
+
+ protected:
+ ~Base() override { *destroyed_ = true; }
+
+ private:
+ bool* destroyed_;
+};
+
+class Derived : public Base {
+ public:
+ explicit Derived(bool* destroyed) : Base(destroyed) {}
+
+ private:
+ ~Derived() override {}
+};
+
+class QuicheReferenceCountedTest : public QuicTest {};
+
+TEST_F(QuicheReferenceCountedTest, DefaultConstructor) {
+ QuicheReferenceCountedPointer<Base> a;
+ EXPECT_EQ(nullptr, a);
+ EXPECT_EQ(nullptr, a.get());
+ EXPECT_FALSE(a);
+}
+
+TEST_F(QuicheReferenceCountedTest, ConstructFromRawPointer) {
+ bool destroyed = false;
+ {
+ QuicheReferenceCountedPointer<Base> a(new Base(&destroyed));
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_TRUE(destroyed);
+}
+
+TEST_F(QuicheReferenceCountedTest, RawPointerAssignment) {
+ bool destroyed = false;
+ {
+ QuicheReferenceCountedPointer<Base> a;
+ Base* rct = new Base(&destroyed);
+ a = rct;
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_TRUE(destroyed);
+}
+
+TEST_F(QuicheReferenceCountedTest, PointerCopy) {
+ bool destroyed = false;
+ {
+ QuicheReferenceCountedPointer<Base> a(new Base(&destroyed));
+ {
+ QuicheReferenceCountedPointer<Base> b(a);
+ EXPECT_EQ(a, b);
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_TRUE(destroyed);
+}
+
+TEST_F(QuicheReferenceCountedTest, PointerCopyAssignment) {
+ bool destroyed = false;
+ {
+ QuicheReferenceCountedPointer<Base> a(new Base(&destroyed));
+ {
+ QuicheReferenceCountedPointer<Base> b = a;
+ EXPECT_EQ(a, b);
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_TRUE(destroyed);
+}
+
+TEST_F(QuicheReferenceCountedTest, PointerCopyFromOtherType) {
+ bool destroyed = false;
+ {
+ QuicheReferenceCountedPointer<Derived> a(new Derived(&destroyed));
+ {
+ QuicheReferenceCountedPointer<Base> b(a);
+ EXPECT_EQ(a.get(), b.get());
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_TRUE(destroyed);
+}
+
+TEST_F(QuicheReferenceCountedTest, PointerCopyAssignmentFromOtherType) {
+ bool destroyed = false;
+ {
+ QuicheReferenceCountedPointer<Derived> a(new Derived(&destroyed));
+ {
+ QuicheReferenceCountedPointer<Base> b = a;
+ EXPECT_EQ(a.get(), b.get());
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_TRUE(destroyed);
+}
+
+TEST_F(QuicheReferenceCountedTest, PointerMove) {
+ bool destroyed = false;
+ QuicheReferenceCountedPointer<Base> a(new Derived(&destroyed));
+ EXPECT_FALSE(destroyed);
+ QuicheReferenceCountedPointer<Base> b(std::move(a));
+ EXPECT_FALSE(destroyed);
+ EXPECT_NE(nullptr, b);
+ EXPECT_EQ(nullptr, a); // NOLINT
+
+ b = nullptr;
+ EXPECT_TRUE(destroyed);
+}
+
+TEST_F(QuicheReferenceCountedTest, PointerMoveAssignment) {
+ bool destroyed = false;
+ QuicheReferenceCountedPointer<Base> a(new Derived(&destroyed));
+ EXPECT_FALSE(destroyed);
+ QuicheReferenceCountedPointer<Base> b = std::move(a);
+ EXPECT_FALSE(destroyed);
+ EXPECT_NE(nullptr, b);
+ EXPECT_EQ(nullptr, a); // NOLINT
+
+ b = nullptr;
+ EXPECT_TRUE(destroyed);
+}
+
+TEST_F(QuicheReferenceCountedTest, PointerMoveFromOtherType) {
+ bool destroyed = false;
+ QuicheReferenceCountedPointer<Derived> a(new Derived(&destroyed));
+ EXPECT_FALSE(destroyed);
+ QuicheReferenceCountedPointer<Base> b(std::move(a));
+ EXPECT_FALSE(destroyed);
+ EXPECT_NE(nullptr, b);
+ EXPECT_EQ(nullptr, a); // NOLINT
+
+ b = nullptr;
+ EXPECT_TRUE(destroyed);
+}
+
+TEST_F(QuicheReferenceCountedTest, PointerMoveAssignmentFromOtherType) {
+ bool destroyed = false;
+ QuicheReferenceCountedPointer<Derived> a(new Derived(&destroyed));
+ EXPECT_FALSE(destroyed);
+ QuicheReferenceCountedPointer<Base> b = std::move(a);
+ EXPECT_FALSE(destroyed);
+ EXPECT_NE(nullptr, b);
+ EXPECT_EQ(nullptr, a); // NOLINT
+
+ b = nullptr;
+ EXPECT_TRUE(destroyed);
+}
+
+} // namespace
+} // namespace test
+} // namespace quiche
diff --git a/quic/core/crypto/client_proof_source.cc b/quic/core/crypto/client_proof_source.cc
index 4e4d442..7f2e1fd 100644
--- a/quic/core/crypto/client_proof_source.cc
+++ b/quic/core/crypto/client_proof_source.cc
@@ -10,7 +10,7 @@
bool DefaultClientProofSource::AddCertAndKey(
std::vector<std::string> server_hostnames,
- QuicReferenceCountedPointer<Chain> chain,
+ quiche::QuicheReferenceCountedPointer<Chain> chain,
CertificatePrivateKey private_key) {
if (!ValidateCertAndKey(chain, private_key)) {
return false;
diff --git a/quic/core/crypto/client_proof_source.h b/quic/core/crypto/client_proof_source.h
index d1ab26c..2db8205 100644
--- a/quic/core/crypto/client_proof_source.h
+++ b/quic/core/crypto/client_proof_source.h
@@ -22,11 +22,11 @@
virtual ~ClientProofSource() {}
struct QUIC_EXPORT_PRIVATE CertAndKey {
- CertAndKey(QuicReferenceCountedPointer<Chain> chain,
+ CertAndKey(quiche::QuicheReferenceCountedPointer<Chain> chain,
CertificatePrivateKey private_key)
: chain(std::move(chain)), private_key(std::move(private_key)) {}
- QuicReferenceCountedPointer<Chain> chain;
+ quiche::QuicheReferenceCountedPointer<Chain> chain;
CertificatePrivateKey private_key;
};
@@ -54,7 +54,7 @@
// If any element of |server_hostnames| is already associated with a cert
// chain, it will be updated to be associated with the new cert chain.
bool AddCertAndKey(std::vector<std::string> server_hostnames,
- QuicReferenceCountedPointer<Chain> chain,
+ quiche::QuicheReferenceCountedPointer<Chain> chain,
CertificatePrivateKey private_key);
// ClientProofSource implementation
diff --git a/quic/core/crypto/client_proof_source_test.cc b/quic/core/crypto/client_proof_source_test.cc
index 08f5b76..d8192b8 100644
--- a/quic/core/crypto/client_proof_source_test.cc
+++ b/quic/core/crypto/client_proof_source_test.cc
@@ -11,8 +11,9 @@
namespace quic {
namespace test {
-QuicReferenceCountedPointer<ClientProofSource::Chain> TestCertChain() {
- return QuicReferenceCountedPointer<ClientProofSource::Chain>(
+quiche::QuicheReferenceCountedPointer<ClientProofSource::Chain>
+TestCertChain() {
+ return quiche::QuicheReferenceCountedPointer<ClientProofSource::Chain>(
new ClientProofSource::Chain({std::string(kTestCertificate)}));
}
@@ -32,17 +33,19 @@
return &cert_and_key;
}
-QuicReferenceCountedPointer<ClientProofSource::Chain> NullCertChain() {
- return QuicReferenceCountedPointer<ClientProofSource::Chain>();
+quiche::QuicheReferenceCountedPointer<ClientProofSource::Chain>
+NullCertChain() {
+ return quiche::QuicheReferenceCountedPointer<ClientProofSource::Chain>();
}
-QuicReferenceCountedPointer<ClientProofSource::Chain> EmptyCertChain() {
- return QuicReferenceCountedPointer<ClientProofSource::Chain>(
+quiche::QuicheReferenceCountedPointer<ClientProofSource::Chain>
+EmptyCertChain() {
+ return quiche::QuicheReferenceCountedPointer<ClientProofSource::Chain>(
new ClientProofSource::Chain(std::vector<std::string>()));
}
-QuicReferenceCountedPointer<ClientProofSource::Chain> BadCertChain() {
- return QuicReferenceCountedPointer<ClientProofSource::Chain>(
+quiche::QuicheReferenceCountedPointer<ClientProofSource::Chain> BadCertChain() {
+ return quiche::QuicheReferenceCountedPointer<ClientProofSource::Chain>(
new ClientProofSource::Chain({"This is the content of a bad cert."}));
}
diff --git a/quic/core/crypto/crypto_handshake.h b/quic/core/crypto/crypto_handshake.h
index eefe4b6..a7a5fb0 100644
--- a/quic/core/crypto/crypto_handshake.h
+++ b/quic/core/crypto/crypto_handshake.h
@@ -98,7 +98,7 @@
// Parameters negotiated by the crypto handshake.
struct QUIC_EXPORT_PRIVATE QuicCryptoNegotiatedParameters
- : public QuicReferenceCounted {
+ : public quiche::QuicheReferenceCounted {
// Initializes the members to 0 or empty values.
QuicCryptoNegotiatedParameters();
diff --git a/quic/core/crypto/crypto_server_test.cc b/quic/core/crypto/crypto_server_test.cc
index 90327e3..d6c5815 100644
--- a/quic/core/crypto/crypto_server_test.cc
+++ b/quic/core/crypto/crypto_server_test.cc
@@ -166,8 +166,9 @@
ASSERT_TRUE(server_config_->GetStringPiece(kSCID, &scid));
scid_hex_ = "#" + absl::BytesToHexString(scid);
- signed_config_ = QuicReferenceCountedPointer<QuicSignedServerConfig>(
- new QuicSignedServerConfig());
+ signed_config_ =
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig>(
+ new QuicSignedServerConfig());
QUICHE_DCHECK(signed_config_->chain.get() == nullptr);
}
@@ -186,7 +187,7 @@
*called_ = false;
}
- void Run(QuicReferenceCountedPointer<Result> result,
+ void Run(quiche::QuicheReferenceCountedPointer<Result> result,
std::unique_ptr<ProofSource::Details> /* details */) override {
ASSERT_FALSE(*called_);
test_->ProcessValidationResult(std::move(result), should_succeed_,
@@ -247,10 +248,8 @@
class ProcessCallback : public ProcessClientHelloResultCallback {
public:
ProcessCallback(
- QuicReferenceCountedPointer<ValidateCallback::Result> result,
- bool should_succeed,
- const char* error_substr,
- bool* called,
+ quiche::QuicheReferenceCountedPointer<ValidateCallback::Result> result,
+ bool should_succeed, const char* error_substr, bool* called,
CryptoHandshakeMessage* out)
: result_(std::move(result)),
should_succeed_(should_succeed),
@@ -283,7 +282,8 @@
}
private:
- const QuicReferenceCountedPointer<ValidateCallback::Result> result_;
+ const quiche::QuicheReferenceCountedPointer<ValidateCallback::Result>
+ result_;
const bool should_succeed_;
const char* const error_substr_;
bool* called_;
@@ -291,9 +291,8 @@
};
void ProcessValidationResult(
- QuicReferenceCountedPointer<ValidateCallback::Result> result,
- bool should_succeed,
- const char* error_substr) {
+ quiche::QuicheReferenceCountedPointer<ValidateCallback::Result> result,
+ bool should_succeed, const char* error_substr) {
QuicSocketAddress server_address(QuicIpAddress::Any4(), 5);
bool called;
config_.ProcessClientHello(
@@ -355,8 +354,8 @@
QuicCryptoServerConfigPeer peer_;
QuicCompressedCertsCache compressed_certs_cache_;
QuicCryptoServerConfig::ConfigOptions config_options_;
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
- QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config_;
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig> signed_config_;
CryptoHandshakeMessage out_;
uint8_t orbit_[kOrbitSize];
size_t chlo_packet_size_;
diff --git a/quic/core/crypto/proof_source.cc b/quic/core/crypto/proof_source.cc
index 9cb85c2..1f25a3c 100644
--- a/quic/core/crypto/proof_source.cc
+++ b/quic/core/crypto/proof_source.cc
@@ -33,7 +33,7 @@
}
bool ValidateCertAndKey(
- const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
const CertificatePrivateKey& key) {
if (chain.get() == nullptr || chain->certs.empty()) {
QUIC_BUG(quic_proof_source_empty_chain) << "Certificate chain is empty";
diff --git a/quic/core/crypto/proof_source.h b/quic/core/crypto/proof_source.h
index 2eb755a..8a57df6 100644
--- a/quic/core/crypto/proof_source.h
+++ b/quic/core/crypto/proof_source.h
@@ -15,8 +15,8 @@
#include "quic/core/crypto/quic_crypto_proof.h"
#include "quic/core/quic_versions.h"
#include "quic/platform/api/quic_export.h"
-#include "quic/platform/api/quic_reference_counted.h"
#include "quic/platform/api/quic_socket_address.h"
+#include "common/platform/api/quiche_reference_counted.h"
namespace quic {
@@ -41,7 +41,7 @@
public:
// Chain is a reference-counted wrapper for a vector of stringified
// certificates.
- struct QUIC_EXPORT_PRIVATE Chain : public QuicReferenceCounted {
+ struct QUIC_EXPORT_PRIVATE Chain : public quiche::QuicheReferenceCounted {
explicit Chain(const std::vector<std::string>& certs);
Chain(const Chain&) = delete;
Chain& operator=(const Chain&) = delete;
@@ -83,7 +83,7 @@
// any, gathered during the operation of GetProof. If no stats are
// available, this will be nullptr.
virtual void Run(bool ok,
- const QuicReferenceCountedPointer<Chain>& chain,
+ const quiche::QuicheReferenceCountedPointer<Chain>& chain,
const QuicCryptoProof& proof,
std::unique_ptr<Details> details) = 0;
@@ -149,7 +149,7 @@
//
// Sets *cert_matched_sni to true if the certificate matched the given
// hostname, false if a default cert not matching the hostname was used.
- virtual QuicReferenceCountedPointer<Chain> GetCertChain(
+ virtual quiche::QuicheReferenceCountedPointer<Chain> GetCertChain(
const QuicSocketAddress& server_address,
const QuicSocketAddress& client_address, const std::string& hostname,
bool* cert_matched_sni) = 0;
@@ -347,7 +347,7 @@
// Returns true if |chain| contains a parsable DER-encoded X.509 leaf cert and
// it matches with |key|.
QUIC_EXPORT_PRIVATE bool ValidateCertAndKey(
- const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
const CertificatePrivateKey& key);
} // namespace quic
diff --git a/quic/core/crypto/proof_source_x509.cc b/quic/core/crypto/proof_source_x509.cc
index 986ee32..ec9b85e 100644
--- a/quic/core/crypto/proof_source_x509.cc
+++ b/quic/core/crypto/proof_source_x509.cc
@@ -18,7 +18,7 @@
namespace quic {
std::unique_ptr<ProofSourceX509> ProofSourceX509::Create(
- QuicReferenceCountedPointer<Chain> default_chain,
+ quiche::QuicheReferenceCountedPointer<Chain> default_chain,
CertificatePrivateKey default_key) {
std::unique_ptr<ProofSourceX509> result(new ProofSourceX509());
if (!result->AddCertificateChain(default_chain, std::move(default_key))) {
@@ -61,10 +61,11 @@
nullptr);
}
-QuicReferenceCountedPointer<ProofSource::Chain> ProofSourceX509::GetCertChain(
- const QuicSocketAddress& /*server_address*/,
- const QuicSocketAddress& /*client_address*/, const std::string& hostname,
- bool* cert_matched_sni) {
+quiche::QuicheReferenceCountedPointer<ProofSource::Chain>
+ProofSourceX509::GetCertChain(const QuicSocketAddress& /*server_address*/,
+ const QuicSocketAddress& /*client_address*/,
+ const std::string& hostname,
+ bool* cert_matched_sni) {
return GetCertificate(hostname, cert_matched_sni)->chain;
}
@@ -93,7 +94,7 @@
}
bool ProofSourceX509::AddCertificateChain(
- QuicReferenceCountedPointer<Chain> chain,
+ quiche::QuicheReferenceCountedPointer<Chain> chain,
CertificatePrivateKey key) {
if (chain->certs.empty()) {
QUIC_BUG(quic_bug_10644_1) << "Empty certificate chain supplied.";
diff --git a/quic/core/crypto/proof_source_x509.h b/quic/core/crypto/proof_source_x509.h
index 4b7ae51..8c42f24 100644
--- a/quic/core/crypto/proof_source_x509.h
+++ b/quic/core/crypto/proof_source_x509.h
@@ -24,7 +24,7 @@
// Creates a proof source that uses |default_chain| when no SubjectAltName
// value matches. Returns nullptr if |default_chain| is invalid.
static std::unique_ptr<ProofSourceX509> Create(
- QuicReferenceCountedPointer<Chain> default_chain,
+ quiche::QuicheReferenceCountedPointer<Chain> default_chain,
CertificatePrivateKey default_key);
// ProofSource implementation.
@@ -35,7 +35,7 @@
QuicTransportVersion transport_version,
absl::string_view chlo_hash,
std::unique_ptr<Callback> callback) override;
- QuicReferenceCountedPointer<Chain> GetCertChain(
+ quiche::QuicheReferenceCountedPointer<Chain> GetCertChain(
const QuicSocketAddress& server_address,
const QuicSocketAddress& client_address, const std::string& hostname,
bool* cert_matched_sni) override;
@@ -52,14 +52,14 @@
// not valid. Newer certificates will override older certificates with the
// same SubjectAltName value.
ABSL_MUST_USE_RESULT bool AddCertificateChain(
- QuicReferenceCountedPointer<Chain> chain,
+ quiche::QuicheReferenceCountedPointer<Chain> chain,
CertificatePrivateKey key);
private:
ProofSourceX509() = default;
struct QUIC_EXPORT_PRIVATE Certificate {
- QuicReferenceCountedPointer<Chain> chain;
+ quiche::QuicheReferenceCountedPointer<Chain> chain;
CertificatePrivateKey key;
};
diff --git a/quic/core/crypto/proof_source_x509_test.cc b/quic/core/crypto/proof_source_x509_test.cc
index 1a9462f..1eac3fd 100644
--- a/quic/core/crypto/proof_source_x509_test.cc
+++ b/quic/core/crypto/proof_source_x509_test.cc
@@ -12,18 +12,18 @@
#include "quic/core/crypto/proof_source.h"
#include "quic/platform/api/quic_expect_bug.h"
#include "quic/platform/api/quic_ip_address.h"
-#include "quic/platform/api/quic_reference_counted.h"
#include "quic/platform/api/quic_socket_address.h"
#include "quic/platform/api/quic_test.h"
#include "quic/test_tools/test_certificates.h"
+#include "common/platform/api/quiche_reference_counted.h"
namespace quic {
namespace test {
namespace {
-QuicReferenceCountedPointer<ProofSource::Chain> MakeChain(
+quiche::QuicheReferenceCountedPointer<ProofSource::Chain> MakeChain(
absl::string_view cert) {
- return QuicReferenceCountedPointer<ProofSource::Chain>(
+ return quiche::QuicheReferenceCountedPointer<ProofSource::Chain>(
new ProofSource::Chain(std::vector<std::string>{std::string(cert)}));
}
@@ -41,7 +41,8 @@
}
protected:
- QuicReferenceCountedPointer<ProofSource::Chain> test_chain_, wildcard_chain_;
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> test_chain_,
+ wildcard_chain_;
std::unique_ptr<CertificatePrivateKey> test_key_, wildcard_key_;
};
diff --git a/quic/core/crypto/quic_compressed_certs_cache.cc b/quic/core/crypto/quic_compressed_certs_cache.cc
index 73008b9..3e011cc 100644
--- a/quic/core/crypto/quic_compressed_certs_cache.cc
+++ b/quic/core/crypto/quic_compressed_certs_cache.cc
@@ -25,10 +25,9 @@
client_cached_cert_hashes(nullptr) {}
QuicCompressedCertsCache::UncompressedCerts::UncompressedCerts(
- const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
const std::string* client_cached_cert_hashes)
- : chain(chain),
- client_cached_cert_hashes(client_cached_cert_hashes) {}
+ : chain(chain), client_cached_cert_hashes(client_cached_cert_hashes) {}
QuicCompressedCertsCache::UncompressedCerts::~UncompressedCerts() {}
@@ -67,7 +66,7 @@
}
const std::string* QuicCompressedCertsCache::GetCompressedCert(
- const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
const std::string& client_cached_cert_hashes) {
UncompressedCerts uncompressed_certs(chain, &client_cached_cert_hashes);
@@ -86,7 +85,7 @@
}
void QuicCompressedCertsCache::Insert(
- const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
const std::string& client_cached_cert_hashes,
const std::string& compressed_cert) {
UncompressedCerts uncompressed_certs(chain, &client_cached_cert_hashes);
diff --git a/quic/core/crypto/quic_compressed_certs_cache.h b/quic/core/crypto/quic_compressed_certs_cache.h
index 98e8a35..ffaf56f 100644
--- a/quic/core/crypto/quic_compressed_certs_cache.h
+++ b/quic/core/crypto/quic_compressed_certs_cache.h
@@ -25,16 +25,17 @@
// Otherwise, return nullptr.
// Returned pointer might become invalid on the next call to Insert().
const std::string* GetCompressedCert(
- const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
const std::string& client_cached_cert_hashes);
// Inserts the specified
// |chain, client_cached_cert_hashes, compressed_cert| tuple to the cache.
// If the insertion causes the cache to become overfull, entries will
// be deleted in an LRU order to make room.
- void Insert(const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
- const std::string& client_cached_cert_hashes,
- const std::string& compressed_cert);
+ void Insert(
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
+ const std::string& client_cached_cert_hashes,
+ const std::string& compressed_cert);
// Returns max number of cache entries the cache can carry.
size_t MaxSize();
@@ -52,11 +53,11 @@
struct QUIC_EXPORT_PRIVATE UncompressedCerts {
UncompressedCerts();
UncompressedCerts(
- const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
const std::string* client_cached_cert_hashes);
~UncompressedCerts();
- const QuicReferenceCountedPointer<ProofSource::Chain> chain;
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain;
const std::string* client_cached_cert_hashes;
};
@@ -80,7 +81,7 @@
private:
// Uncompressed certs data.
- QuicReferenceCountedPointer<ProofSource::Chain> chain_;
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain_;
const std::string client_cached_cert_hashes_;
// Cached compressed representation derived from uncompressed certs.
diff --git a/quic/core/crypto/quic_compressed_certs_cache_test.cc b/quic/core/crypto/quic_compressed_certs_cache_test.cc
index 2ce09c3..c76cd72 100644
--- a/quic/core/crypto/quic_compressed_certs_cache_test.cc
+++ b/quic/core/crypto/quic_compressed_certs_cache_test.cc
@@ -29,7 +29,7 @@
TEST_F(QuicCompressedCertsCacheTest, CacheHit) {
std::vector<std::string> certs = {"leaf cert", "intermediate cert",
"root cert"};
- QuicReferenceCountedPointer<ProofSource::Chain> chain(
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain(
new ProofSource::Chain(certs));
std::string cached_certs = "cached certs";
std::string compressed = "compressed cert";
@@ -45,7 +45,7 @@
TEST_F(QuicCompressedCertsCacheTest, CacheMiss) {
std::vector<std::string> certs = {"leaf cert", "intermediate cert",
"root cert"};
- QuicReferenceCountedPointer<ProofSource::Chain> chain(
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain(
new ProofSource::Chain(certs));
std::string cached_certs = "cached certs";
@@ -57,7 +57,7 @@
certs_cache_.GetCompressedCert(chain, "mismatched cached certs"));
// A different chain though with equivalent certs should get a cache miss.
- QuicReferenceCountedPointer<ProofSource::Chain> chain2(
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain2(
new ProofSource::Chain(certs));
EXPECT_EQ(nullptr, certs_cache_.GetCompressedCert(chain2, cached_certs));
}
@@ -67,7 +67,7 @@
// then evicted.
std::vector<std::string> certs = {"leaf cert", "intermediate cert",
"root cert"};
- QuicReferenceCountedPointer<ProofSource::Chain> chain(
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain(
new ProofSource::Chain(certs));
std::string cached_certs = "cached certs";
diff --git a/quic/core/crypto/quic_crypto_client_config.cc b/quic/core/crypto/quic_crypto_client_config.cc
index 4f2d69e..4ddfb1e 100644
--- a/quic/core/crypto/quic_crypto_client_config.cc
+++ b/quic/core/crypto/quic_crypto_client_config.cc
@@ -388,12 +388,10 @@
}
void QuicCryptoClientConfig::FillInchoateClientHello(
- const QuicServerId& server_id,
- const ParsedQuicVersion preferred_version,
- const CachedState* cached,
- QuicRandom* rand,
- bool demand_x509_proof,
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
+ const QuicServerId& server_id, const ParsedQuicVersion preferred_version,
+ const CachedState* cached, QuicRandom* rand, bool demand_x509_proof,
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ out_params,
CryptoHandshakeMessage* out) const {
out->set_tag(kCHLO);
out->set_minimum_size(1);
@@ -457,16 +455,13 @@
}
QuicErrorCode QuicCryptoClientConfig::FillClientHello(
- const QuicServerId& server_id,
- QuicConnectionId connection_id,
+ const QuicServerId& server_id, QuicConnectionId connection_id,
const ParsedQuicVersion preferred_version,
- const ParsedQuicVersion actual_version,
- const CachedState* cached,
- QuicWallTime now,
- QuicRandom* rand,
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
- CryptoHandshakeMessage* out,
- std::string* error_details) const {
+ const ParsedQuicVersion actual_version, const CachedState* cached,
+ QuicWallTime now, QuicRandom* rand,
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ out_params,
+ CryptoHandshakeMessage* out, std::string* error_details) const {
QUICHE_DCHECK(error_details != nullptr);
QUIC_BUG_IF(quic_bug_12943_2,
!QuicUtils::IsConnectionIdValidForVersion(
@@ -677,12 +672,11 @@
}
QuicErrorCode QuicCryptoClientConfig::ProcessRejection(
- const CryptoHandshakeMessage& rej,
- QuicWallTime now,
- const QuicTransportVersion version,
- absl::string_view chlo_hash,
+ const CryptoHandshakeMessage& rej, QuicWallTime now,
+ const QuicTransportVersion version, absl::string_view chlo_hash,
CachedState* cached,
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ out_params,
std::string* error_details) {
QUICHE_DCHECK(error_details != nullptr);
@@ -708,11 +702,10 @@
QuicErrorCode QuicCryptoClientConfig::ProcessServerHello(
const CryptoHandshakeMessage& server_hello,
- QuicConnectionId /*connection_id*/,
- ParsedQuicVersion version,
- const ParsedQuicVersionVector& negotiated_versions,
- CachedState* cached,
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
+ QuicConnectionId /*connection_id*/, ParsedQuicVersion version,
+ const ParsedQuicVersionVector& negotiated_versions, CachedState* cached,
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ out_params,
std::string* error_details) {
QUICHE_DCHECK(error_details != nullptr);
@@ -770,12 +763,11 @@
}
QuicErrorCode QuicCryptoClientConfig::ProcessServerConfigUpdate(
- const CryptoHandshakeMessage& server_config_update,
- QuicWallTime now,
- const QuicTransportVersion version,
- absl::string_view chlo_hash,
+ const CryptoHandshakeMessage& server_config_update, QuicWallTime now,
+ const QuicTransportVersion version, absl::string_view chlo_hash,
CachedState* cached,
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ out_params,
std::string* error_details) {
QUICHE_DCHECK(error_details != nullptr);
diff --git a/quic/core/crypto/quic_crypto_client_config.h b/quic/core/crypto/quic_crypto_client_config.h
index 9c71aca..16e1475 100644
--- a/quic/core/crypto/quic_crypto_client_config.h
+++ b/quic/core/crypto/quic_crypto_client_config.h
@@ -21,7 +21,7 @@
#include "quic/core/quic_packets.h"
#include "quic/core/quic_server_id.h"
#include "quic/platform/api/quic_export.h"
-#include "quic/platform/api/quic_reference_counted.h"
+#include "common/platform/api/quiche_reference_counted.h"
namespace quic {
@@ -265,12 +265,10 @@
// then |out| will include an X509 proof demand, and the associated
// certificate related fields.
void FillInchoateClientHello(
- const QuicServerId& server_id,
- const ParsedQuicVersion preferred_version,
- const CachedState* cached,
- QuicRandom* rand,
- bool demand_x509_proof,
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
+ const QuicServerId& server_id, const ParsedQuicVersion preferred_version,
+ const CachedState* cached, QuicRandom* rand, bool demand_x509_proof,
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ out_params,
CryptoHandshakeMessage* out) const;
// FillClientHello sets |out| to be a CHLO message based on the configuration
@@ -288,16 +286,13 @@
// from the client and server's keys, and the Channel ID public key and the
// signature are placed in the CETV value of the CHLO.
QuicErrorCode FillClientHello(
- const QuicServerId& server_id,
- QuicConnectionId connection_id,
+ const QuicServerId& server_id, QuicConnectionId connection_id,
const ParsedQuicVersion preferred_version,
- const ParsedQuicVersion actual_version,
- const CachedState* cached,
- QuicWallTime now,
- QuicRandom* rand,
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
- CryptoHandshakeMessage* out,
- std::string* error_details) const;
+ const ParsedQuicVersion actual_version, const CachedState* cached,
+ QuicWallTime now, QuicRandom* rand,
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ out_params,
+ CryptoHandshakeMessage* out, std::string* error_details) const;
// ProcessRejection processes a REJ message from a server and updates the
// cached information about that server. After this, |IsComplete| may return
@@ -306,12 +301,11 @@
// will be saved in |out_params|. |now| is used to judge whether the server
// config in the rejection message has expired.
QuicErrorCode ProcessRejection(
- const CryptoHandshakeMessage& rej,
- QuicWallTime now,
- QuicTransportVersion version,
- absl::string_view chlo_hash,
+ const CryptoHandshakeMessage& rej, QuicWallTime now,
+ QuicTransportVersion version, absl::string_view chlo_hash,
CachedState* cached,
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ out_params,
std::string* error_details);
// ProcessServerHello processes the message in |server_hello|, updates the
@@ -325,11 +319,10 @@
// versions provided in the VER tag of the server hello.
QuicErrorCode ProcessServerHello(
const CryptoHandshakeMessage& server_hello,
- QuicConnectionId connection_id,
- ParsedQuicVersion version,
- const ParsedQuicVersionVector& negotiated_versions,
- CachedState* cached,
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
+ QuicConnectionId connection_id, ParsedQuicVersion version,
+ const ParsedQuicVersionVector& negotiated_versions, CachedState* cached,
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ out_params,
std::string* error_details);
// Processes the message in |server_config_update|, updating the cached source
@@ -341,7 +334,8 @@
const CryptoHandshakeMessage& server_config_update, QuicWallTime now,
const QuicTransportVersion version, absl::string_view chlo_hash,
CachedState* cached,
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ out_params,
std::string* error_details);
ProofVerifier* proof_verifier() const;
diff --git a/quic/core/crypto/quic_crypto_client_config_test.cc b/quic/core/crypto/quic_crypto_client_config_test.cc
index 5bcf01c..a1f1562 100644
--- a/quic/core/crypto/quic_crypto_client_config_test.cc
+++ b/quic/core/crypto/quic_crypto_client_config_test.cc
@@ -98,7 +98,7 @@
QuicCryptoClientConfig config(crypto_test_utils::ProofVerifierForTesting());
config.set_user_agent_id("quic-tester");
config.set_alpn("hq");
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params(
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params(
new QuicCryptoNegotiatedParameters);
CryptoHandshakeMessage msg;
QuicServerId server_id("www.google.com", 443, false);
@@ -127,7 +127,7 @@
config.set_pad_inchoate_hello(false);
config.set_user_agent_id("quic-tester");
config.set_alpn("hq");
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params(
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params(
new QuicCryptoNegotiatedParameters);
CryptoHandshakeMessage msg;
QuicServerId server_id("www.google.com", 443, false);
@@ -152,7 +152,7 @@
TEST_F(QuicCryptoClientConfigTest, InchoateChloSecure) {
QuicCryptoClientConfig::CachedState state;
QuicCryptoClientConfig config(crypto_test_utils::ProofVerifierForTesting());
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params(
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params(
new QuicCryptoNegotiatedParameters);
CryptoHandshakeMessage msg;
QuicServerId server_id("www.google.com", 443, false);
@@ -182,7 +182,7 @@
EXPECT_FALSE(state.IsEmpty());
QuicCryptoClientConfig config(crypto_test_utils::ProofVerifierForTesting());
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params(
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params(
new QuicCryptoNegotiatedParameters);
CryptoHandshakeMessage msg;
QuicServerId server_id("www.google.com", 443, false);
@@ -209,7 +209,7 @@
EXPECT_FALSE(state.IsEmpty());
QuicCryptoClientConfig config(crypto_test_utils::ProofVerifierForTesting());
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params(
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params(
new QuicCryptoNegotiatedParameters);
CryptoHandshakeMessage msg;
QuicServerId server_id("www.google.com", 443, false);
@@ -225,7 +225,7 @@
TEST_F(QuicCryptoClientConfigTest, FillClientHello) {
QuicCryptoClientConfig::CachedState state;
QuicCryptoClientConfig config(crypto_test_utils::ProofVerifierForTesting());
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params(
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params(
new QuicCryptoNegotiatedParameters);
QuicConnectionId kConnectionId = TestConnectionId(1234);
std::string error_details;
@@ -246,7 +246,7 @@
QuicCryptoClientConfig::CachedState state;
QuicCryptoClientConfig config(crypto_test_utils::ProofVerifierForTesting());
config.set_pad_full_hello(false);
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params(
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params(
new QuicCryptoNegotiatedParameters);
QuicConnectionId kConnectionId = TestConnectionId(1234);
std::string error_details;
@@ -281,8 +281,8 @@
msg.SetVersionVector(kVER, supported_version_vector);
QuicCryptoClientConfig::CachedState cached;
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params(
- new QuicCryptoNegotiatedParameters);
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ out_params(new QuicCryptoNegotiatedParameters);
std::string error;
QuicCryptoClientConfig config(crypto_test_utils::ProofVerifierForTesting());
EXPECT_THAT(config.ProcessServerHello(
@@ -444,8 +444,8 @@
// Now process the rejection.
QuicCryptoClientConfig::CachedState cached;
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params(
- new QuicCryptoNegotiatedParameters);
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ out_params(new QuicCryptoNegotiatedParameters);
std::string error;
QuicCryptoClientConfig config(crypto_test_utils::ProofVerifierForTesting());
EXPECT_THAT(
@@ -465,8 +465,8 @@
// Now process the rejection.
QuicCryptoClientConfig::CachedState cached;
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params(
- new QuicCryptoNegotiatedParameters);
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ out_params(new QuicCryptoNegotiatedParameters);
std::string error;
QuicCryptoClientConfig config(crypto_test_utils::ProofVerifierForTesting());
EXPECT_THAT(
@@ -495,8 +495,8 @@
QuicCryptoClientConfig config(crypto_test_utils::ProofVerifierForTesting());
QuicCryptoClientConfig::CachedState cached;
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params(
- new QuicCryptoNegotiatedParameters);
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ out_params(new QuicCryptoNegotiatedParameters);
std::string error_details;
EXPECT_THAT(config.ProcessServerHello(msg, EmptyQuicConnectionId(), version,
supported_versions, &cached, out_params,
diff --git a/quic/core/crypto/quic_crypto_server_config.cc b/quic/core/crypto/quic_crypto_server_config.cc
index ec4c038..b4335b9 100644
--- a/quic/core/crypto/quic_crypto_server_config.cc
+++ b/quic/core/crypto/quic_crypto_server_config.cc
@@ -48,9 +48,9 @@
#include "quic/platform/api/quic_flags.h"
#include "quic/platform/api/quic_hostname_utils.h"
#include "quic/platform/api/quic_logging.h"
-#include "quic/platform/api/quic_reference_counted.h"
#include "quic/platform/api/quic_socket_address.h"
#include "quic/platform/api/quic_testvalue.h"
+#include "common/platform/api/quiche_reference_counted.h"
namespace quic {
@@ -164,7 +164,8 @@
// Note: stores a pointer to a unique_ptr, and std::moves the unique_ptr when
// ValidationComplete is called.
ValidateClientHelloHelper(
- QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
+ quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
result,
std::unique_ptr<ValidateClientHelloResultCallback>* done_cb)
: result_(std::move(result)), done_cb_(done_cb) {}
@@ -194,7 +195,8 @@
}
private:
- QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
+ quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
result_;
std::unique_ptr<ValidateClientHelloResultCallback>* done_cb_;
};
@@ -436,7 +438,7 @@
return nullptr;
}
- QuicReferenceCountedPointer<Config> config =
+ quiche::QuicheReferenceCountedPointer<Config> config =
ParseConfigProtobuf(protobuf, /* is_fallback = */ false);
if (!config) {
QUIC_LOG(WARNING) << "Failed to parse server config message";
@@ -473,9 +475,9 @@
const std::vector<QuicServerConfigProtobuf>& protobufs,
const QuicServerConfigProtobuf* fallback_protobuf,
const QuicWallTime now) {
- std::vector<QuicReferenceCountedPointer<Config>> parsed_configs;
+ std::vector<quiche::QuicheReferenceCountedPointer<Config>> parsed_configs;
for (auto& protobuf : protobufs) {
- QuicReferenceCountedPointer<Config> config =
+ quiche::QuicheReferenceCountedPointer<Config> config =
ParseConfigProtobuf(protobuf, /* is_fallback = */ false);
if (!config) {
QUIC_LOG(WARNING) << "Rejecting QUIC configs because of above errors";
@@ -485,7 +487,7 @@
parsed_configs.push_back(config);
}
- QuicReferenceCountedPointer<Config> fallback_config;
+ quiche::QuicheReferenceCountedPointer<Config> fallback_config;
if (fallback_protobuf != nullptr) {
fallback_config =
ParseConfigProtobuf(*fallback_protobuf, /* is_fallback = */ true);
@@ -511,7 +513,8 @@
QuicWriterMutexLock locked(&configs_lock_);
ConfigMap new_configs;
- for (const QuicReferenceCountedPointer<Config>& config : parsed_configs) {
+ for (const quiche::QuicheReferenceCountedPointer<Config>& config :
+ parsed_configs) {
auto it = configs_.find(config->id);
if (it != configs_.end()) {
QUIC_LOG(INFO) << "Keeping scid: " << absl::BytesToHexString(config->id)
@@ -569,15 +572,15 @@
void QuicCryptoServerConfig::ValidateClientHello(
const CryptoHandshakeMessage& client_hello,
const QuicSocketAddress& client_address,
- const QuicSocketAddress& server_address,
- QuicTransportVersion version,
+ const QuicSocketAddress& server_address, QuicTransportVersion version,
const QuicClock* clock,
- QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config,
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig> signed_config,
std::unique_ptr<ValidateClientHelloResultCallback> done_cb) const {
const QuicWallTime now(clock->WallNow());
- QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result> result(
- new ValidateClientHelloResultCallback::Result(
+ quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
+ result(new ValidateClientHelloResultCallback::Result(
client_hello, client_address.host(), now));
absl::string_view requested_scid;
@@ -614,10 +617,11 @@
const Configs& configs)
: config_(config), context_(std::move(context)), configs_(configs) {}
- void Run(bool ok,
- const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
- const QuicCryptoProof& proof,
- std::unique_ptr<ProofSource::Details> details) override {
+ void Run(
+ bool ok,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
+ const QuicCryptoProof& proof,
+ std::unique_ptr<ProofSource::Details> details) override {
if (ok) {
context_->signed_config()->chain = chain;
context_->signed_config()->proof = proof;
@@ -674,17 +678,18 @@
SendRejectWithFallbackConfigCallback(
const QuicCryptoServerConfig* config,
std::unique_ptr<ProcessClientHelloContext> context,
- QuicReferenceCountedPointer<Config> fallback_config)
+ quiche::QuicheReferenceCountedPointer<Config> fallback_config)
: config_(config),
context_(std::move(context)),
fallback_config_(fallback_config) {}
// Capture |chain| and |proof| into the signed config, and then invoke
// SendRejectWithFallbackConfigAfterGetProof.
- void Run(bool ok,
- const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
- const QuicCryptoProof& proof,
- std::unique_ptr<ProofSource::Details> details) override {
+ void Run(
+ bool ok,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
+ const QuicCryptoProof& proof,
+ std::unique_ptr<ProofSource::Details> details) override {
if (ok) {
context_->signed_config()->chain = chain;
context_->signed_config()->proof = proof;
@@ -696,25 +701,22 @@
private:
const QuicCryptoServerConfig* config_;
std::unique_ptr<ProcessClientHelloContext> context_;
- QuicReferenceCountedPointer<Config> fallback_config_;
+ quiche::QuicheReferenceCountedPointer<Config> fallback_config_;
};
void QuicCryptoServerConfig::ProcessClientHello(
- QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
+ quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
validate_chlo_result,
- bool reject_only,
- QuicConnectionId connection_id,
+ bool reject_only, QuicConnectionId connection_id,
const QuicSocketAddress& server_address,
- const QuicSocketAddress& client_address,
- ParsedQuicVersion version,
- const ParsedQuicVersionVector& supported_versions,
- const QuicClock* clock,
- QuicRandom* rand,
- QuicCompressedCertsCache* compressed_certs_cache,
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params,
- QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config,
- QuicByteCount total_framing_overhead,
- QuicByteCount chlo_packet_size,
+ const QuicSocketAddress& client_address, ParsedQuicVersion version,
+ const ParsedQuicVersionVector& supported_versions, const QuicClock* clock,
+ QuicRandom* rand, QuicCompressedCertsCache* compressed_certs_cache,
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ params,
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig> signed_config,
+ QuicByteCount total_framing_overhead, QuicByteCount chlo_packet_size,
std::unique_ptr<ProcessClientHelloResultCallback> done_cb) const {
QUICHE_DCHECK(done_cb);
auto context = std::make_unique<ProcessClientHelloContext>(
@@ -1072,7 +1074,7 @@
void QuicCryptoServerConfig::SendRejectWithFallbackConfig(
std::unique_ptr<ProcessClientHelloContext> context,
- QuicReferenceCountedPointer<Config> fallback_config) const {
+ quiche::QuicheReferenceCountedPointer<Config> fallback_config) const {
// We failed to calculate a shared initial key, likely because we tried to use
// a remote key-exchange service which could not be reached. We want to send
// a REJ which tells the client to use a different ServerConfig which
@@ -1096,7 +1098,7 @@
bool found_error,
std::unique_ptr<ProofSource::Details> proof_source_details,
std::unique_ptr<ProcessClientHelloContext> context,
- QuicReferenceCountedPointer<Config> fallback_config) const {
+ quiche::QuicheReferenceCountedPointer<Config> fallback_config) const {
if (found_error) {
context->Fail(QUIC_HANDSHAKE_FAILED, "Failed to get proof");
return;
@@ -1111,7 +1113,7 @@
std::move(proof_source_details));
}
-QuicReferenceCountedPointer<QuicCryptoServerConfig::Config>
+quiche::QuicheReferenceCountedPointer<QuicCryptoServerConfig::Config>
QuicCryptoServerConfig::GetConfigWithScid(
absl::string_view requested_scid) const {
configs_lock_.AssertReaderHeld();
@@ -1121,17 +1123,16 @@
if (it != configs_.end()) {
// We'll use the config that the client requested in order to do
// key-agreement.
- return QuicReferenceCountedPointer<Config>(it->second);
+ return quiche::QuicheReferenceCountedPointer<Config>(it->second);
}
}
- return QuicReferenceCountedPointer<Config>();
+ return quiche::QuicheReferenceCountedPointer<Config>();
}
bool QuicCryptoServerConfig::GetCurrentConfigs(
- const QuicWallTime& now,
- absl::string_view requested_scid,
- QuicReferenceCountedPointer<Config> old_primary_config,
+ const QuicWallTime& now, absl::string_view requested_scid,
+ quiche::QuicheReferenceCountedPointer<Config> old_primary_config,
Configs* configs) const {
QuicReaderMutexLock locked(&configs_lock_);
@@ -1165,8 +1166,8 @@
// Config's based on their primary_time.
// static
bool QuicCryptoServerConfig::ConfigPrimaryTimeLessThan(
- const QuicReferenceCountedPointer<Config>& a,
- const QuicReferenceCountedPointer<Config>& b) {
+ const quiche::QuicheReferenceCountedPointer<Config>& a,
+ const quiche::QuicheReferenceCountedPointer<Config>& b) {
if (a->primary_time.IsBefore(b->primary_time) ||
b->primary_time.IsBefore(a->primary_time)) {
// Primary times differ.
@@ -1182,7 +1183,7 @@
void QuicCryptoServerConfig::SelectNewPrimaryConfig(
const QuicWallTime now) const {
- std::vector<QuicReferenceCountedPointer<Config>> configs;
+ std::vector<quiche::QuicheReferenceCountedPointer<Config>> configs;
configs.reserve(configs_.size());
for (auto it = configs_.begin(); it != configs_.end(); ++it) {
@@ -1202,10 +1203,10 @@
std::sort(configs.begin(), configs.end(), ConfigPrimaryTimeLessThan);
- QuicReferenceCountedPointer<Config> best_candidate = configs[0];
+ quiche::QuicheReferenceCountedPointer<Config> best_candidate = configs[0];
for (size_t i = 0; i < configs.size(); ++i) {
- const QuicReferenceCountedPointer<Config> config(configs[i]);
+ const quiche::QuicheReferenceCountedPointer<Config> config(configs[i]);
if (!config->primary_time.IsAfter(now)) {
if (config->primary_time.IsAfter(best_candidate->primary_time)) {
best_candidate = config;
@@ -1216,7 +1217,7 @@
// This is the first config with a primary_time in the future. Thus the
// previous Config should be the primary and this one should determine the
// next_config_promotion_time_.
- QuicReferenceCountedPointer<Config> new_primary = best_candidate;
+ quiche::QuicheReferenceCountedPointer<Config> new_primary = best_candidate;
if (i == 0) {
// We need the primary_time of the next config.
if (configs.size() > 1) {
@@ -1247,7 +1248,7 @@
// All config's primary times are in the past. We should make the most recent
// and highest priority candidate primary.
- QuicReferenceCountedPointer<Config> new_primary = best_candidate;
+ quiche::QuicheReferenceCountedPointer<Config> new_primary = best_candidate;
if (primary_config_) {
primary_config_->is_primary = false;
}
@@ -1267,9 +1268,9 @@
void QuicCryptoServerConfig::EvaluateClientHello(
const QuicSocketAddress& /*server_address*/,
const QuicSocketAddress& /*client_address*/,
- QuicTransportVersion /*version*/,
- const Configs& configs,
- QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
+ QuicTransportVersion /*version*/, const Configs& configs,
+ quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
client_hello_state,
std::unique_ptr<ValidateClientHelloResultCallback> done_cb) const {
ValidateClientHelloHelper helper(client_hello_state, &done_cb);
@@ -1414,7 +1415,7 @@
void QuicCryptoServerConfig::BuildServerConfigUpdateMessageProofSourceCallback::
Run(bool ok,
- const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
const QuicCryptoProof& proof,
std::unique_ptr<ProofSource::Details> details) {
config_->FinishBuildServerConfigUpdateMessage(
@@ -1426,13 +1427,10 @@
void QuicCryptoServerConfig::FinishBuildServerConfigUpdateMessage(
QuicCompressedCertsCache* compressed_certs_cache,
- const std::string& client_cached_cert_hashes,
- bool sct_supported_by_client,
- const std::string& sni,
- bool ok,
- const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
- const std::string& signature,
- const std::string& leaf_cert_sct,
+ const std::string& client_cached_cert_hashes, bool sct_supported_by_client,
+ const std::string& sni, bool ok,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
+ const std::string& signature, const std::string& leaf_cert_sct,
std::unique_ptr<ProofSource::Details> /*details*/,
CryptoHandshakeMessage message,
std::unique_ptr<BuildServerConfigUpdateMessageResultCallback> cb) const {
@@ -1580,7 +1578,7 @@
std::string QuicCryptoServerConfig::CompressChain(
QuicCompressedCertsCache* compressed_certs_cache,
- const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
const std::string& client_cached_cert_hashes) {
// Check whether the compressed certs is available in the cache.
QUICHE_DCHECK(compressed_certs_cache);
@@ -1596,10 +1594,9 @@
return compressed;
}
-QuicReferenceCountedPointer<QuicCryptoServerConfig::Config>
+quiche::QuicheReferenceCountedPointer<QuicCryptoServerConfig::Config>
QuicCryptoServerConfig::ParseConfigProtobuf(
- const QuicServerConfigProtobuf& protobuf,
- bool is_fallback) const {
+ const QuicServerConfigProtobuf& protobuf, bool is_fallback) const {
std::unique_ptr<CryptoHandshakeMessage> msg =
CryptoFramer::ParseMessage(protobuf.config());
@@ -1614,7 +1611,7 @@
return nullptr;
}
- QuicReferenceCountedPointer<Config> config(new Config);
+ quiche::QuicheReferenceCountedPointer<Config> config(new Config);
config->serialized = protobuf.config();
config->source_address_token_boxer = &source_address_token_boxer_;
diff --git a/quic/core/crypto/quic_crypto_server_config.h b/quic/core/crypto/quic_crypto_server_config.h
index 8ee793a..3e7acb2 100644
--- a/quic/core/crypto/quic_crypto_server_config.h
+++ b/quic/core/crypto/quic_crypto_server_config.h
@@ -27,8 +27,8 @@
#include "quic/core/quic_time.h"
#include "quic/platform/api/quic_export.h"
#include "quic/platform/api/quic_mutex.h"
-#include "quic/platform/api/quic_reference_counted.h"
#include "quic/platform/api/quic_socket_address.h"
+#include "common/platform/api/quiche_reference_counted.h"
namespace quic {
@@ -83,7 +83,7 @@
public:
// Opaque token that holds information about the client_hello and
// its validity. Can be interpreted by calling ProcessClientHello.
- struct QUIC_EXPORT_PRIVATE Result : public QuicReferenceCounted {
+ struct QUIC_EXPORT_PRIVATE Result : public quiche::QuicheReferenceCounted {
Result(const CryptoHandshakeMessage& in_client_hello,
QuicIpAddress in_client_ip,
QuicWallTime in_now);
@@ -106,7 +106,7 @@
ValidateClientHelloResultCallback& operator=(
const ValidateClientHelloResultCallback&) = delete;
virtual ~ValidateClientHelloResultCallback();
- virtual void Run(QuicReferenceCountedPointer<Result> result,
+ virtual void Run(quiche::QuicheReferenceCountedPointer<Result> result,
std::unique_ptr<ProofSource::Details> details) = 0;
};
@@ -295,7 +295,8 @@
const QuicSocketAddress& client_address,
const QuicSocketAddress& server_address, QuicTransportVersion version,
const QuicClock* clock,
- QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config,
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig>
+ signed_config,
std::unique_ptr<ValidateClientHelloResultCallback> done_cb) const;
// ProcessClientHello processes |client_hello| and decides whether to accept
@@ -328,15 +329,18 @@
// chlo_packet_size: the size, in bytes, of the CHLO packet
// done_cb: the callback invoked on completion
void ProcessClientHello(
- QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
+ quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
validate_chlo_result,
bool reject_only, QuicConnectionId connection_id,
const QuicSocketAddress& server_address,
const QuicSocketAddress& client_address, ParsedQuicVersion version,
const ParsedQuicVersionVector& supported_versions, const QuicClock* clock,
QuicRandom* rand, QuicCompressedCertsCache* compressed_certs_cache,
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params,
- QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config,
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ params,
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig>
+ signed_config,
QuicByteCount total_framing_overhead, QuicByteCount chlo_packet_size,
std::unique_ptr<ProcessClientHelloResultCallback> done_cb) const;
@@ -472,7 +476,7 @@
// Config represents a server config: a collection of preferences and
// Diffie-Hellman public values.
class QUIC_EXPORT_PRIVATE Config : public QuicCryptoConfig,
- public QuicReferenceCounted {
+ public quiche::QuicheReferenceCounted {
public:
Config();
Config(const Config&) = delete;
@@ -530,18 +534,18 @@
};
using ConfigMap =
- std::map<ServerConfigID, QuicReferenceCountedPointer<Config>>;
+ std::map<ServerConfigID, quiche::QuicheReferenceCountedPointer<Config>>;
// Get a ref to the config with a given server config id.
- QuicReferenceCountedPointer<Config> GetConfigWithScid(
+ quiche::QuicheReferenceCountedPointer<Config> GetConfigWithScid(
absl::string_view requested_scid) const
QUIC_SHARED_LOCKS_REQUIRED(configs_lock_);
// A snapshot of the configs associated with an in-progress handshake.
struct QUIC_EXPORT_PRIVATE Configs {
- QuicReferenceCountedPointer<Config> requested;
- QuicReferenceCountedPointer<Config> primary;
- QuicReferenceCountedPointer<Config> fallback;
+ quiche::QuicheReferenceCountedPointer<Config> requested;
+ quiche::QuicheReferenceCountedPointer<Config> primary;
+ quiche::QuicheReferenceCountedPointer<Config> fallback;
};
// Get a snapshot of the current configs associated with a handshake. If this
@@ -550,16 +554,16 @@
//
// Returns true if any configs are loaded. If false is returned, |configs| is
// not modified.
- bool GetCurrentConfigs(const QuicWallTime& now,
- absl::string_view requested_scid,
- QuicReferenceCountedPointer<Config> old_primary_config,
- Configs* configs) const;
+ bool GetCurrentConfigs(
+ const QuicWallTime& now, absl::string_view requested_scid,
+ quiche::QuicheReferenceCountedPointer<Config> old_primary_config,
+ Configs* configs) const;
// ConfigPrimaryTimeLessThan returns true if a->primary_time <
// b->primary_time.
static bool ConfigPrimaryTimeLessThan(
- const QuicReferenceCountedPointer<Config>& a,
- const QuicReferenceCountedPointer<Config>& b);
+ const quiche::QuicheReferenceCountedPointer<Config>& a,
+ const quiche::QuicheReferenceCountedPointer<Config>& b);
// SelectNewPrimaryConfig reevaluates the primary config based on the
// "primary_time" deadlines contained in each.
@@ -571,10 +575,10 @@
// are written to |client_hello_state->info|.
void EvaluateClientHello(
const QuicSocketAddress& server_address,
- const QuicSocketAddress& client_address,
- QuicTransportVersion version,
+ const QuicSocketAddress& client_address, QuicTransportVersion version,
const Configs& configs,
- QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
+ quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
client_hello_state,
std::unique_ptr<ValidateClientHelloResultCallback> done_cb) const;
@@ -583,21 +587,20 @@
class QUIC_EXPORT_PRIVATE ProcessClientHelloContext {
public:
ProcessClientHelloContext(
- QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
+ quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
validate_chlo_result,
- bool reject_only,
- QuicConnectionId connection_id,
+ bool reject_only, QuicConnectionId connection_id,
const QuicSocketAddress& server_address,
- const QuicSocketAddress& client_address,
- ParsedQuicVersion version,
+ const QuicSocketAddress& client_address, ParsedQuicVersion version,
const ParsedQuicVersionVector& supported_versions,
- const QuicClock* clock,
- QuicRandom* rand,
+ const QuicClock* clock, QuicRandom* rand,
QuicCompressedCertsCache* compressed_certs_cache,
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params,
- QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config,
- QuicByteCount total_framing_overhead,
- QuicByteCount chlo_packet_size,
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ params,
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig>
+ signed_config,
+ QuicByteCount total_framing_overhead, QuicByteCount chlo_packet_size,
std::unique_ptr<ProcessClientHelloResultCallback> done_cb)
: validate_chlo_result_(validate_chlo_result),
reject_only_(reject_only),
@@ -626,7 +629,8 @@
std::unique_ptr<ProofSource::Details> proof_source_details);
// Member accessors
- QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
+ quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
validate_chlo_result() const {
return validate_chlo_result_;
}
@@ -643,10 +647,12 @@
QuicCompressedCertsCache* compressed_certs_cache() const {
return compressed_certs_cache_;
}
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params() const {
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ params() const {
return params_;
}
- QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config() const {
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig>
+ signed_config() const {
return signed_config_;
}
QuicByteCount total_framing_overhead() const {
@@ -664,7 +670,8 @@
}
private:
- const QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
+ const quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
validate_chlo_result_;
const bool reject_only_;
const QuicConnectionId connection_id_;
@@ -675,8 +682,10 @@
const QuicClock* const clock_;
QuicRandom* const rand_;
QuicCompressedCertsCache* const compressed_certs_cache_;
- const QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
- const QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config_;
+ const quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ params_;
+ const quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig>
+ signed_config_;
const QuicByteCount total_framing_overhead_;
const QuicByteCount chlo_packet_size_;
std::unique_ptr<ProcessClientHelloResultCallback> done_cb_;
@@ -715,7 +724,7 @@
// client used is not accessible.
void SendRejectWithFallbackConfig(
std::unique_ptr<ProcessClientHelloContext> context,
- QuicReferenceCountedPointer<Config> fallback_config) const;
+ quiche::QuicheReferenceCountedPointer<Config> fallback_config) const;
// Callback class for bridging between SendRejectWithFallbackConfig and
// SendRejectWithFallbackConfigAfterGetProof.
@@ -729,7 +738,7 @@
bool found_error,
std::unique_ptr<ProofSource::Details> proof_source_details,
std::unique_ptr<ProcessClientHelloContext> context,
- QuicReferenceCountedPointer<Config> fallback_config) const;
+ quiche::QuicheReferenceCountedPointer<Config> fallback_config) const;
// BuildRejectionAndRecordStats calls |BuildRejection| below and also informs
// the RejectionObserver.
@@ -749,15 +758,15 @@
// 64-bit, FNV-1a hashes of certificates that the peer already possesses.
static std::string CompressChain(
QuicCompressedCertsCache* compressed_certs_cache,
- const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
const std::string& client_cached_cert_hashes);
// ParseConfigProtobuf parses the given config protobuf and returns a
- // QuicReferenceCountedPointer<Config> if successful. The caller adopts the
- // reference to the Config. On error, ParseConfigProtobuf returns nullptr.
- QuicReferenceCountedPointer<Config> ParseConfigProtobuf(
- const QuicServerConfigProtobuf& protobuf,
- bool is_fallback) const;
+ // quiche::QuicheReferenceCountedPointer<Config> if successful. The caller
+ // adopts the reference to the Config. On error, ParseConfigProtobuf returns
+ // nullptr.
+ quiche::QuicheReferenceCountedPointer<Config> ParseConfigProtobuf(
+ const QuicServerConfigProtobuf& protobuf, bool is_fallback) const;
// ValidateSingleSourceAddressToken returns HANDSHAKE_OK if the source
// address token in |token| is a timely token for the IP address |ip|
@@ -806,10 +815,11 @@
CryptoHandshakeMessage message,
std::unique_ptr<BuildServerConfigUpdateMessageResultCallback> cb);
- void Run(bool ok,
- const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
- const QuicCryptoProof& proof,
- std::unique_ptr<ProofSource::Details> details) override;
+ void Run(
+ bool ok,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
+ const QuicCryptoProof& proof,
+ std::unique_ptr<ProofSource::Details> details) override;
private:
const QuicCryptoServerConfig* config_;
@@ -827,12 +837,9 @@
void FinishBuildServerConfigUpdateMessage(
QuicCompressedCertsCache* compressed_certs_cache,
const std::string& client_cached_cert_hashes,
- bool sct_supported_by_client,
- const std::string& sni,
- bool ok,
- const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
- const std::string& signature,
- const std::string& leaf_cert_sct,
+ bool sct_supported_by_client, const std::string& sni, bool ok,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
+ const std::string& signature, const std::string& leaf_cert_sct,
std::unique_ptr<ProofSource::Details> details,
CryptoHandshakeMessage message,
std::unique_ptr<BuildServerConfigUpdateMessageResultCallback> cb) const;
@@ -862,7 +869,7 @@
// primary_config_ points to a Config (which is also in |configs_|) which is
// the primary config - i.e. the one that we'll give out to new clients.
- mutable QuicReferenceCountedPointer<Config> primary_config_
+ mutable quiche::QuicheReferenceCountedPointer<Config> primary_config_
QUIC_GUARDED_BY(configs_lock_);
// fallback_config_ points to a Config (which is also in |configs_|) which is
@@ -870,7 +877,7 @@
// for some reason.
//
// TODO(b/112548056): This is currently always nullptr.
- QuicReferenceCountedPointer<Config> fallback_config_
+ quiche::QuicheReferenceCountedPointer<Config> fallback_config_
QUIC_GUARDED_BY(configs_lock_);
// next_config_promotion_time_ contains the nearest, future time when an
@@ -939,14 +946,14 @@
};
struct QUIC_EXPORT_PRIVATE QuicSignedServerConfig
- : public QuicReferenceCounted {
+ : public quiche::QuicheReferenceCounted {
QuicSignedServerConfig();
QuicCryptoProof proof;
- QuicReferenceCountedPointer<ProofSource::Chain> chain;
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain;
// The server config that is used for this proof (and the rest of the
// request).
- QuicReferenceCountedPointer<QuicCryptoServerConfig::Config> config;
+ quiche::QuicheReferenceCountedPointer<QuicCryptoServerConfig::Config> config;
std::string primary_scid;
protected:
diff --git a/quic/core/crypto/quic_crypto_server_config_test.cc b/quic/core/crypto/quic_crypto_server_config_test.cc
index 8e97705..720da63 100644
--- a/quic/core/crypto/quic_crypto_server_config_test.cc
+++ b/quic/core/crypto/quic_crypto_server_config_test.cc
@@ -71,7 +71,7 @@
QuicCryptoServerConfigPeer peer(&server);
std::vector<std::string> certs = {"testcert"};
- QuicReferenceCountedPointer<ProofSource::Chain> chain(
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain(
new ProofSource::Chain(certs));
std::string compressed = QuicCryptoServerConfigPeer::CompressChain(
@@ -92,7 +92,7 @@
// Compress the certs for the first time.
std::vector<std::string> certs = {"testcert"};
- QuicReferenceCountedPointer<ProofSource::Chain> chain(
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain(
new ProofSource::Chain(certs));
std::string cached_certs = "";
@@ -120,7 +120,7 @@
QuicCryptoServerConfigPeer peer(&server);
std::vector<std::string> certs = {"testcert"};
- QuicReferenceCountedPointer<ProofSource::Chain> chain(
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain(
new ProofSource::Chain(certs));
std::string cached_certs = "";
@@ -129,7 +129,7 @@
EXPECT_EQ(compressed_certs_cache.Size(), 1u);
// Compress a similar certs which only differs in the chain.
- QuicReferenceCountedPointer<ProofSource::Chain> chain2(
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain2(
new ProofSource::Chain(certs));
std::string compressed2 = QuicCryptoServerConfigPeer::CompressChain(
@@ -456,7 +456,7 @@
class ValidateCallback : public ValidateClientHelloResultCallback {
public:
- void Run(QuicReferenceCountedPointer<Result> /*result*/,
+ void Run(quiche::QuicheReferenceCountedPointer<Result> /*result*/,
std::unique_ptr<ProofSource::Details> /*details*/) override {}
};
@@ -477,7 +477,7 @@
}
ASSERT_NE(transport_version, QUIC_VERSION_UNSUPPORTED);
MockClock clock;
- QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config(
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig> signed_config(
new QuicSignedServerConfig);
std::unique_ptr<ValidateClientHelloResultCallback> done_cb(
new ValidateCallback);
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index c778faa..182ef18 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -3946,7 +3946,7 @@
const int expected_bytes_acked = header_size + request_string.length();
// The TestAckListener will cause a failure if not notified.
- QuicReferenceCountedPointer<TestAckListener> ack_listener(
+ quiche::QuicheReferenceCountedPointer<TestAckListener> ack_listener(
new TestAckListener());
// Send the request, and register the delegate for ACKs.
diff --git a/quic/core/http/quic_headers_stream.cc b/quic/core/http/quic_headers_stream.cc
index 2b9f485..1a8d0dd 100644
--- a/quic/core/http/quic_headers_stream.cc
+++ b/quic/core/http/quic_headers_stream.cc
@@ -13,9 +13,9 @@
namespace quic {
QuicHeadersStream::CompressedHeaderInfo::CompressedHeaderInfo(
- QuicStreamOffset headers_stream_offset,
- QuicStreamOffset full_length,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener)
+ QuicStreamOffset headers_stream_offset, QuicStreamOffset full_length,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener)
: headers_stream_offset(headers_stream_offset),
full_length(full_length),
unacked_length(full_length),
@@ -138,9 +138,9 @@
}
void QuicHeadersStream::OnDataBuffered(
- QuicStreamOffset offset,
- QuicByteCount data_length,
- const QuicReferenceCountedPointer<QuicAckListenerInterface>& ack_listener) {
+ QuicStreamOffset offset, QuicByteCount data_length,
+ const quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>&
+ ack_listener) {
// Populate unacked_headers_.
if (!unacked_headers_.empty() &&
(offset == unacked_headers_.back().headers_stream_offset +
diff --git a/quic/core/http/quic_headers_stream.h b/quic/core/http/quic_headers_stream.h
index 153575b..3e541ec 100644
--- a/quic/core/http/quic_headers_stream.h
+++ b/quic/core/http/quic_headers_stream.h
@@ -59,9 +59,9 @@
// offset in headers stream, unacked length and ack listener of this header.
struct QUIC_EXPORT_PRIVATE CompressedHeaderInfo {
CompressedHeaderInfo(
- QuicStreamOffset headers_stream_offset,
- QuicStreamOffset full_length,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
+ QuicStreamOffset headers_stream_offset, QuicStreamOffset full_length,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener);
CompressedHeaderInfo(const CompressedHeaderInfo& other);
~CompressedHeaderInfo();
@@ -73,7 +73,8 @@
QuicByteCount unacked_length;
// Ack listener of this header, and it is notified once any of the bytes has
// been acked or retransmitted.
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener;
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener;
};
// Returns true if the session is still connected.
@@ -83,10 +84,9 @@
// ack_listener is notified once data within [offset, offset + length] is
// acked or retransmitted.
void OnDataBuffered(
- QuicStreamOffset offset,
- QuicByteCount data_length,
- const QuicReferenceCountedPointer<QuicAckListenerInterface>& ack_listener)
- override;
+ QuicStreamOffset offset, QuicByteCount data_length,
+ const quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>&
+ ack_listener) override;
QuicSpdySession* spdy_session_;
diff --git a/quic/core/http/quic_headers_stream_test.cc b/quic/core/http/quic_headers_stream_test.cc
index 3a44f79..d4d8e2f 100644
--- a/quic/core/http/quic_headers_stream_test.cc
+++ b/quic/core/http/quic_headers_stream_test.cc
@@ -760,11 +760,11 @@
_, _, NO_FIN, _, _))
.WillRepeatedly(Invoke(&session_, &MockQuicSpdySession::ConsumeData));
InSequence s;
- QuicReferenceCountedPointer<MockAckListener> ack_listener1(
+ quiche::QuicheReferenceCountedPointer<MockAckListener> ack_listener1(
new MockAckListener());
- QuicReferenceCountedPointer<MockAckListener> ack_listener2(
+ quiche::QuicheReferenceCountedPointer<MockAckListener> ack_listener2(
new MockAckListener());
- QuicReferenceCountedPointer<MockAckListener> ack_listener3(
+ quiche::QuicheReferenceCountedPointer<MockAckListener> ack_listener3(
new MockAckListener());
// Packet 1.
@@ -829,11 +829,11 @@
_, _, NO_FIN, _, _))
.WillRepeatedly(Invoke(&session_, &MockQuicSpdySession::ConsumeData));
InSequence s;
- QuicReferenceCountedPointer<MockAckListener> ack_listener1(
+ quiche::QuicheReferenceCountedPointer<MockAckListener> ack_listener1(
new MockAckListener());
- QuicReferenceCountedPointer<MockAckListener> ack_listener2(
+ quiche::QuicheReferenceCountedPointer<MockAckListener> ack_listener2(
new MockAckListener());
- QuicReferenceCountedPointer<MockAckListener> ack_listener3(
+ quiche::QuicheReferenceCountedPointer<MockAckListener> ack_listener3(
new MockAckListener());
headers_stream_->WriteOrBufferData("Header5", false, ack_listener1);
@@ -879,11 +879,11 @@
_, _, NO_FIN, _, _))
.WillRepeatedly(Invoke(&session_, &MockQuicSpdySession::ConsumeData));
InSequence s;
- QuicReferenceCountedPointer<MockAckListener> ack_listener1(
+ quiche::QuicheReferenceCountedPointer<MockAckListener> ack_listener1(
new MockAckListener());
- QuicReferenceCountedPointer<MockAckListener> ack_listener2(
+ quiche::QuicheReferenceCountedPointer<MockAckListener> ack_listener2(
new MockAckListener());
- QuicReferenceCountedPointer<MockAckListener> ack_listener3(
+ quiche::QuicheReferenceCountedPointer<MockAckListener> ack_listener3(
new MockAckListener());
// Send [0, 42).
diff --git a/quic/core/http/quic_server_initiated_spdy_stream.cc b/quic/core/http/quic_server_initiated_spdy_stream.cc
index 37a5389..2a227a7 100644
--- a/quic/core/http/quic_server_initiated_spdy_stream.cc
+++ b/quic/core/http/quic_server_initiated_spdy_stream.cc
@@ -16,9 +16,9 @@
}
size_t QuicServerInitiatedSpdyStream::WriteHeaders(
- spdy::SpdyHeaderBlock /*header_block*/,
- bool /*fin*/,
- QuicReferenceCountedPointer<QuicAckListenerInterface> /*ack_listener*/) {
+ spdy::SpdyHeaderBlock /*header_block*/, bool /*fin*/,
+ quiche::QuicheReferenceCountedPointer<
+ QuicAckListenerInterface> /*ack_listener*/) {
QUIC_BUG(Writing headers in QuicServerInitiatedSpdyStream)
<< "Attempting to write headers in QuicServerInitiatedSpdyStream";
OnUnrecoverableError(QUIC_INTERNAL_ERROR,
diff --git a/quic/core/http/quic_server_initiated_spdy_stream.h b/quic/core/http/quic_server_initiated_spdy_stream.h
index a13dc65..889f216 100644
--- a/quic/core/http/quic_server_initiated_spdy_stream.h
+++ b/quic/core/http/quic_server_initiated_spdy_stream.h
@@ -18,10 +18,10 @@
using QuicSpdyStream::QuicSpdyStream;
void OnBodyAvailable() override;
- size_t WriteHeaders(spdy::SpdyHeaderBlock header_block,
- bool fin,
- QuicReferenceCountedPointer<QuicAckListenerInterface>
- ack_listener) override;
+ size_t WriteHeaders(
+ spdy::SpdyHeaderBlock header_block, bool fin,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener) override;
void OnInitialHeadersComplete(bool fin,
size_t frame_len,
const QuicHeaderList& header_list) override;
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index 095efdd..4407198 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -676,7 +676,8 @@
size_t QuicSpdySession::WriteHeadersOnHeadersStream(
QuicStreamId id, SpdyHeaderBlock headers, bool fin,
const spdy::SpdyStreamPrecedence& precedence,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener) {
QUICHE_DCHECK(!VersionUsesHttp3(transport_version()));
return WriteHeadersOnHeadersStreamImpl(
@@ -905,7 +906,8 @@
size_t QuicSpdySession::WriteHeadersOnHeadersStreamImpl(
QuicStreamId id, spdy::SpdyHeaderBlock headers, bool fin,
QuicStreamId parent_stream_id, int weight, bool exclusive,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener) {
QUICHE_DCHECK(!VersionUsesHttp3(transport_version()));
const QuicByteCount uncompressed_size = headers.TotalBytesUsed();
diff --git a/quic/core/http/quic_spdy_session.h b/quic/core/http/quic_spdy_session.h
index 569ab77..50264a1 100644
--- a/quic/core/http/quic_spdy_session.h
+++ b/quic/core/http/quic_spdy_session.h
@@ -204,7 +204,8 @@
virtual size_t WriteHeadersOnHeadersStream(
QuicStreamId id, spdy::SpdyHeaderBlock headers, bool fin,
const spdy::SpdyStreamPrecedence& precedence,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener);
// Writes an HTTP/2 PRIORITY frame the to peer. Returns the size in bytes of
// the resulting PRIORITY frame.
@@ -506,7 +507,8 @@
size_t WriteHeadersOnHeadersStreamImpl(
QuicStreamId id, spdy::SpdyHeaderBlock headers, bool fin,
QuicStreamId parent_stream_id, int weight, bool exclusive,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener);
void OnNewEncryptionKeyAvailable(
EncryptionLevel level, std::unique_ptr<QuicEncrypter> encrypter) override;
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index a629827..fee5ea4 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -208,7 +208,7 @@
bool encryption_established_;
bool one_rtt_keys_available_;
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
};
class TestHeadersStream : public QuicHeadersStream {
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index adeb224..e7080a3 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -262,7 +262,8 @@
size_t QuicSpdyStream::WriteHeaders(
SpdyHeaderBlock header_block, bool fin,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener) {
if (!AssertNotWebTransportDataStream("writing headers")) {
return 0;
}
@@ -349,7 +350,8 @@
size_t QuicSpdyStream::WriteTrailers(
SpdyHeaderBlock trailer_block,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener) {
if (fin_sent()) {
QUIC_BUG(quic_bug_10410_1)
<< "Trailers cannot be sent after a FIN, on stream " << id();
@@ -1204,7 +1206,8 @@
size_t QuicSpdyStream::WriteHeadersImpl(
spdy::SpdyHeaderBlock header_block, bool fin,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener) {
if (!VersionUsesHttp3(transport_version())) {
return spdy_session_->WriteHeadersOnHeadersStream(
id(), std::move(header_block), fin, precedence(),
diff --git a/quic/core/http/quic_spdy_stream.h b/quic/core/http/quic_spdy_stream.h
index 1df1485..5a77d6f 100644
--- a/quic/core/http/quic_spdy_stream.h
+++ b/quic/core/http/quic_spdy_stream.h
@@ -125,7 +125,8 @@
// QPACK.
virtual size_t WriteHeaders(
spdy::SpdyHeaderBlock header_block, bool fin,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener);
// Sends |data| to the peer, or buffers if it can't be sent immediately.
void WriteOrBufferBody(absl::string_view data, bool fin);
@@ -136,7 +137,8 @@
// data sent on the encoder stream when using QPACK.
virtual size_t WriteTrailers(
spdy::SpdyHeaderBlock trailer_block,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener);
// Override to report newly acked bytes via ack_listener_.
bool OnStreamFrameAcked(QuicStreamOffset offset, QuicByteCount data_length,
@@ -361,14 +363,16 @@
const QuicHeaderList& header_list);
virtual size_t WriteHeadersImpl(
spdy::SpdyHeaderBlock header_block, bool fin,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener);
Visitor* visitor() { return visitor_; }
void set_headers_decompressed(bool val) { headers_decompressed_ = val; }
void set_ack_listener(
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener) {
ack_listener_ = std::move(ack_listener);
}
@@ -504,7 +508,7 @@
// Ack listener of this stream, and it is notified when any of written bytes
// are acked or retransmitted.
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener_;
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface> ack_listener_;
// Offset of unacked frame headers.
QuicIntervalSet<QuicStreamOffset> unacked_frame_headers_offsets_;
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index bf4dc45..88f049f 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -192,7 +192,7 @@
bool encryption_established_;
bool one_rtt_keys_available_;
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
};
class TestStream : public QuicSpdyStream {
@@ -222,9 +222,10 @@
MOCK_METHOD(void, WriteHeadersMock, (bool fin), ());
- size_t WriteHeadersImpl(spdy::SpdyHeaderBlock header_block, bool fin,
- QuicReferenceCountedPointer<QuicAckListenerInterface>
- /*ack_listener*/) override {
+ size_t WriteHeadersImpl(
+ spdy::SpdyHeaderBlock header_block, bool fin,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ /*ack_listener*/) override {
saved_headers_ = std::move(header_block);
WriteHeadersMock(fin);
if (VersionUsesHttp3(transport_version())) {
@@ -1721,9 +1722,9 @@
Initialize(kShouldProcessData);
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).Times(AtLeast(1));
testing::InSequence s;
- QuicReferenceCountedPointer<MockAckListener> ack_listener1(
+ quiche::QuicheReferenceCountedPointer<MockAckListener> ack_listener1(
new MockAckListener());
- QuicReferenceCountedPointer<MockAckListener> ack_listener2(
+ quiche::QuicheReferenceCountedPointer<MockAckListener> ack_listener2(
new MockAckListener());
stream_->set_ack_listener(ack_listener1);
stream2_->set_ack_listener(ack_listener2);
@@ -1811,7 +1812,7 @@
TEST_P(QuicSpdyStreamTest, StreamWaitsForAcks) {
Initialize(kShouldProcessData);
- QuicReferenceCountedPointer<MockAckListener> mock_ack_listener(
+ quiche::QuicheReferenceCountedPointer<MockAckListener> mock_ack_listener(
new StrictMock<MockAckListener>);
stream_->set_ack_listener(mock_ack_listener);
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).Times(AtLeast(1));
@@ -1865,7 +1866,7 @@
TEST_P(QuicSpdyStreamTest, StreamDataGetAckedMultipleTimes) {
Initialize(kShouldProcessData);
- QuicReferenceCountedPointer<MockAckListener> mock_ack_listener(
+ quiche::QuicheReferenceCountedPointer<MockAckListener> mock_ack_listener(
new StrictMock<MockAckListener>);
stream_->set_ack_listener(mock_ack_listener);
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).Times(AtLeast(1));
@@ -1930,7 +1931,7 @@
}
Initialize(kShouldProcessData);
- QuicReferenceCountedPointer<MockAckListener> mock_ack_listener(
+ quiche::QuicheReferenceCountedPointer<MockAckListener> mock_ack_listener(
new StrictMock<MockAckListener>);
stream_->set_ack_listener(mock_ack_listener);
std::string body = "Test1";
@@ -1974,7 +1975,7 @@
}
Initialize(kShouldProcessData);
- QuicReferenceCountedPointer<MockAckListener> mock_ack_listener(
+ quiche::QuicheReferenceCountedPointer<MockAckListener> mock_ack_listener(
new StrictMock<MockAckListener>);
stream_->set_ack_listener(mock_ack_listener);
std::string body1 = "Test1";
@@ -2009,7 +2010,7 @@
}
Initialize(kShouldProcessData);
- QuicReferenceCountedPointer<MockAckListener> mock_ack_listener(
+ quiche::QuicheReferenceCountedPointer<MockAckListener> mock_ack_listener(
new StrictMock<MockAckListener>);
stream_->set_ack_listener(mock_ack_listener);
std::string body1 = "Test1";
diff --git a/quic/core/quic_ack_listener_interface.h b/quic/core/quic_ack_listener_interface.h
index abfb217..7592e0f 100644
--- a/quic/core/quic_ack_listener_interface.h
+++ b/quic/core/quic_ack_listener_interface.h
@@ -8,13 +8,13 @@
#include "quic/core/quic_time.h"
#include "quic/core/quic_types.h"
#include "quic/platform/api/quic_export.h"
-#include "quic/platform/api/quic_reference_counted.h"
+#include "common/platform/api/quiche_reference_counted.h"
namespace quic {
// Pure virtual class to listen for packet acknowledgements.
class QUIC_EXPORT_PRIVATE QuicAckListenerInterface
- : public QuicReferenceCounted {
+ : public quiche::QuicheReferenceCounted {
public:
QuicAckListenerInterface() {}
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 6c6e84b..db7ae69 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -38,7 +38,6 @@
#include "quic/platform/api/quic_flags.h"
#include "quic/platform/api/quic_ip_address.h"
#include "quic/platform/api/quic_logging.h"
-#include "quic/platform/api/quic_reference_counted.h"
#include "quic/platform/api/quic_socket_address.h"
#include "quic/platform/api/quic_test.h"
#include "quic/test_tools/mock_clock.h"
@@ -52,6 +51,7 @@
#include "quic/test_tools/quic_test_utils.h"
#include "quic/test_tools/simple_data_producer.h"
#include "quic/test_tools/simple_session_notifier.h"
+#include "common/platform/api/quiche_reference_counted.h"
#include "common/simple_buffer_allocator.h"
using testing::_;
diff --git a/quic/core/quic_crypto_client_handshaker.h b/quic/core/quic_crypto_client_handshaker.h
index c0c94b9..b458ee4 100644
--- a/quic/core/quic_crypto_client_handshaker.h
+++ b/quic/core/quic_crypto_client_handshaker.h
@@ -202,7 +202,7 @@
bool encryption_established_;
bool one_rtt_keys_available_;
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
crypto_negotiated_params_;
};
diff --git a/quic/core/quic_crypto_client_handshaker_test.cc b/quic/core/quic_crypto_client_handshaker_test.cc
index 120e5da..bb1e40f 100644
--- a/quic/core/quic_crypto_client_handshaker_test.cc
+++ b/quic/core/quic_crypto_client_handshaker_test.cc
@@ -78,8 +78,9 @@
absl::string_view /*chlo_hash*/,
std::unique_ptr<Callback> callback) override {
bool cert_matched_sni;
- QuicReferenceCountedPointer<ProofSource::Chain> chain = GetCertChain(
- server_address, client_address, hostname, &cert_matched_sni);
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain =
+ GetCertChain(server_address, client_address, hostname,
+ &cert_matched_sni);
QuicCryptoProof proof;
proof.signature = "Dummy signature";
proof.leaf_cert_scts = "Dummy timestamp";
@@ -87,13 +88,13 @@
callback->Run(true, chain, proof, /*details=*/nullptr);
}
- QuicReferenceCountedPointer<Chain> GetCertChain(
+ quiche::QuicheReferenceCountedPointer<Chain> GetCertChain(
const QuicSocketAddress& /*server_address*/,
const QuicSocketAddress& /*client_address*/,
const std::string& /*hostname*/, bool* /*cert_matched_sni*/) override {
std::vector<std::string> certs;
certs.push_back("Dummy cert");
- return QuicReferenceCountedPointer<ProofSource::Chain>(
+ return quiche::QuicheReferenceCountedPointer<ProofSource::Chain>(
new ProofSource::Chain(certs));
}
diff --git a/quic/core/quic_crypto_server_stream.cc b/quic/core/quic_crypto_server_stream.cc
index 6bac704..3612c77 100644
--- a/quic/core/quic_crypto_server_stream.cc
+++ b/quic/core/quic_crypto_server_stream.cc
@@ -21,7 +21,7 @@
public:
ProcessClientHelloCallback(
QuicCryptoServerStream* parent,
- const QuicReferenceCountedPointer<
+ const quiche::QuicheReferenceCountedPointer<
ValidateClientHelloResultCallback::Result>& result)
: parent_(parent), result_(result) {}
@@ -44,7 +44,8 @@
private:
QuicCryptoServerStream* parent_;
- QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
+ quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
result_;
};
@@ -137,7 +138,8 @@
}
void QuicCryptoServerStream::FinishProcessingHandshakeMessage(
- QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
+ quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
result,
std::unique_ptr<ProofSource::Details> details) {
// Clear the callback that got us here.
@@ -456,7 +458,8 @@
}
void QuicCryptoServerStream::ProcessClientHello(
- QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
+ quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
result,
std::unique_ptr<ProofSource::Details> proof_source_details,
std::unique_ptr<ProcessClientHelloResultCallback> done_cb) {
@@ -518,7 +521,7 @@
}
void QuicCryptoServerStream::ValidateCallback::Run(
- QuicReferenceCountedPointer<Result> result,
+ quiche::QuicheReferenceCountedPointer<Result> result,
std::unique_ptr<ProofSource::Details> details) {
if (parent_ != nullptr) {
parent_->FinishProcessingHandshakeMessage(std::move(result),
diff --git a/quic/core/quic_crypto_server_stream.h b/quic/core/quic_crypto_server_stream.h
index acb8ae2..d26b751 100644
--- a/quic/core/quic_crypto_server_stream.h
+++ b/quic/core/quic_crypto_server_stream.h
@@ -92,7 +92,8 @@
QuicCryptoServerStreamBase::Helper* helper);
virtual void ProcessClientHello(
- QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
+ quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
result,
std::unique_ptr<ProofSource::Details> proof_source_details,
std::unique_ptr<ProcessClientHelloResultCallback> done_cb);
@@ -128,7 +129,7 @@
void Cancel();
// From ValidateClientHelloResultCallback
- void Run(QuicReferenceCountedPointer<Result> result,
+ void Run(quiche::QuicheReferenceCountedPointer<Result> result,
std::unique_ptr<ProofSource::Details> details) override;
private:
@@ -157,7 +158,8 @@
// the client hello is complete. Finishes processing of the client
// hello message and handles handshake success/failure.
void FinishProcessingHandshakeMessage(
- QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
+ quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
result,
std::unique_ptr<ProofSource::Details> details);
@@ -198,7 +200,7 @@
// Server's certificate chain and signature of the server config, as provided
// by ProofSource::GetProof.
- QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config_;
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig> signed_config_;
// Hash of the last received CHLO message which can be used for generating
// server config update messages.
@@ -256,7 +258,7 @@
bool encryption_established_;
bool one_rtt_keys_available_;
bool one_rtt_packet_decrypted_;
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
crypto_negotiated_params_;
};
diff --git a/quic/core/quic_crypto_stream_test.cc b/quic/core/quic_crypto_stream_test.cc
index f8828be..fffcb09 100644
--- a/quic/core/quic_crypto_stream_test.cc
+++ b/quic/core/quic_crypto_stream_test.cc
@@ -96,7 +96,7 @@
SSL* GetSsl() const override { return nullptr; }
private:
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
std::vector<CryptoHandshakeMessage> messages_;
};
diff --git a/quic/core/quic_datagram_queue_test.cc b/quic/core/quic_datagram_queue_test.cc
index 295e72a..4c0e0f2 100644
--- a/quic/core/quic_datagram_queue_test.cc
+++ b/quic/core/quic_datagram_queue_test.cc
@@ -11,10 +11,10 @@
#include "quic/core/crypto/null_encrypter.h"
#include "quic/core/quic_time.h"
#include "quic/core/quic_types.h"
-#include "quic/platform/api/quic_reference_counted.h"
#include "quic/platform/api/quic_test.h"
#include "quic/test_tools/quic_test_utils.h"
#include "common/platform/api/quiche_mem_slice.h"
+#include "common/platform/api/quiche_reference_counted.h"
#include "common/quiche_buffer_allocator.h"
namespace quic {
@@ -35,7 +35,7 @@
class QuicDatagramQueueObserver final : public QuicDatagramQueue::Observer {
public:
- class Context : public QuicReferenceCounted {
+ class Context : public quiche::QuicheReferenceCounted {
public:
std::vector<absl::optional<MessageStatus>> statuses;
};
@@ -49,10 +49,12 @@
context_->statuses.push_back(std::move(status));
}
- const QuicReferenceCountedPointer<Context>& context() { return context_; }
+ const quiche::QuicheReferenceCountedPointer<Context>& context() {
+ return context_;
+ }
private:
- QuicReferenceCountedPointer<Context> context_;
+ quiche::QuicheReferenceCountedPointer<Context> context_;
};
class QuicDatagramQueueTestBase : public QuicTest {
@@ -209,7 +211,8 @@
// This is moved out immediately.
std::unique_ptr<QuicDatagramQueueObserver> observer_;
- QuicReferenceCountedPointer<QuicDatagramQueueObserver::Context> context_;
+ quiche::QuicheReferenceCountedPointer<QuicDatagramQueueObserver::Context>
+ context_;
QuicDatagramQueue queue_;
};
diff --git a/quic/core/quic_dispatcher.h b/quic/core/quic_dispatcher.h
index f22d58a..72ea5cd 100644
--- a/quic/core/quic_dispatcher.h
+++ b/quic/core/quic_dispatcher.h
@@ -27,8 +27,8 @@
#include "quic/core/quic_session.h"
#include "quic/core/quic_time_wait_list_manager.h"
#include "quic/core/quic_version_manager.h"
-#include "quic/platform/api/quic_reference_counted.h"
#include "quic/platform/api/quic_socket_address.h"
+#include "common/platform/api/quiche_reference_counted.h"
#include "common/quiche_linked_hash_map.h"
namespace quic {
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 4d5eed5..5abc651 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -190,7 +190,7 @@
bool encryption_established_;
bool one_rtt_keys_available_;
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
};
class TestStream : public QuicStream {
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index 8737044..a1d482a 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -649,7 +649,8 @@
void QuicStream::WriteOrBufferData(
absl::string_view data, bool fin,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener) {
QUIC_BUG_IF(quic_bug_12570_4,
QuicUtils::IsCryptoStreamId(transport_version(), id_))
<< ENDPOINT
@@ -662,7 +663,8 @@
void QuicStream::WriteOrBufferDataAtLevel(
absl::string_view data, bool fin, EncryptionLevel level,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener) {
if (data.empty() && !fin) {
QUIC_BUG(quic_bug_10586_2) << "data.empty() && !fin";
return;
diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h
index 4a6acca..0547e74 100644
--- a/quic/core/quic_stream.h
+++ b/quic/core/quic_stream.h
@@ -35,8 +35,8 @@
#include "quic/core/session_notifier_interface.h"
#include "quic/core/stream_delegate_interface.h"
#include "quic/platform/api/quic_export.h"
-#include "quic/platform/api/quic_reference_counted.h"
#include "common/platform/api/quiche_mem_slice.h"
+#include "common/platform/api/quiche_reference_counted.h"
#include "spdy/core/spdy_protocol.h"
namespace quic {
@@ -316,12 +316,14 @@
// true.
void WriteOrBufferData(
absl::string_view data, bool fin,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener);
// Sends |data| to connection with specified |level|.
void WriteOrBufferDataAtLevel(
absl::string_view data, bool fin, EncryptionLevel level,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener);
// Adds random padding after the fin is consumed for this stream.
void AddRandomPaddingAfterFin();
@@ -409,7 +411,7 @@
// buffer.
virtual void OnDataBuffered(
QuicStreamOffset /*offset*/, QuicByteCount /*data_length*/,
- const QuicReferenceCountedPointer<QuicAckListenerInterface>&
+ const quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>&
/*ack_listener*/) {}
// Called just before the object is destroyed.
diff --git a/quic/core/tls_client_handshaker.h b/quic/core/tls_client_handshaker.h
index c7db0ed..c9a760e 100644
--- a/quic/core/tls_client_handshaker.h
+++ b/quic/core/tls_client_handshaker.h
@@ -149,7 +149,7 @@
HandshakeState state_ = HANDSHAKE_START;
bool encryption_established_ = false;
bool initial_keys_dropped_ = false;
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
crypto_negotiated_params_;
bool allow_empty_alpn_for_tests_ = false;
diff --git a/quic/core/tls_server_handshaker.cc b/quic/core/tls_server_handshaker.cc
index dc4b39a..f622d56 100644
--- a/quic/core/tls_server_handshaker.cc
+++ b/quic/core/tls_server_handshaker.cc
@@ -78,7 +78,7 @@
}
bool cert_matched_sni;
- QuicReferenceCountedPointer<ProofSource::Chain> chain =
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain =
proof_source_->GetCertChain(server_address, client_address, hostname,
&cert_matched_sni);
diff --git a/quic/core/tls_server_handshaker.h b/quic/core/tls_server_handshaker.h
index c2ea44b..b5764a5 100644
--- a/quic/core/tls_server_handshaker.h
+++ b/quic/core/tls_server_handshaker.h
@@ -374,7 +374,7 @@
bool encryption_established_ = false;
bool valid_alpn_received_ = false;
bool can_disable_resumption_ = true;
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters>
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters>
crypto_negotiated_params_;
TlsServerConnection tls_connection_;
const QuicCryptoServerConfig* crypto_config_; // Unowned.
diff --git a/quic/core/tls_server_handshaker_test.cc b/quic/core/tls_server_handshaker_test.cc
index 01fb7ab..0d46ef8 100644
--- a/quic/core/tls_server_handshaker_test.cc
+++ b/quic/core/tls_server_handshaker_test.cc
@@ -402,8 +402,8 @@
std::string der_cert =
CreateSelfSignedCertificate(*client_cert_key.private_key(), options);
- QuicReferenceCountedPointer<ClientProofSource::Chain> client_cert_chain(
- new ClientProofSource::Chain({der_cert}));
+ quiche::QuicheReferenceCountedPointer<ClientProofSource::Chain>
+ client_cert_chain(new ClientProofSource::Chain({der_cert}));
if (!client_proof_source->AddCertAndKey({"*"}, client_cert_chain,
std::move(client_cert_key))) {
diff --git a/quic/platform/api/quic_reference_counted.h b/quic/platform/api/quic_reference_counted.h
deleted file mode 100644
index 18f6f37..0000000
--- a/quic/platform/api/quic_reference_counted.h
+++ /dev/null
@@ -1,162 +0,0 @@
-// Copyright (c) 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef QUICHE_QUIC_PLATFORM_API_QUIC_REFERENCE_COUNTED_H_
-#define QUICHE_QUIC_PLATFORM_API_QUIC_REFERENCE_COUNTED_H_
-
-#include "net/quic/platform/impl/quic_reference_counted_impl.h"
-
-namespace quic {
-
-// Base class for explicitly reference-counted objects in QUIC.
-class QUIC_EXPORT_PRIVATE QuicReferenceCounted
- : public QuicReferenceCountedImpl {
- public:
- QuicReferenceCounted() {}
-
- protected:
- ~QuicReferenceCounted() override {}
-};
-
-// A class representing a reference counted pointer in QUIC.
-//
-// Construct or initialize QuicReferenceCountedPointer from raw pointer. Here
-// raw pointer MUST be a newly created object. Reference count of a newly
-// created object is undefined, but that will be 1 after being added to
-// QuicReferenceCountedPointer.
-// QuicReferenceCountedPointer is used as a local variable.
-// QuicReferenceCountedPointer<T> r_ptr(new T());
-// or, equivalently:
-// QuicReferenceCountedPointer<T> r_ptr;
-// T* p = new T();
-// r_ptr = T;
-//
-// QuicReferenceCountedPointer is used as a member variable:
-// MyClass::MyClass() : r_ptr(new T()) {}
-//
-// This is WRONG, since *p is not guaranteed to be newly created:
-// MyClass::MyClass(T* p) : r_ptr(p) {}
-//
-// Given an existing QuicReferenceCountedPointer, create a duplicate that has
-// its own reference on the object:
-// QuicReferenceCountedPointer<T> r_ptr_b(r_ptr_a);
-// or, equivalently:
-// QuicReferenceCountedPointer<T> r_ptr_b = r_ptr_a;
-//
-// Given an existing QuicReferenceCountedPointer, create a
-// QuicReferenceCountedPointer that adopts the reference:
-// QuicReferenceCountedPointer<T> r_ptr_b(std::move(r_ptr_a));
-// or, equivalently:
-// QuicReferenceCountedPointer<T> r_ptr_b = std::move(r_ptr_a);
-
-template <class T>
-class QUIC_NO_EXPORT QuicReferenceCountedPointer {
- public:
- QuicReferenceCountedPointer() = default;
-
- // Constructor from raw pointer |p|. This guarantees that the reference count
- // of *p is 1. This should be only called when a new object is created.
- // Calling this on an already existent object does not increase its reference
- // count.
- explicit QuicReferenceCountedPointer(T* p) : impl_(p) {}
-
- // Allows implicit conversion from nullptr.
- QuicReferenceCountedPointer(std::nullptr_t) : impl_(nullptr) {} // NOLINT
-
- // Copy and copy conversion constructors. It does not take the reference away
- // from |other| and they each end up with their own reference.
- template <typename U>
- QuicReferenceCountedPointer( // NOLINT
- const QuicReferenceCountedPointer<U>& other)
- : impl_(other.impl()) {}
- QuicReferenceCountedPointer(const QuicReferenceCountedPointer& other)
- : impl_(other.impl()) {}
-
- // Move constructors. After move, it adopts the reference from |other|.
- template <typename U>
- QuicReferenceCountedPointer(QuicReferenceCountedPointer<U>&& other) // NOLINT
- : impl_(std::move(other.impl())) {}
- QuicReferenceCountedPointer(QuicReferenceCountedPointer&& other)
- : impl_(std::move(other.impl())) {}
-
- ~QuicReferenceCountedPointer() = default;
-
- // Copy assignments.
- QuicReferenceCountedPointer& operator=(
- const QuicReferenceCountedPointer& other) {
- impl_ = other.impl();
- return *this;
- }
- template <typename U>
- QuicReferenceCountedPointer<T>& operator=(
- const QuicReferenceCountedPointer<U>& other) {
- impl_ = other.impl();
- return *this;
- }
-
- // Move assignments.
- QuicReferenceCountedPointer& operator=(QuicReferenceCountedPointer&& other) {
- impl_ = std::move(other.impl());
- return *this;
- }
- template <typename U>
- QuicReferenceCountedPointer<T>& operator=(
- QuicReferenceCountedPointer<U>&& other) {
- impl_ = std::move(other.impl());
- return *this;
- }
-
- // Accessors for the referenced object.
- // operator*() and operator->() will assert() if there is no current object.
- T& operator*() const { return *impl_; }
- T* operator->() const { return impl_.get(); }
-
- explicit operator bool() const { return static_cast<bool>(impl_); }
-
- // Assignment operator on raw pointer. Drops a reference to current pointee,
- // if any, and replaces it with |p|. This guarantees that the reference count
- // of *p is 1. This should only be used when a new object is created. Calling
- // this on an already existent object is undefined behavior.
- QuicReferenceCountedPointer<T>& operator=(T* p) {
- impl_ = p;
- return *this;
- }
-
- // Returns the raw pointer with no change in reference count.
- T* get() const { return impl_.get(); }
-
- QuicReferenceCountedPointerImpl<T>& impl() { return impl_; }
- const QuicReferenceCountedPointerImpl<T>& impl() const { return impl_; }
-
- // Comparisons against same type.
- friend bool operator==(const QuicReferenceCountedPointer& a,
- const QuicReferenceCountedPointer& b) {
- return a.get() == b.get();
- }
- friend bool operator!=(const QuicReferenceCountedPointer& a,
- const QuicReferenceCountedPointer& b) {
- return a.get() != b.get();
- }
-
- // Comparisons against nullptr.
- friend bool operator==(const QuicReferenceCountedPointer& a, std::nullptr_t) {
- return a.get() == nullptr;
- }
- friend bool operator==(std::nullptr_t, const QuicReferenceCountedPointer& b) {
- return nullptr == b.get();
- }
- friend bool operator!=(const QuicReferenceCountedPointer& a, std::nullptr_t) {
- return a.get() != nullptr;
- }
- friend bool operator!=(std::nullptr_t, const QuicReferenceCountedPointer& b) {
- return nullptr != b.get();
- }
-
- private:
- QuicReferenceCountedPointerImpl<T> impl_;
-};
-
-} // namespace quic
-
-#endif // QUICHE_QUIC_PLATFORM_API_QUIC_REFERENCE_COUNTED_H_
diff --git a/quic/platform/api/quic_reference_counted_test.cc b/quic/platform/api/quic_reference_counted_test.cc
deleted file mode 100644
index e2ea981..0000000
--- a/quic/platform/api/quic_reference_counted_test.cc
+++ /dev/null
@@ -1,173 +0,0 @@
-// Copyright (c) 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "quic/platform/api/quic_reference_counted.h"
-
-#include "quic/platform/api/quic_test.h"
-
-namespace quic {
-namespace test {
-namespace {
-
-class Base : public QuicReferenceCounted {
- public:
- explicit Base(bool* destroyed) : destroyed_(destroyed) {
- *destroyed_ = false;
- }
-
- protected:
- ~Base() override { *destroyed_ = true; }
-
- private:
- bool* destroyed_;
-};
-
-class Derived : public Base {
- public:
- explicit Derived(bool* destroyed) : Base(destroyed) {}
-
- private:
- ~Derived() override {}
-};
-
-class QuicReferenceCountedTest : public QuicTest {};
-
-TEST_F(QuicReferenceCountedTest, DefaultConstructor) {
- QuicReferenceCountedPointer<Base> a;
- EXPECT_EQ(nullptr, a);
- EXPECT_EQ(nullptr, a.get());
- EXPECT_FALSE(a);
-}
-
-TEST_F(QuicReferenceCountedTest, ConstructFromRawPointer) {
- bool destroyed = false;
- {
- QuicReferenceCountedPointer<Base> a(new Base(&destroyed));
- EXPECT_FALSE(destroyed);
- }
- EXPECT_TRUE(destroyed);
-}
-
-TEST_F(QuicReferenceCountedTest, RawPointerAssignment) {
- bool destroyed = false;
- {
- QuicReferenceCountedPointer<Base> a;
- Base* rct = new Base(&destroyed);
- a = rct;
- EXPECT_FALSE(destroyed);
- }
- EXPECT_TRUE(destroyed);
-}
-
-TEST_F(QuicReferenceCountedTest, PointerCopy) {
- bool destroyed = false;
- {
- QuicReferenceCountedPointer<Base> a(new Base(&destroyed));
- {
- QuicReferenceCountedPointer<Base> b(a);
- EXPECT_EQ(a, b);
- EXPECT_FALSE(destroyed);
- }
- EXPECT_FALSE(destroyed);
- }
- EXPECT_TRUE(destroyed);
-}
-
-TEST_F(QuicReferenceCountedTest, PointerCopyAssignment) {
- bool destroyed = false;
- {
- QuicReferenceCountedPointer<Base> a(new Base(&destroyed));
- {
- QuicReferenceCountedPointer<Base> b = a;
- EXPECT_EQ(a, b);
- EXPECT_FALSE(destroyed);
- }
- EXPECT_FALSE(destroyed);
- }
- EXPECT_TRUE(destroyed);
-}
-
-TEST_F(QuicReferenceCountedTest, PointerCopyFromOtherType) {
- bool destroyed = false;
- {
- QuicReferenceCountedPointer<Derived> a(new Derived(&destroyed));
- {
- QuicReferenceCountedPointer<Base> b(a);
- EXPECT_EQ(a.get(), b.get());
- EXPECT_FALSE(destroyed);
- }
- EXPECT_FALSE(destroyed);
- }
- EXPECT_TRUE(destroyed);
-}
-
-TEST_F(QuicReferenceCountedTest, PointerCopyAssignmentFromOtherType) {
- bool destroyed = false;
- {
- QuicReferenceCountedPointer<Derived> a(new Derived(&destroyed));
- {
- QuicReferenceCountedPointer<Base> b = a;
- EXPECT_EQ(a.get(), b.get());
- EXPECT_FALSE(destroyed);
- }
- EXPECT_FALSE(destroyed);
- }
- EXPECT_TRUE(destroyed);
-}
-
-TEST_F(QuicReferenceCountedTest, PointerMove) {
- bool destroyed = false;
- QuicReferenceCountedPointer<Base> a(new Derived(&destroyed));
- EXPECT_FALSE(destroyed);
- QuicReferenceCountedPointer<Base> b(std::move(a));
- EXPECT_FALSE(destroyed);
- EXPECT_NE(nullptr, b);
- EXPECT_EQ(nullptr, a); // NOLINT
-
- b = nullptr;
- EXPECT_TRUE(destroyed);
-}
-
-TEST_F(QuicReferenceCountedTest, PointerMoveAssignment) {
- bool destroyed = false;
- QuicReferenceCountedPointer<Base> a(new Derived(&destroyed));
- EXPECT_FALSE(destroyed);
- QuicReferenceCountedPointer<Base> b = std::move(a);
- EXPECT_FALSE(destroyed);
- EXPECT_NE(nullptr, b);
- EXPECT_EQ(nullptr, a); // NOLINT
-
- b = nullptr;
- EXPECT_TRUE(destroyed);
-}
-
-TEST_F(QuicReferenceCountedTest, PointerMoveFromOtherType) {
- bool destroyed = false;
- QuicReferenceCountedPointer<Derived> a(new Derived(&destroyed));
- EXPECT_FALSE(destroyed);
- QuicReferenceCountedPointer<Base> b(std::move(a));
- EXPECT_FALSE(destroyed);
- EXPECT_NE(nullptr, b);
- EXPECT_EQ(nullptr, a); // NOLINT
-
- b = nullptr;
- EXPECT_TRUE(destroyed);
-}
-
-TEST_F(QuicReferenceCountedTest, PointerMoveAssignmentFromOtherType) {
- bool destroyed = false;
- QuicReferenceCountedPointer<Derived> a(new Derived(&destroyed));
- EXPECT_FALSE(destroyed);
- QuicReferenceCountedPointer<Base> b = std::move(a);
- EXPECT_FALSE(destroyed);
- EXPECT_NE(nullptr, b);
- EXPECT_EQ(nullptr, a); // NOLINT
-
- b = nullptr;
- EXPECT_TRUE(destroyed);
-}
-
-} // namespace
-} // namespace test
-} // namespace quic
diff --git a/quic/qbone/qbone_session_test.cc b/quic/qbone/qbone_session_test.cc
index c3ae3be..e787174 100644
--- a/quic/qbone/qbone_session_test.cc
+++ b/quic/qbone/qbone_session_test.cc
@@ -80,8 +80,9 @@
std::unique_ptr<Callback> callback) override {
if (!proof_source_) {
QuicCryptoProof proof;
- QuicReferenceCountedPointer<ProofSource::Chain> chain = GetCertChain(
- server_address, client_address, hostname, &proof.cert_matched_sni);
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain =
+ GetCertChain(server_address, client_address, hostname,
+ &proof.cert_matched_sni);
callback->Run(/*ok=*/false, chain, proof, /*details=*/nullptr);
return;
}
@@ -90,12 +91,12 @@
std::move(callback));
}
- QuicReferenceCountedPointer<Chain> GetCertChain(
+ quiche::QuicheReferenceCountedPointer<Chain> GetCertChain(
const QuicSocketAddress& server_address,
const QuicSocketAddress& client_address, const std::string& hostname,
bool* cert_matched_sni) override {
if (!proof_source_) {
- return QuicReferenceCountedPointer<Chain>();
+ return quiche::QuicheReferenceCountedPointer<Chain>();
}
return proof_source_->GetCertChain(server_address, client_address, hostname,
cert_matched_sni);
diff --git a/quic/test_tools/crypto_test_utils.cc b/quic/test_tools/crypto_test_utils.cc
index f39d463..30bf0a2 100644
--- a/quic/test_tools/crypto_test_utils.cc
+++ b/quic/test_tools/crypto_test_utils.cc
@@ -103,12 +103,11 @@
class FullChloGenerator {
public:
FullChloGenerator(
- QuicCryptoServerConfig* crypto_config,
- QuicSocketAddress server_addr,
- QuicSocketAddress client_addr,
- const QuicClock* clock,
+ QuicCryptoServerConfig* crypto_config, QuicSocketAddress server_addr,
+ QuicSocketAddress client_addr, const QuicClock* clock,
ParsedQuicVersion version,
- QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config,
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig>
+ signed_config,
QuicCompressedCertsCache* compressed_certs_cache,
CryptoHandshakeMessage* out)
: crypto_config_(crypto_config),
@@ -125,8 +124,9 @@
public:
explicit ValidateClientHelloCallback(FullChloGenerator* generator)
: generator_(generator) {}
- void Run(QuicReferenceCountedPointer<
- ValidateClientHelloResultCallback::Result> result,
+ void Run(quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
+ result,
std::unique_ptr<ProofSource::Details> /* details */) override {
generator_->ValidateClientHelloDone(std::move(result));
}
@@ -141,9 +141,9 @@
}
private:
- void ValidateClientHelloDone(
- QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
- result) {
+ void ValidateClientHelloDone(quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
+ result) {
result_ = result;
crypto_config_->ProcessClientHello(
result_, /*reject_only=*/false, TestConnectionId(1), server_addr_,
@@ -205,12 +205,13 @@
QuicSocketAddress client_addr_;
const QuicClock* clock_;
ParsedQuicVersion version_;
- QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config_;
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig> signed_config_;
QuicCompressedCertsCache* compressed_certs_cache_;
CryptoHandshakeMessage* out_;
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
- QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
+ quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
result_;
};
@@ -473,7 +474,7 @@
}
uint64_t LeafCertHashForTesting() {
- QuicReferenceCountedPointer<ProofSource::Chain> chain;
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain;
QuicSocketAddress server_address(QuicIpAddress::Any4(), 42);
QuicSocketAddress client_address(QuicIpAddress::Any4(), 43);
QuicCryptoProof proof;
@@ -481,20 +482,22 @@
class Callback : public ProofSource::Callback {
public:
- Callback(bool* ok, QuicReferenceCountedPointer<ProofSource::Chain>* chain)
+ Callback(bool* ok,
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain>* chain)
: ok_(ok), chain_(chain) {}
- void Run(bool ok,
- const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
- const QuicCryptoProof& /* proof */,
- std::unique_ptr<ProofSource::Details> /* details */) override {
+ void Run(
+ bool ok,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
+ const QuicCryptoProof& /* proof */,
+ std::unique_ptr<ProofSource::Details> /* details */) override {
*ok_ = ok;
*chain_ = chain;
}
private:
bool* ok_;
- QuicReferenceCountedPointer<ProofSource::Chain>* chain_;
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain>* chain_;
};
// Note: relies on the callback being invoked synchronously
@@ -838,12 +841,10 @@
void GenerateFullCHLO(
const CryptoHandshakeMessage& inchoate_chlo,
- QuicCryptoServerConfig* crypto_config,
- QuicSocketAddress server_addr,
- QuicSocketAddress client_addr,
- QuicTransportVersion transport_version,
+ QuicCryptoServerConfig* crypto_config, QuicSocketAddress server_addr,
+ QuicSocketAddress client_addr, QuicTransportVersion transport_version,
const QuicClock* clock,
- QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config,
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig> signed_config,
QuicCompressedCertsCache* compressed_certs_cache,
CryptoHandshakeMessage* out) {
// Pass a inchoate CHLO.
diff --git a/quic/test_tools/crypto_test_utils.h b/quic/test_tools/crypto_test_utils.h
index bd065f6..c92eb17 100644
--- a/quic/test_tools/crypto_test_utils.h
+++ b/quic/test_tools/crypto_test_utils.h
@@ -192,12 +192,10 @@
// |crypto_config|'s validation.
void GenerateFullCHLO(
const CryptoHandshakeMessage& inchoate_chlo,
- QuicCryptoServerConfig* crypto_config,
- QuicSocketAddress server_addr,
- QuicSocketAddress client_addr,
- QuicTransportVersion transport_version,
+ QuicCryptoServerConfig* crypto_config, QuicSocketAddress server_addr,
+ QuicSocketAddress client_addr, QuicTransportVersion transport_version,
const QuicClock* clock,
- QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config,
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig> signed_config,
QuicCompressedCertsCache* compressed_certs_cache,
CryptoHandshakeMessage* out);
diff --git a/quic/test_tools/crypto_test_utils_test.cc b/quic/test_tools/crypto_test_utils_test.cc
index b1f2115..18bada5 100644
--- a/quic/test_tools/crypto_test_utils_test.cc
+++ b/quic/test_tools/crypto_test_utils_test.cc
@@ -18,14 +18,13 @@
class ShloVerifier {
public:
- ShloVerifier(
- QuicCryptoServerConfig* crypto_config,
- QuicSocketAddress server_addr,
- QuicSocketAddress client_addr,
- const QuicClock* clock,
- QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config,
- QuicCompressedCertsCache* compressed_certs_cache,
- ParsedQuicVersion version)
+ ShloVerifier(QuicCryptoServerConfig* crypto_config,
+ QuicSocketAddress server_addr, QuicSocketAddress client_addr,
+ const QuicClock* clock,
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig>
+ signed_config,
+ QuicCompressedCertsCache* compressed_certs_cache,
+ ParsedQuicVersion version)
: crypto_config_(crypto_config),
server_addr_(server_addr),
client_addr_(client_addr),
@@ -39,8 +38,9 @@
public:
explicit ValidateClientHelloCallback(ShloVerifier* shlo_verifier)
: shlo_verifier_(shlo_verifier) {}
- void Run(QuicReferenceCountedPointer<
- ValidateClientHelloResultCallback::Result> result,
+ void Run(quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
+ result,
std::unique_ptr<ProofSource::Details> /* details */) override {
shlo_verifier_->ValidateClientHelloDone(result);
}
@@ -56,7 +56,7 @@
private:
void ValidateClientHelloDone(
- const QuicReferenceCountedPointer<
+ const quiche::QuicheReferenceCountedPointer<
ValidateClientHelloResultCallback::Result>& result) {
result_ = result;
crypto_config_->ProcessClientHello(
@@ -99,11 +99,12 @@
QuicSocketAddress server_addr_;
QuicSocketAddress client_addr_;
const QuicClock* clock_;
- QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config_;
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig> signed_config_;
QuicCompressedCertsCache* compressed_certs_cache_;
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
- QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
+ quiche::QuicheReferenceCountedPointer<
+ ValidateClientHelloResultCallback::Result>
result_;
const ParsedQuicVersion version_;
@@ -118,7 +119,7 @@
crypto_test_utils::ProofSourceForTesting(), KeyExchangeSource::Default());
QuicSocketAddress server_addr(QuicIpAddress::Any4(), 5);
QuicSocketAddress client_addr(QuicIpAddress::Loopback4(), 1);
- QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config(
+ quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig> signed_config(
new QuicSignedServerConfig);
QuicCompressedCertsCache compressed_certs_cache(
QuicCompressedCertsCache::kQuicCompressedCertsCacheSize);
diff --git a/quic/test_tools/failing_proof_source.cc b/quic/test_tools/failing_proof_source.cc
index 1f17c8a..8eb13db 100644
--- a/quic/test_tools/failing_proof_source.cc
+++ b/quic/test_tools/failing_proof_source.cc
@@ -19,13 +19,13 @@
callback->Run(false, nullptr, QuicCryptoProof(), nullptr);
}
-QuicReferenceCountedPointer<ProofSource::Chain>
+quiche::QuicheReferenceCountedPointer<ProofSource::Chain>
FailingProofSource::GetCertChain(const QuicSocketAddress& /*server_address*/,
const QuicSocketAddress& /*client_address*/,
const std::string& /*hostname*/,
bool* cert_matched_sni) {
*cert_matched_sni = false;
- return QuicReferenceCountedPointer<Chain>();
+ return quiche::QuicheReferenceCountedPointer<Chain>();
}
void FailingProofSource::ComputeTlsSignature(
diff --git a/quic/test_tools/failing_proof_source.h b/quic/test_tools/failing_proof_source.h
index db5a197..333bdc3 100644
--- a/quic/test_tools/failing_proof_source.h
+++ b/quic/test_tools/failing_proof_source.h
@@ -21,7 +21,7 @@
absl::string_view chlo_hash,
std::unique_ptr<Callback> callback) override;
- QuicReferenceCountedPointer<Chain> GetCertChain(
+ quiche::QuicheReferenceCountedPointer<Chain> GetCertChain(
const QuicSocketAddress& server_address,
const QuicSocketAddress& client_address, const std::string& hostname,
bool* cert_matched_sni) override;
diff --git a/quic/test_tools/fake_proof_source.cc b/quic/test_tools/fake_proof_source.cc
index 0f7cb19..2f30610 100644
--- a/quic/test_tools/fake_proof_source.cc
+++ b/quic/test_tools/fake_proof_source.cc
@@ -94,10 +94,11 @@
delegate_.get()));
}
-QuicReferenceCountedPointer<ProofSource::Chain> FakeProofSource::GetCertChain(
- const QuicSocketAddress& server_address,
- const QuicSocketAddress& client_address, const std::string& hostname,
- bool* cert_matched_sni) {
+quiche::QuicheReferenceCountedPointer<ProofSource::Chain>
+FakeProofSource::GetCertChain(const QuicSocketAddress& server_address,
+ const QuicSocketAddress& client_address,
+ const std::string& hostname,
+ bool* cert_matched_sni) {
return delegate_->GetCertChain(server_address, client_address, hostname,
cert_matched_sni);
}
diff --git a/quic/test_tools/fake_proof_source.h b/quic/test_tools/fake_proof_source.h
index b135129..256e174 100644
--- a/quic/test_tools/fake_proof_source.h
+++ b/quic/test_tools/fake_proof_source.h
@@ -41,7 +41,7 @@
QuicTransportVersion transport_version,
absl::string_view chlo_hash,
std::unique_ptr<ProofSource::Callback> callback) override;
- QuicReferenceCountedPointer<Chain> GetCertChain(
+ quiche::QuicheReferenceCountedPointer<Chain> GetCertChain(
const QuicSocketAddress& server_address,
const QuicSocketAddress& client_address, const std::string& hostname,
bool* cert_matched_sni) override;
diff --git a/quic/test_tools/fake_proof_source_handle.cc b/quic/test_tools/fake_proof_source_handle.cc
index 0b2e06f..7d30bdd 100644
--- a/quic/test_tools/fake_proof_source_handle.cc
+++ b/quic/test_tools/fake_proof_source_handle.cc
@@ -104,7 +104,7 @@
QUICHE_DCHECK(select_cert_action_ == Action::DELEGATE_SYNC);
bool cert_matched_sni;
- QuicReferenceCountedPointer<ProofSource::Chain> chain =
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain =
delegate_->GetCertChain(server_address, client_address, hostname,
&cert_matched_sni);
@@ -197,7 +197,7 @@
/*cert_matched_sni=*/false, dealyed_ssl_config_);
} else if (action_ == Action::DELEGATE_ASYNC) {
bool cert_matched_sni;
- QuicReferenceCountedPointer<ProofSource::Chain> chain =
+ quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain =
delegate_->GetCertChain(args_.server_address, args_.client_address,
args_.hostname, &cert_matched_sni);
bool ok = chain && !chain->certs.empty();
diff --git a/quic/test_tools/quic_crypto_server_config_peer.cc b/quic/test_tools/quic_crypto_server_config_peer.cc
index 848ebad..8027d78 100644
--- a/quic/test_tools/quic_crypto_server_config_peer.cc
+++ b/quic/test_tools/quic_crypto_server_config_peer.cc
@@ -12,19 +12,19 @@
namespace quic {
namespace test {
-QuicReferenceCountedPointer<QuicCryptoServerConfig::Config>
+quiche::QuicheReferenceCountedPointer<QuicCryptoServerConfig::Config>
QuicCryptoServerConfigPeer::GetPrimaryConfig() {
QuicReaderMutexLock locked(&server_config_->configs_lock_);
- return QuicReferenceCountedPointer<QuicCryptoServerConfig::Config>(
+ return quiche::QuicheReferenceCountedPointer<QuicCryptoServerConfig::Config>(
server_config_->primary_config_);
}
-QuicReferenceCountedPointer<QuicCryptoServerConfig::Config>
+quiche::QuicheReferenceCountedPointer<QuicCryptoServerConfig::Config>
QuicCryptoServerConfigPeer::GetConfig(std::string config_id) {
QuicReaderMutexLock locked(&server_config_->configs_lock_);
if (config_id == "<primary>") {
- return QuicReferenceCountedPointer<QuicCryptoServerConfig::Config>(
- server_config_->primary_config_);
+ return quiche::QuicheReferenceCountedPointer<
+ QuicCryptoServerConfig::Config>(server_config_->primary_config_);
} else {
return server_config_->GetConfigWithScid(config_id);
}
@@ -91,9 +91,9 @@
ASSERT_EQ(expected_ids_and_status.size(), server_config_->configs_.size())
<< ConfigsDebug();
- for (const std::pair<
- const ServerConfigID,
- QuicReferenceCountedPointer<QuicCryptoServerConfig::Config>>& i :
+ for (const std::pair<const ServerConfigID,
+ quiche::QuicheReferenceCountedPointer<
+ QuicCryptoServerConfig::Config>>& i :
server_config_->configs_) {
bool found = false;
for (std::pair<ServerConfigID, bool>& j : expected_ids_and_status) {
@@ -120,8 +120,8 @@
std::string s;
for (const auto& i : server_config_->configs_) {
- const QuicReferenceCountedPointer<QuicCryptoServerConfig::Config> config =
- i.second;
+ const quiche::QuicheReferenceCountedPointer<QuicCryptoServerConfig::Config>
+ config = i.second;
if (config->is_primary) {
s += "(primary) ";
} else {
@@ -142,7 +142,7 @@
std::string QuicCryptoServerConfigPeer::CompressChain(
QuicCompressedCertsCache* compressed_certs_cache,
- const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
const std::string& client_cached_cert_hashes) {
return QuicCryptoServerConfig::CompressChain(compressed_certs_cache, chain,
client_cached_cert_hashes);
diff --git a/quic/test_tools/quic_crypto_server_config_peer.h b/quic/test_tools/quic_crypto_server_config_peer.h
index 649e323..029d403 100644
--- a/quic/test_tools/quic_crypto_server_config_peer.h
+++ b/quic/test_tools/quic_crypto_server_config_peer.h
@@ -18,12 +18,12 @@
: server_config_(server_config) {}
// Returns the primary config.
- QuicReferenceCountedPointer<QuicCryptoServerConfig::Config>
+ quiche::QuicheReferenceCountedPointer<QuicCryptoServerConfig::Config>
GetPrimaryConfig();
// Returns the config associated with |config_id|.
- QuicReferenceCountedPointer<QuicCryptoServerConfig::Config> GetConfig(
- std::string config_id);
+ quiche::QuicheReferenceCountedPointer<QuicCryptoServerConfig::Config>
+ GetConfig(std::string config_id);
// Returns a pointer to the ProofSource object.
ProofSource* GetProofSource() const;
@@ -76,7 +76,7 @@
static std::string CompressChain(
QuicCompressedCertsCache* compressed_certs_cache,
- const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
+ const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
const std::string& client_cached_cert_hashes);
uint32_t source_address_token_future_secs();
diff --git a/quic/test_tools/quic_spdy_session_peer.cc b/quic/test_tools/quic_spdy_session_peer.cc
index f0f99ee..cf14ab3 100644
--- a/quic/test_tools/quic_spdy_session_peer.cc
+++ b/quic/test_tools/quic_spdy_session_peer.cc
@@ -48,7 +48,8 @@
size_t QuicSpdySessionPeer::WriteHeadersOnHeadersStream(
QuicSpdySession* session, QuicStreamId id, spdy::SpdyHeaderBlock headers,
bool fin, const spdy::SpdyStreamPrecedence& precedence,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener) {
return session->WriteHeadersOnHeadersStream(
id, std::move(headers), fin, precedence, std::move(ack_listener));
}
diff --git a/quic/test_tools/quic_spdy_session_peer.h b/quic/test_tools/quic_spdy_session_peer.h
index ba28e67..df65fc3 100644
--- a/quic/test_tools/quic_spdy_session_peer.h
+++ b/quic/test_tools/quic_spdy_session_peer.h
@@ -34,7 +34,8 @@
static size_t WriteHeadersOnHeadersStream(
QuicSpdySession* session, QuicStreamId id, spdy::SpdyHeaderBlock headers,
bool fin, const spdy::SpdyStreamPrecedence& precedence,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener);
// |session| can't be nullptr.
static QuicStreamId GetNextOutgoingUnidirectionalStreamId(
QuicSpdySession* session);
diff --git a/quic/test_tools/quic_spdy_stream_peer.cc b/quic/test_tools/quic_spdy_stream_peer.cc
index ea21081..f55e60a 100644
--- a/quic/test_tools/quic_spdy_stream_peer.cc
+++ b/quic/test_tools/quic_spdy_stream_peer.cc
@@ -13,7 +13,8 @@
// static
void QuicSpdyStreamPeer::set_ack_listener(
QuicSpdyStream* stream,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener) {
stream->set_ack_listener(std::move(ack_listener));
}
diff --git a/quic/test_tools/quic_spdy_stream_peer.h b/quic/test_tools/quic_spdy_stream_peer.h
index 692cbc3..10bb4a6 100644
--- a/quic/test_tools/quic_spdy_stream_peer.h
+++ b/quic/test_tools/quic_spdy_stream_peer.h
@@ -20,7 +20,8 @@
public:
static void set_ack_listener(
QuicSpdyStream* stream,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener);
static const QuicIntervalSet<QuicStreamOffset>& unacked_frame_headers_offsets(
QuicSpdyStream* stream);
static bool use_datagram_contexts(QuicSpdyStream* stream);
diff --git a/quic/test_tools/quic_test_client.cc b/quic/test_tools/quic_test_client.cc
index 02d890f..f0d5981 100644
--- a/quic/test_tools/quic_test_client.cc
+++ b/quic/test_tools/quic_test_client.cc
@@ -455,10 +455,9 @@
}
ssize_t QuicTestClient::GetOrCreateStreamAndSendRequest(
- const spdy::SpdyHeaderBlock* headers,
- absl::string_view body,
- bool fin,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
+ const spdy::SpdyHeaderBlock* headers, absl::string_view body, bool fin,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener) {
if (headers) {
QuicClientPushPromiseIndex::TryHandle* handle;
QuicAsyncStatus rv =
@@ -530,9 +529,9 @@
}
ssize_t QuicTestClient::SendData(
- const std::string& data,
- bool last_data,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
+ const std::string& data, bool last_data,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener) {
return GetOrCreateStreamAndSendRequest(nullptr, absl::string_view(data),
last_data, std::move(ack_listener));
}
@@ -898,11 +897,10 @@
}
QuicTestClient::TestClientDataToResend::TestClientDataToResend(
- std::unique_ptr<spdy::SpdyHeaderBlock> headers,
- absl::string_view body,
- bool fin,
- QuicTestClient* test_client,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener)
+ std::unique_ptr<spdy::SpdyHeaderBlock> headers, absl::string_view body,
+ bool fin, QuicTestClient* test_client,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener)
: QuicClient::QuicDataToResend(std::move(headers), body, fin),
test_client_(test_client),
ack_listener_(std::move(ack_listener)) {}
diff --git a/quic/test_tools/quic_test_client.h b/quic/test_tools/quic_test_client.h
index db97e02..b655adf 100644
--- a/quic/test_tools/quic_test_client.h
+++ b/quic/test_tools/quic_test_client.h
@@ -123,9 +123,9 @@
ssize_t SendData(const std::string& data, bool last_data);
// As above, but |delegate| will be notified when |data| is ACKed.
ssize_t SendData(
- const std::string& data,
- bool last_data,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
+ const std::string& data, bool last_data,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener);
// Clears any outstanding state and sends a simple GET of 'uri' to the
// server. Returns 0 if the request failed and no bytes were written.
@@ -262,10 +262,9 @@
// stores the request in case it needs to be resent. If |headers| is
// null, only the body will be sent on the stream.
ssize_t GetOrCreateStreamAndSendRequest(
- const spdy::SpdyHeaderBlock* headers,
- absl::string_view body,
- bool fin,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
+ const spdy::SpdyHeaderBlock* headers, absl::string_view body, bool fin,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener);
QuicRstStreamErrorCode stream_error() { return stream_error_; }
QuicErrorCode connection_error() const;
@@ -340,11 +339,10 @@
class TestClientDataToResend : public QuicClient::QuicDataToResend {
public:
TestClientDataToResend(
- std::unique_ptr<spdy::SpdyHeaderBlock> headers,
- absl::string_view body,
- bool fin,
- QuicTestClient* test_client,
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
+ std::unique_ptr<spdy::SpdyHeaderBlock> headers, absl::string_view body,
+ bool fin, QuicTestClient* test_client,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener);
~TestClientDataToResend() override;
@@ -352,7 +350,8 @@
protected:
QuicTestClient* test_client_;
- QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener_;
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ ack_listener_;
};
// PerStreamState of a stream is updated when it is closed.
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index d9bc541..82262eb 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -858,7 +858,7 @@
SSL* GetSsl() const override { return nullptr; }
private:
- QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
+ quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
CryptoFramer crypto_framer_;
};
diff --git a/quic/tools/quic_simple_server_stream_test.cc b/quic/tools/quic_simple_server_stream_test.cc
index 40b470e..411ee96 100644
--- a/quic/tools/quic_simple_server_stream_test.cc
+++ b/quic/tools/quic_simple_server_stream_test.cc
@@ -58,9 +58,10 @@
MOCK_METHOD(void, WriteHeadersMock, (bool fin), ());
MOCK_METHOD(void, WriteEarlyHintsHeadersMock, (bool fin), ());
- size_t WriteHeaders(spdy::Http2HeaderBlock header_block, bool fin,
- QuicReferenceCountedPointer<QuicAckListenerInterface>
- /*ack_listener*/) override {
+ size_t WriteHeaders(
+ spdy::Http2HeaderBlock header_block, bool fin,
+ quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
+ /*ack_listener*/) override {
if (header_block[":status"] == "103") {
WriteEarlyHintsHeadersMock(fin);
} else {
diff --git a/quic/tools/quic_toy_client.cc b/quic/tools/quic_toy_client.cc
index 7b6b760..c033fd8 100644
--- a/quic/tools/quic_toy_client.cc
+++ b/quic/tools/quic_toy_client.cc
@@ -216,7 +216,7 @@
auto proof_source = std::make_unique<DefaultClientProofSource>();
proof_source->AddCertAndKey(
{"*"},
- QuicReferenceCountedPointer<ClientProofSource::Chain>(
+ quiche::QuicheReferenceCountedPointer<ClientProofSource::Chain>(
new ClientProofSource::Chain(certs)),
std::move(*private_key));
