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));