Move quic::QuicCircularDeque to quiche::QuicheCircularDeque.

See last comment at cl/366295336 for motivation.

PiperOrigin-RevId: 370769667
Change-Id: I41907c4e7ef592fb8b7f6a298daf4e1ed15f4d2f

common/platform/api/quiche_test.h

diff --git a/common/platform/api/quiche_test.h b/common/platform/api/quiche_test.h
index b584752..1af25df 100644
--- a/common/platform/api/quiche_test.h
+++ b/common/platform/api/quiche_test.h
@@ -12,4 +12,7 @@
 template <class T>
 using QuicheTestWithParam = quiche::test::QuicheTestWithParamImpl<T>;
 
+#define EXPECT_QUICHE_DEBUG_DEATH(condition, message) \
+  EXPECT_QUICHE_DEBUG_DEATH_IMPL(condition, message)
+
 #endif  // QUICHE_COMMON_PLATFORM_API_QUICHE_TEST_H_

common/quiche_circular_deque.h

diff --git a/quic/core/quic_circular_deque.h b/common/quiche_circular_deque.h
similarity index 88%
rename from quic/core/quic_circular_deque.h
rename to common/quiche_circular_deque.h
index 44637ab..42b2232 100644
--- a/quic/core/quic_circular_deque.h
+++ b/common/quiche_circular_deque.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef QUICHE_QUIC_CORE_QUIC_CIRCULAR_DEQUE_H_
-#define QUICHE_QUIC_CORE_QUIC_CIRCULAR_DEQUE_H_
+#ifndef QUICHE_COMMON_QUICHE_CIRCULAR_DEQUE_H_
+#define QUICHE_COMMON_QUICHE_CIRCULAR_DEQUE_H_
 
 #include <algorithm>
 #include <cstddef>
@@ -13,16 +13,16 @@
 #include <ostream>
 #include <type_traits>
 
-#include "quic/platform/api/quic_export.h"
-#include "quic/platform/api/quic_logging.h"
+#include "common/platform/api/quiche_export.h"
+#include "common/platform/api/quiche_logging.h"
 
-namespace quic {
+namespace quiche {
 
-// QuicCircularDeque is a STL-style container that is similar to std deque in
+// QuicheCircularDeque is a STL-style container that is similar to std::deque in
 // API and std::vector in capacity management. The goal is to optimize a common
 // QUIC use case where we keep adding new elements to the end and removing old
 // elements from the beginning, under such scenarios, if the container's size()
-// remain relatively stable, QuicCircularDeque requires little to no memory
+// remain relatively stable, QuicheCircularDeque requires little to no memory
 // allocations or deallocations.
 //
 // The implementation, as the name suggests, uses a flat circular buffer to hold
@@ -40,12 +40,12 @@
 template <typename T,
           size_t MinCapacityIncrement = 3,
           typename Allocator = std::allocator<T>>
-class QUIC_NO_EXPORT QuicCircularDeque {
+class QUICHE_NO_EXPORT QuicheCircularDeque {
   using AllocatorTraits = std::allocator_traits<Allocator>;
 
   // Pointee is either T or const T.
   template <typename Pointee>
-  class QUIC_NO_EXPORT basic_iterator {
+  class QUICHE_NO_EXPORT basic_iterator {
     using size_type = typename AllocatorTraits::size_type;
 
    public:
@@ -159,7 +159,7 @@
     }
 
    private:
-    basic_iterator(const QuicCircularDeque* deque, size_type index)
+    basic_iterator(const QuicheCircularDeque* deque, size_type index)
         : deque_(deque), index_(index) {}
 
     void Increment() {
@@ -191,8 +191,8 @@
       return index_ + deque_->data_capacity() - deque_->begin_;
     }
 
-    friend class QuicCircularDeque;
-    const QuicCircularDeque* deque_ = nullptr;
+    friend class QuicheCircularDeque;
+    const QuicheCircularDeque* deque_ = nullptr;
     size_type index_ = 0;
   };
 
@@ -210,19 +210,19 @@
   using reverse_iterator = std::reverse_iterator<iterator>;
   using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
-  QuicCircularDeque() : QuicCircularDeque(allocator_type()) {}
-  explicit QuicCircularDeque(const allocator_type& alloc)
+  QuicheCircularDeque() : QuicheCircularDeque(allocator_type()) {}
+  explicit QuicheCircularDeque(const allocator_type& alloc)
       : allocator_and_data_(alloc) {}
 
-  QuicCircularDeque(size_type count,
-                    const T& value,
-                    const Allocator& alloc = allocator_type())
+  QuicheCircularDeque(size_type count,
+                      const T& value,
+                      const Allocator& alloc = allocator_type())
       : allocator_and_data_(alloc) {
     resize(count, value);
   }
 
-  explicit QuicCircularDeque(size_type count,
-                             const Allocator& alloc = allocator_type())
+  explicit QuicheCircularDeque(size_type count,
+                               const Allocator& alloc = allocator_type())
       : allocator_and_data_(alloc) {
     resize(count);
   }
@@ -232,25 +232,26 @@
       typename = std::enable_if_t<std::is_base_of<
           std::input_iterator_tag,
           typename std::iterator_traits<InputIt>::iterator_category>::value>>
-  QuicCircularDeque(InputIt first,
-                    InputIt last,
-                    const Allocator& alloc = allocator_type())
+  QuicheCircularDeque(InputIt first,
+                      InputIt last,
+                      const Allocator& alloc = allocator_type())
       : allocator_and_data_(alloc) {
     AssignRange(first, last);
   }
 
-  QuicCircularDeque(const QuicCircularDeque& other)
-      : QuicCircularDeque(
+  QuicheCircularDeque(const QuicheCircularDeque& other)
+      : QuicheCircularDeque(
             other,
             AllocatorTraits::select_on_container_copy_construction(
                 other.allocator_and_data_.allocator())) {}
 
-  QuicCircularDeque(const QuicCircularDeque& other, const allocator_type& alloc)
+  QuicheCircularDeque(const QuicheCircularDeque& other,
+                      const allocator_type& alloc)
       : allocator_and_data_(alloc) {
     assign(other.begin(), other.end());
   }
 
-  QuicCircularDeque(QuicCircularDeque&& other)
+  QuicheCircularDeque(QuicheCircularDeque&& other)
       : begin_(other.begin_),
         end_(other.end_),
         allocator_and_data_(std::move(other.allocator_and_data_)) {
@@ -259,16 +260,16 @@
     other.allocator_and_data_.data_capacity = 0;
   }
 
-  QuicCircularDeque(QuicCircularDeque&& other, const allocator_type& alloc)
+  QuicheCircularDeque(QuicheCircularDeque&& other, const allocator_type& alloc)
       : allocator_and_data_(alloc) {
     MoveRetainAllocator(std::move(other));
   }
 
-  QuicCircularDeque(std::initializer_list<T> init,
-                    const allocator_type& alloc = allocator_type())
-      : QuicCircularDeque(init.begin(), init.end(), alloc) {}
+  QuicheCircularDeque(std::initializer_list<T> init,
+                      const allocator_type& alloc = allocator_type())
+      : QuicheCircularDeque(init.begin(), init.end(), alloc) {}
 
-  QuicCircularDeque& operator=(const QuicCircularDeque& other) {
+  QuicheCircularDeque& operator=(const QuicheCircularDeque& other) {
     if (this == &other) {
       return *this;
     }
@@ -286,21 +287,21 @@
     return *this;
   }
 
-  QuicCircularDeque& operator=(QuicCircularDeque&& other) {
+  QuicheCircularDeque& operator=(QuicheCircularDeque&& other) {
     if (this == &other) {
       return *this;
     }
     if (AllocatorTraits::propagate_on_container_move_assignment::value) {
       // Take over the storage of "other", along with its allocator.
-      this->~QuicCircularDeque();
-      new (this) QuicCircularDeque(std::move(other));
+      this->~QuicheCircularDeque();
+      new (this) QuicheCircularDeque(std::move(other));
     } else {
       MoveRetainAllocator(std::move(other));
     }
     return *this;
   }
 
-  ~QuicCircularDeque() { DestroyAndDeallocateAll(); }
+  ~QuicheCircularDeque() { DestroyAndDeallocateAll(); }
 
   void assign(size_type count, const T& value) {
     ClearRetainCapacity();
@@ -333,7 +334,7 @@
   }
 
   const_reference at(size_type pos) const {
-    return const_cast<QuicCircularDeque*>(this)->at(pos);
+    return const_cast<QuicheCircularDeque*>(this)->at(pos);
   }
 
   reference operator[](size_type pos) { return at(pos); }
@@ -346,7 +347,7 @@
   }
 
   const_reference front() const {
-    return const_cast<QuicCircularDeque*>(this)->front();
+    return const_cast<QuicheCircularDeque*>(this)->front();
   }
 
   reference back() {
@@ -355,7 +356,7 @@
   }
 
   const_reference back() const {
-    return const_cast<QuicCircularDeque*>(this)->back();
+    return const_cast<QuicheCircularDeque*>(this)->back();
   }
 
   iterator begin() { return iterator(this, begin_); }
@@ -460,7 +461,7 @@
     return num_elements_to_pop;
   }
 
-  void swap(QuicCircularDeque& other) {
+  void swap(QuicheCircularDeque& other) {
     using std::swap;
     swap(begin_, other.begin_);
     swap(end_, other.end_);
@@ -479,7 +480,7 @@
     }
   }
 
-  friend void swap(QuicCircularDeque& lhs, QuicCircularDeque& rhs) {
+  friend void swap(QuicheCircularDeque& lhs, QuicheCircularDeque& rhs) {
     lhs.swap(rhs);
   }
 
@@ -487,18 +488,19 @@
     return allocator_and_data_.allocator();
   }
 
-  friend bool operator==(const QuicCircularDeque& lhs,
-                         const QuicCircularDeque& rhs) {
+  friend bool operator==(const QuicheCircularDeque& lhs,
+                         const QuicheCircularDeque& rhs) {
     return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
   }
 
-  friend bool operator!=(const QuicCircularDeque& lhs,
-                         const QuicCircularDeque& rhs) {
+  friend bool operator!=(const QuicheCircularDeque& lhs,
+                         const QuicheCircularDeque& rhs) {
     return !(lhs == rhs);
   }
 
-  friend QUIC_NO_EXPORT std::ostream& operator<<(std::ostream& os,
-                                                 const QuicCircularDeque& dq) {
+  friend QUICHE_NO_EXPORT std::ostream& operator<<(
+      std::ostream& os,
+      const QuicheCircularDeque& dq) {
     os << "{";
     for (size_type pos = 0; pos != dq.size(); ++pos) {
       if (pos != 0) {
@@ -511,7 +513,7 @@
   }
 
  private:
-  void MoveRetainAllocator(QuicCircularDeque&& other) {
+  void MoveRetainAllocator(QuicheCircularDeque&& other) {
     if (get_allocator() == other.get_allocator()) {
       // Take over the storage of "other", with which we share an allocator.
       DestroyAndDeallocateAll();
@@ -752,6 +754,6 @@
   AllocatorAndData allocator_and_data_;
 };
 
-}  // namespace quic
+}  // namespace quiche
 
-#endif  // QUICHE_QUIC_CORE_QUIC_CIRCULAR_DEQUE_H_
+#endif  // QUICHE_COMMON_QUICHE_CIRCULAR_DEQUE_H_

common/quiche_circular_deque_test.cc

diff --git a/quic/core/quic_circular_deque_test.cc b/common/quiche_circular_deque_test.cc
similarity index 80%
rename from quic/core/quic_circular_deque_test.cc
rename to common/quiche_circular_deque_test.cc
index 25aa78e..0b38ab7 100644
--- a/quic/core/quic_circular_deque_test.cc
+++ b/common/quiche_circular_deque_test.cc
@@ -2,19 +2,19 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quic/core/quic_circular_deque.h"
+#include "common/quiche_circular_deque.h"
 
 #include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <type_traits>
 
-#include "quic/platform/api/quic_logging.h"
-#include "quic/platform/api/quic_test.h"
+#include "common/platform/api/quiche_logging.h"
+#include "common/platform/api/quiche_test.h"
 
 using testing::ElementsAre;
 
-namespace quic {
+namespace quiche {
 namespace test {
 namespace {
 
@@ -106,10 +106,10 @@
   }
 }
 
-class QuicCircularDequeTest : public QuicTest {};
+class QuicheCircularDequeTest : public QuicheTest {};
 
-TEST_F(QuicCircularDequeTest, Empty) {
-  QuicCircularDeque<int> dq;
+TEST_F(QuicheCircularDequeTest, Empty) {
+  QuicheCircularDeque<int> dq;
   EXPECT_TRUE(dq.empty());
   EXPECT_EQ(0u, dq.size());
   dq.clear();
@@ -122,68 +122,69 @@
   EXPECT_TRUE(dq.empty());
   EXPECT_EQ(0u, dq.size());
 
-  EXPECT_QUIC_DEBUG_DEATH(dq.front(), "");
-  EXPECT_QUIC_DEBUG_DEATH(dq.back(), "");
-  EXPECT_QUIC_DEBUG_DEATH(dq.at(0), "");
-  EXPECT_QUIC_DEBUG_DEATH(dq[0], "");
+  EXPECT_QUICHE_DEBUG_DEATH(dq.front(), "");
+  EXPECT_QUICHE_DEBUG_DEATH(dq.back(), "");
+  EXPECT_QUICHE_DEBUG_DEATH(dq.at(0), "");
+  EXPECT_QUICHE_DEBUG_DEATH(dq[0], "");
 }
 
-TEST_F(QuicCircularDequeTest, Constructor) {
-  QuicCircularDeque<int> dq;
+TEST_F(QuicheCircularDequeTest, Constructor) {
+  QuicheCircularDeque<int> dq;
   EXPECT_TRUE(dq.empty());
 
   std::allocator<int> alloc;
-  QuicCircularDeque<int> dq1(alloc);
+  QuicheCircularDeque<int> dq1(alloc);
   EXPECT_TRUE(dq1.empty());
 
-  QuicCircularDeque<int> dq2(8, 100, alloc);
+  QuicheCircularDeque<int> dq2(8, 100, alloc);
   EXPECT_THAT(dq2, ElementsAre(100, 100, 100, 100, 100, 100, 100, 100));
 
-  QuicCircularDeque<int> dq3(5, alloc);
+  QuicheCircularDeque<int> dq3(5, alloc);
   EXPECT_THAT(dq3, ElementsAre(0, 0, 0, 0, 0));
 
-  QuicCircularDeque<int> dq4_rand_iter(dq3.begin(), dq3.end(), alloc);
+  QuicheCircularDeque<int> dq4_rand_iter(dq3.begin(), dq3.end(), alloc);
   EXPECT_THAT(dq4_rand_iter, ElementsAre(0, 0, 0, 0, 0));
   EXPECT_EQ(dq4_rand_iter, dq3);
 
   std::list<int> dq4_src = {4, 4, 4, 4};
-  QuicCircularDeque<int> dq4_bidi_iter(dq4_src.begin(), dq4_src.end());
+  QuicheCircularDeque<int> dq4_bidi_iter(dq4_src.begin(), dq4_src.end());
   EXPECT_THAT(dq4_bidi_iter, ElementsAre(4, 4, 4, 4));
 
-  QuicCircularDeque<int> dq5(dq4_bidi_iter);
+  QuicheCircularDeque<int> dq5(dq4_bidi_iter);
   EXPECT_THAT(dq5, ElementsAre(4, 4, 4, 4));
   EXPECT_EQ(dq5, dq4_bidi_iter);
 
-  QuicCircularDeque<int> dq6(dq5, alloc);
+  QuicheCircularDeque<int> dq6(dq5, alloc);
   EXPECT_THAT(dq6, ElementsAre(4, 4, 4, 4));
   EXPECT_EQ(dq6, dq5);
 
-  QuicCircularDeque<int> dq7(std::move(*&dq6));
+  QuicheCircularDeque<int> dq7(std::move(*&dq6));
   EXPECT_THAT(dq7, ElementsAre(4, 4, 4, 4));
   EXPECT_TRUE(dq6.empty());
 
-  QuicCircularDeque<int> dq8_equal_allocator(std::move(*&dq7), alloc);
+  QuicheCircularDeque<int> dq8_equal_allocator(std::move(*&dq7), alloc);
   EXPECT_THAT(dq8_equal_allocator, ElementsAre(4, 4, 4, 4));
   EXPECT_TRUE(dq7.empty());
 
-  QuicCircularDeque<int, 3, CountingAllocator<int>> dq8_temp = {5, 6, 7, 8, 9};
-  QuicCircularDeque<int, 3, CountingAllocator<int>> dq8_unequal_allocator(
+  QuicheCircularDeque<int, 3, CountingAllocator<int>> dq8_temp = {5, 6, 7, 8,
+                                                                  9};
+  QuicheCircularDeque<int, 3, CountingAllocator<int>> dq8_unequal_allocator(
       std::move(*&dq8_temp), CountingAllocator<int>());
   EXPECT_THAT(dq8_unequal_allocator, ElementsAre(5, 6, 7, 8, 9));
   EXPECT_TRUE(dq8_temp.empty());
 
-  QuicCircularDeque<int> dq9({3, 4, 5, 6, 7}, alloc);
+  QuicheCircularDeque<int> dq9({3, 4, 5, 6, 7}, alloc);
   EXPECT_THAT(dq9, ElementsAre(3, 4, 5, 6, 7));
 }
 
-TEST_F(QuicCircularDequeTest, Assign) {
+TEST_F(QuicheCircularDequeTest, Assign) {
   // assign()
-  QuicCircularDeque<int, 3, CountingAllocator<int>> dq;
+  QuicheCircularDeque<int, 3, CountingAllocator<int>> dq;
   dq.assign(7, 1);
   EXPECT_THAT(dq, ElementsAre(1, 1, 1, 1, 1, 1, 1));
   EXPECT_EQ(1u, dq.get_allocator().allocate_count());
 
-  QuicCircularDeque<int, 3, CountingAllocator<int>> dq2;
+  QuicheCircularDeque<int, 3, CountingAllocator<int>> dq2;
   dq2.assign(dq.begin(), dq.end());
   EXPECT_THAT(dq2, ElementsAre(1, 1, 1, 1, 1, 1, 1));
   EXPECT_EQ(1u, dq2.get_allocator().allocate_count());
@@ -194,7 +195,7 @@
 
   // Assign from a non random access iterator.
   std::list<int> dq3_src = {3, 3, 3, 3, 3};
-  QuicCircularDeque<int, 3, CountingAllocator<int>> dq3;
+  QuicheCircularDeque<int, 3, CountingAllocator<int>> dq3;
   dq3.assign(dq3_src.begin(), dq3_src.end());
   EXPECT_THAT(dq3, ElementsAre(3, 3, 3, 3, 3));
   EXPECT_LT(1u, dq3.get_allocator().allocate_count());
@@ -203,7 +204,7 @@
   dq3 = *&dq3;
   EXPECT_THAT(dq3, ElementsAre(3, 3, 3, 3, 3));
 
-  QuicCircularDeque<
+  QuicheCircularDeque<
       int, 3,
       ConfigurableAllocator<int,
                             /*propagate_on_copy_assignment=*/std::true_type,
@@ -215,7 +216,7 @@
   dq5 = dq4;
   EXPECT_THAT(dq5, ElementsAre(3, 3, 3, 3, 3));
 
-  QuicCircularDeque<
+  QuicheCircularDeque<
       int, 3,
       ConfigurableAllocator<int,
                             /*propagate_on_copy_assignment=*/std::false_type,
@@ -238,7 +239,7 @@
   EXPECT_THAT(dq8, ElementsAre(3, 3, 3, 3, 3));
   EXPECT_TRUE(dq3.empty());
 
-  QuicCircularDeque<
+  QuicheCircularDeque<
       int, 3,
       ConfigurableAllocator<int,
                             /*propagate_on_copy_assignment=*/std::true_type,
@@ -252,7 +253,7 @@
   EXPECT_THAT(dq9, ElementsAre(2, 2, 2, 2, 2, 2));
   EXPECT_TRUE(dq10.empty());
 
-  QuicCircularDeque<
+  QuicheCircularDeque<
       int, 3,
       ConfigurableAllocator<int,
                             /*propagate_on_copy_assignment=*/std::true_type,
@@ -267,13 +268,13 @@
   EXPECT_TRUE(dq12.empty());
 }
 
-TEST_F(QuicCircularDequeTest, Access) {
+TEST_F(QuicheCircularDequeTest, Access) {
   // at()
   // operator[]
   // front()
   // back()
 
-  QuicCircularDeque<int, 3, CountingAllocator<int>> dq;
+  QuicheCircularDeque<int, 3, CountingAllocator<int>> dq;
   dq.push_back(10);
   EXPECT_EQ(dq.front(), 10);
   EXPECT_EQ(dq.back(), 10);
@@ -369,15 +370,15 @@
   EXPECT_EQ(1u, dq.get_allocator().allocate_count());
 }
 
-TEST_F(QuicCircularDequeTest, Iterate) {
-  QuicCircularDeque<int> dq;
+TEST_F(QuicheCircularDequeTest, Iterate) {
+  QuicheCircularDeque<int> dq;
   EXPECT_EQ(dq.begin(), dq.end());
   EXPECT_EQ(dq.cbegin(), dq.cend());
   EXPECT_EQ(dq.rbegin(), dq.rend());
   EXPECT_EQ(dq.crbegin(), dq.crend());
 
   dq.emplace_back(2);
-  QuicCircularDeque<int>::const_iterator citer = dq.begin();
+  QuicheCircularDeque<int>::const_iterator citer = dq.begin();
   EXPECT_NE(citer, dq.end());
   EXPECT_EQ(*citer, 2);
   ++citer;
@@ -389,7 +390,7 @@
   EXPECT_EQ(*dq.crbegin(), 2);
 
   dq.emplace_front(1);
-  QuicCircularDeque<int>::const_reverse_iterator criter = dq.rbegin();
+  QuicheCircularDeque<int>::const_reverse_iterator criter = dq.rbegin();
   EXPECT_NE(criter, dq.rend());
   EXPECT_EQ(*criter, 2);
   ++criter;
@@ -407,42 +408,43 @@
 
   // Forward iterate.
   int expected_value = 1;
-  for (QuicCircularDeque<int>::iterator it = dq.begin(); it != dq.end(); ++it) {
+  for (QuicheCircularDeque<int>::iterator it = dq.begin(); it != dq.end();
+       ++it) {
     EXPECT_EQ(expected_value++, *it);
   }
 
   expected_value = 1;
-  for (QuicCircularDeque<int>::const_iterator it = dq.cbegin(); it != dq.cend();
-       ++it) {
+  for (QuicheCircularDeque<int>::const_iterator it = dq.cbegin();
+       it != dq.cend(); ++it) {
     EXPECT_EQ(expected_value++, *it);
   }
 
   // Reverse iterate.
   expected_value = 3;
-  for (QuicCircularDeque<int>::reverse_iterator it = dq.rbegin();
+  for (QuicheCircularDeque<int>::reverse_iterator it = dq.rbegin();
        it != dq.rend(); ++it) {
     EXPECT_EQ(expected_value--, *it);
   }
 
   expected_value = 3;
-  for (QuicCircularDeque<int>::const_reverse_iterator it = dq.crbegin();
+  for (QuicheCircularDeque<int>::const_reverse_iterator it = dq.crbegin();
        it != dq.crend(); ++it) {
     EXPECT_EQ(expected_value--, *it);
   }
 }
 
-TEST_F(QuicCircularDequeTest, Iterator) {
+TEST_F(QuicheCircularDequeTest, Iterator) {
   // Default constructed iterators of the same type compare equal.
-  EXPECT_EQ(QuicCircularDeque<int>::iterator(),
-            QuicCircularDeque<int>::iterator());
-  EXPECT_EQ(QuicCircularDeque<int>::const_iterator(),
-            QuicCircularDeque<int>::const_iterator());
-  EXPECT_EQ(QuicCircularDeque<int>::reverse_iterator(),
-            QuicCircularDeque<int>::reverse_iterator());
-  EXPECT_EQ(QuicCircularDeque<int>::const_reverse_iterator(),
-            QuicCircularDeque<int>::const_reverse_iterator());
+  EXPECT_EQ(QuicheCircularDeque<int>::iterator(),
+            QuicheCircularDeque<int>::iterator());
+  EXPECT_EQ(QuicheCircularDeque<int>::const_iterator(),
+            QuicheCircularDeque<int>::const_iterator());
+  EXPECT_EQ(QuicheCircularDeque<int>::reverse_iterator(),
+            QuicheCircularDeque<int>::reverse_iterator());
+  EXPECT_EQ(QuicheCircularDeque<int>::const_reverse_iterator(),
+            QuicheCircularDeque<int>::const_reverse_iterator());
 
-  QuicCircularDeque<QuicCircularDeque<int>, 3> dqdq = {
+  QuicheCircularDeque<QuicheCircularDeque<int>, 3> dqdq = {
       {1, 2}, {10, 20, 30}, {100, 200, 300, 400}};
 
   // iter points to {1, 2}
@@ -494,8 +496,8 @@
   }
 }
 
-TEST_F(QuicCircularDequeTest, Resize) {
-  QuicCircularDeque<int, 3, CountingAllocator<int>> dq;
+TEST_F(QuicheCircularDequeTest, Resize) {
+  QuicheCircularDeque<int, 3, CountingAllocator<int>> dq;
   dq.resize(8);
   EXPECT_THAT(dq, ElementsAre(0, 0, 0, 0, 0, 0, 0, 0));
   EXPECT_EQ(1u, dq.get_allocator().allocate_count());
@@ -503,7 +505,7 @@
   dq.resize(10, 5);
   EXPECT_THAT(dq, ElementsAre(0, 0, 0, 0, 0, 0, 0, 0, 5, 5));
 
-  QuicCircularDeque<int, 3, CountingAllocator<int>> dq2 = dq;
+  QuicheCircularDeque<int, 3, CountingAllocator<int>> dq2 = dq;
 
   for (size_t new_size = dq.size(); new_size != 0; --new_size) {
     dq.resize(new_size);
@@ -575,7 +577,7 @@
 };
 }  // namespace
 
-TEST_F(QuicCircularDequeTest, RelocateNonTriviallyCopyable) {
+TEST_F(QuicheCircularDequeTest, RelocateNonTriviallyCopyable) {
   // When relocating non-trivially-copyable objects:
   // - Move constructor is preferred, if available.
   // - Copy constructor is used otherwise.
@@ -585,8 +587,8 @@
     using MoveConstructible = std::unique_ptr<Foo>;
     ASSERT_FALSE(std::is_trivially_copyable<MoveConstructible>::value);
     ASSERT_TRUE(std::is_move_constructible<MoveConstructible>::value);
-    QuicCircularDeque<MoveConstructible, 3,
-                      CountingAllocator<MoveConstructible>>
+    QuicheCircularDeque<MoveConstructible, 3,
+                        CountingAllocator<MoveConstructible>>
         dq1;
     dq1.resize(3);
     EXPECT_EQ(dq1.size(), dq1.capacity());
@@ -606,8 +608,8 @@
     using NonMoveConstructible = Foo;
     ASSERT_FALSE(std::is_trivially_copyable<NonMoveConstructible>::value);
     ASSERT_FALSE(std::is_move_constructible<NonMoveConstructible>::value);
-    QuicCircularDeque<NonMoveConstructible, 3,
-                      CountingAllocator<NonMoveConstructible>>
+    QuicheCircularDeque<NonMoveConstructible, 3,
+                        CountingAllocator<NonMoveConstructible>>
         dq2;
     dq2.resize(3);
     EXPECT_EQ(dq2.size(), dq2.capacity());
@@ -623,49 +625,49 @@
   }
 }
 
-TEST_F(QuicCircularDequeTest, PushPop) {
+TEST_F(QuicheCircularDequeTest, PushPop) {
   // (push|pop|emplace)_(back|front)
 
   {
-    QuicCircularDeque<Foo, 4, CountingAllocator<Foo>> dq(4);
+    QuicheCircularDeque<Foo, 4, CountingAllocator<Foo>> dq(4);
     for (size_t i = 0; i < dq.size(); ++i) {
       dq[i].Set(i + 1);
     }
-    QUIC_LOG(INFO) << "dq initialized to " << dq;
+    QUICHE_LOG(INFO) << "dq initialized to " << dq;
     EXPECT_THAT(dq, ElementsAre(Foo(1), Foo(2), Foo(3), Foo(4)));
 
     ShiftLeft(&dq, false);
-    QUIC_LOG(INFO) << "shift left once : " << dq;
+    QUICHE_LOG(INFO) << "shift left once : " << dq;
     EXPECT_THAT(dq, ElementsAre(Foo(2), Foo(3), Foo(4), Foo(1)));
 
     ShiftLeft(&dq, true);
-    QUIC_LOG(INFO) << "shift left twice: " << dq;
+    QUICHE_LOG(INFO) << "shift left twice: " << dq;
     EXPECT_THAT(dq, ElementsAre(Foo(3), Foo(4), Foo(1), Foo(2)));
     ASSERT_GT(&dq.front(), &dq.back());
     // dq destructs with wrapped data.
   }
 
   {
-    QuicCircularDeque<Foo, 4, CountingAllocator<Foo>> dq1(4);
+    QuicheCircularDeque<Foo, 4, CountingAllocator<Foo>> dq1(4);
     for (size_t i = 0; i < dq1.size(); ++i) {
       dq1[i].Set(i + 1);
     }
-    QUIC_LOG(INFO) << "dq1 initialized to " << dq1;
+    QUICHE_LOG(INFO) << "dq1 initialized to " << dq1;
     EXPECT_THAT(dq1, ElementsAre(Foo(1), Foo(2), Foo(3), Foo(4)));
 
     ShiftRight(&dq1, false);
-    QUIC_LOG(INFO) << "shift right once : " << dq1;
+    QUICHE_LOG(INFO) << "shift right once : " << dq1;
     EXPECT_THAT(dq1, ElementsAre(Foo(4), Foo(1), Foo(2), Foo(3)));
 
     ShiftRight(&dq1, true);
-    QUIC_LOG(INFO) << "shift right twice: " << dq1;
+    QUICHE_LOG(INFO) << "shift right twice: " << dq1;
     EXPECT_THAT(dq1, ElementsAre(Foo(3), Foo(4), Foo(1), Foo(2)));
     ASSERT_GT(&dq1.front(), &dq1.back());
     // dq1 destructs with wrapped data.
   }
 
   {  // Pop n elements from front.
-    QuicCircularDeque<Foo, 4, CountingAllocator<Foo>> dq2(5);
+    QuicheCircularDeque<Foo, 4, CountingAllocator<Foo>> dq2(5);
     for (size_t i = 0; i < dq2.size(); ++i) {
       dq2[i].Set(i + 1);
     }
@@ -679,7 +681,7 @@
   }
 
   {  // Pop n elements from back.
-    QuicCircularDeque<Foo, 4, CountingAllocator<Foo>> dq3(6);
+    QuicheCircularDeque<Foo, 4, CountingAllocator<Foo>> dq3(6);
     for (size_t i = 0; i < dq3.size(); ++i) {
       dq3[i].Set(i + 1);
     }
@@ -700,11 +702,11 @@
   }
 }
 
-TEST_F(QuicCircularDequeTest, Allocation) {
+TEST_F(QuicheCircularDequeTest, Allocation) {
   CountingAllocator<int> alloc;
 
   {
-    QuicCircularDeque<int, 3, CountingAllocator<int>> dq(alloc);
+    QuicheCircularDeque<int, 3, CountingAllocator<int>> dq(alloc);
     EXPECT_EQ(alloc, dq.get_allocator());
     EXPECT_EQ(0u, dq.size());
     EXPECT_EQ(0u, dq.capacity());
@@ -734,13 +736,13 @@
 
 }  // namespace
 }  // namespace test
-}  // namespace quic
+}  // namespace quiche
 
-// Use a non-quic namespace to make sure swap can be used via ADL.
+// Use a non-quiche namespace to make sure swap can be used via ADL.
 namespace {
 
 template <typename T>
-using SwappableAllocator = quic::test::ConfigurableAllocator<
+using SwappableAllocator = quiche::test::ConfigurableAllocator<
     T,
     /*propagate_on_copy_assignment=*/std::true_type,
     /*propagate_on_move_assignment=*/std::true_type,
@@ -748,7 +750,7 @@
     /*equality_result=*/true>;
 
 template <typename T>
-using UnswappableEqualAllocator = quic::test::ConfigurableAllocator<
+using UnswappableEqualAllocator = quiche::test::ConfigurableAllocator<
     T,
     /*propagate_on_copy_assignment=*/std::true_type,
     /*propagate_on_move_assignment=*/std::true_type,
@@ -756,19 +758,19 @@
     /*equality_result=*/true>;
 
 template <typename T>
-using UnswappableUnequalAllocator = quic::test::ConfigurableAllocator<
+using UnswappableUnequalAllocator = quiche::test::ConfigurableAllocator<
     T,
     /*propagate_on_copy_assignment=*/std::true_type,
     /*propagate_on_move_assignment=*/std::true_type,
     /*propagate_on_swap=*/std::false_type,
     /*equality_result=*/false>;
 
-using quic::test::QuicCircularDequeTest;
+using quiche::test::QuicheCircularDequeTest;
 
-TEST_F(QuicCircularDequeTest, Swap) {
+TEST_F(QuicheCircularDequeTest, Swap) {
   using std::swap;
 
-  quic::QuicCircularDeque<int64_t, 3, SwappableAllocator<int64_t>> dq1, dq2;
+  quiche::QuicheCircularDeque<int64_t, 3, SwappableAllocator<int64_t>> dq1, dq2;
   dq1.push_back(10);
   dq1.push_back(11);
   dq2.push_back(20);
@@ -776,14 +778,16 @@
   EXPECT_THAT(dq1, ElementsAre(20));
   EXPECT_THAT(dq2, ElementsAre(10, 11));
 
-  quic::QuicCircularDeque<char, 3, UnswappableEqualAllocator<char>> dq3, dq4;
+  quiche::QuicheCircularDeque<char, 3, UnswappableEqualAllocator<char>> dq3,
+      dq4;
   dq3 = {1, 2, 3, 4, 5};
   dq4 = {6, 7, 8, 9, 0};
   swap(dq3, dq4);
   EXPECT_THAT(dq3, ElementsAre(6, 7, 8, 9, 0));
   EXPECT_THAT(dq4, ElementsAre(1, 2, 3, 4, 5));
 
-  quic::QuicCircularDeque<int, 3, UnswappableUnequalAllocator<int>> dq5, dq6;
+  quiche::QuicheCircularDeque<int, 3, UnswappableUnequalAllocator<int>> dq5,
+      dq6;
   dq6.push_front(4);
 
   // Using UnswappableUnequalAllocator is ok as long as swap is not called.
@@ -791,6 +795,6 @@
   EXPECT_THAT(dq5, ElementsAre(4));
 
   // Undefined behavior to swap between two containers with unequal allocators.
-  EXPECT_QUIC_DEBUG_DEATH(swap(dq5, dq6), "Undefined swap behavior");
+  EXPECT_QUICHE_DEBUG_DEATH(swap(dq5, dq6), "Undefined swap behavior");
 }
 }  // namespace

http2/hpack/decoder/hpack_decoder_tables.h

diff --git a/http2/hpack/decoder/hpack_decoder_tables.h b/http2/hpack/decoder/hpack_decoder_tables.h
index f75916d..ef5b3d2 100644
--- a/http2/hpack/decoder/hpack_decoder_tables.h
+++ b/http2/hpack/decoder/hpack_decoder_tables.h
@@ -25,8 +25,8 @@
 #include <vector>
 
 #include "http2/http2_constants.h"
-#include "quic/core/quic_circular_deque.h"
 #include "common/platform/api/quiche_export.h"
+#include "common/quiche_circular_deque.h"
 
 namespace http2 {
 namespace test {
@@ -107,7 +107,7 @@
   // Removes the oldest dynamic table entry.
   void RemoveLastEntry();
 
-  quic::QuicCircularDeque<HpackStringPair> table_;
+  quiche::QuicheCircularDeque<HpackStringPair> table_;
 
   // The last received DynamicTableSizeUpdate value, initialized to
   // SETTINGS_HEADER_TABLE_SIZE.

quic/core/batch_writer/quic_batch_writer_base.h

diff --git a/quic/core/batch_writer/quic_batch_writer_base.h b/quic/core/batch_writer/quic_batch_writer_base.h
index ff924d0..e7d1f12 100644
--- a/quic/core/batch_writer/quic_batch_writer_base.h
+++ b/quic/core/batch_writer/quic_batch_writer_base.h
@@ -60,7 +60,7 @@
   const QuicBatchWriterBuffer& batch_buffer() const { return *batch_buffer_; }
   QuicBatchWriterBuffer& batch_buffer() { return *batch_buffer_; }
 
-  const QuicCircularDeque<BufferedWrite>& buffered_writes() const {
+  const quiche::QuicheCircularDeque<BufferedWrite>& buffered_writes() const {
     return batch_buffer_->buffered_writes();
   }
 

quic/core/batch_writer/quic_batch_writer_buffer.h

diff --git a/quic/core/batch_writer/quic_batch_writer_buffer.h b/quic/core/batch_writer/quic_batch_writer_buffer.h
index 007c283..4faa3cb 100644
--- a/quic/core/batch_writer/quic_batch_writer_buffer.h
+++ b/quic/core/batch_writer/quic_batch_writer_buffer.h
@@ -6,11 +6,11 @@
 #define QUICHE_QUIC_PLATFORM_IMPL_BATCH_WRITER_QUIC_BATCH_WRITER_BUFFER_H_
 
 #include "absl/base/optimization.h"
-#include "quic/core/quic_circular_deque.h"
 #include "quic/core/quic_linux_socket_utils.h"
 #include "quic/core/quic_packet_writer.h"
 #include "quic/platform/api/quic_ip_address.h"
 #include "quic/platform/api/quic_socket_address.h"
+#include "common/quiche_circular_deque.h"
 
 namespace quic {
 
@@ -61,7 +61,7 @@
   };
   PopResult PopBufferedWrite(int32_t num_buffered_writes);
 
-  const QuicCircularDeque<BufferedWrite>& buffered_writes() const {
+  const quiche::QuicheCircularDeque<BufferedWrite>& buffered_writes() const {
     return buffered_writes_;
   }
 
@@ -87,7 +87,7 @@
   bool Invariants() const;
   const char* buffer_end() const { return buffer_ + sizeof(buffer_); }
   ABSL_CACHELINE_ALIGNED char buffer_[kBufferSize];
-  QuicCircularDeque<BufferedWrite> buffered_writes_;
+  quiche::QuicheCircularDeque<BufferedWrite> buffered_writes_;
 };
 
 }  // namespace quic

quic/core/congestion_control/bandwidth_sampler.h

diff --git a/quic/core/congestion_control/bandwidth_sampler.h b/quic/core/congestion_control/bandwidth_sampler.h
index 7a34097..6738f49 100644
--- a/quic/core/congestion_control/bandwidth_sampler.h
+++ b/quic/core/congestion_control/bandwidth_sampler.h
@@ -9,13 +9,13 @@
 #include "quic/core/congestion_control/windowed_filter.h"
 #include "quic/core/packet_number_indexed_queue.h"
 #include "quic/core/quic_bandwidth.h"
-#include "quic/core/quic_circular_deque.h"
 #include "quic/core/quic_packets.h"
 #include "quic/core/quic_time.h"
 #include "quic/core/quic_types.h"
 #include "quic/core/quic_unacked_packet_map.h"
 #include "quic/platform/api/quic_export.h"
 #include "quic/platform/api/quic_flags.h"
+#include "common/quiche_circular_deque.h"
 
 namespace quic {
 
@@ -540,7 +540,7 @@
   PacketNumberIndexedQueue<ConnectionStateOnSentPacket> connection_state_map_;
 
   RecentAckPoints recent_ack_points_;
-  QuicCircularDeque<AckPoint> a0_candidates_;
+  quiche::QuicheCircularDeque<AckPoint> a0_candidates_;
 
   // Maximum number of tracked packets.
   const QuicPacketCount max_tracked_packets_;

quic/core/http/quic_header_list.h

diff --git a/quic/core/http/quic_header_list.h b/quic/core/http/quic_header_list.h
index 9ddf6de..01c861d 100644
--- a/quic/core/http/quic_header_list.h
+++ b/quic/core/http/quic_header_list.h
@@ -11,9 +11,9 @@
 #include <utility>
 
 #include "absl/strings/string_view.h"
-#include "quic/core/quic_circular_deque.h"
 #include "quic/platform/api/quic_bug_tracker.h"
 #include "quic/platform/api/quic_export.h"
+#include "common/quiche_circular_deque.h"
 #include "spdy/core/spdy_header_block.h"
 #include "spdy/core/spdy_headers_handler_interface.h"
 
@@ -23,7 +23,8 @@
 class QUIC_EXPORT_PRIVATE QuicHeaderList
     : public spdy::SpdyHeadersHandlerInterface {
  public:
-  using ListType = QuicCircularDeque<std::pair<std::string, std::string>>;
+  using ListType =
+      quiche::QuicheCircularDeque<std::pair<std::string, std::string>>;
   using value_type = ListType::value_type;
   using const_iterator = ListType::const_iterator;
 
@@ -59,7 +60,7 @@
   std::string DebugString() const;
 
  private:
-  QuicCircularDeque<std::pair<std::string, std::string>> header_list_;
+  quiche::QuicheCircularDeque<std::pair<std::string, std::string>> header_list_;
 
   // The limit on the size of the header list (defined by spec as name + value +
   // overhead for each header field). Headers over this limit will not be

quic/core/http/quic_headers_stream.h

diff --git a/quic/core/http/quic_headers_stream.h b/quic/core/http/quic_headers_stream.h
index ae9e2af..153575b 100644
--- a/quic/core/http/quic_headers_stream.h
+++ b/quic/core/http/quic_headers_stream.h
@@ -91,7 +91,7 @@
   QuicSpdySession* spdy_session_;
 
   // Headers that have not been fully acked.
-  QuicCircularDeque<CompressedHeaderInfo> unacked_headers_;
+  quiche::QuicheCircularDeque<CompressedHeaderInfo> unacked_headers_;
 };
 
 }  // namespace quic

quic/core/http/quic_spdy_session.h

diff --git a/quic/core/http/quic_spdy_session.h b/quic/core/http/quic_spdy_session.h
index 823bb2e..214d1da 100644
--- a/quic/core/http/quic_spdy_session.h
+++ b/quic/core/http/quic_spdy_session.h
@@ -26,13 +26,13 @@
 #include "quic/core/qpack/qpack_encoder_stream_sender.h"
 #include "quic/core/qpack/qpack_receive_stream.h"
 #include "quic/core/qpack/qpack_send_stream.h"
-#include "quic/core/quic_circular_deque.h"
 #include "quic/core/quic_session.h"
 #include "quic/core/quic_time.h"
 #include "quic/core/quic_types.h"
 #include "quic/core/quic_versions.h"
 #include "quic/platform/api/quic_containers.h"
 #include "quic/platform/api/quic_export.h"
+#include "common/quiche_circular_deque.h"
 #include "spdy/core/http2_frame_decoder_adapter.h"
 
 namespace quic {

quic/core/http/quic_spdy_stream_body_manager.h

diff --git a/quic/core/http/quic_spdy_stream_body_manager.h b/quic/core/http/quic_spdy_stream_body_manager.h
index 7b2d9f1..f34801a 100644
--- a/quic/core/http/quic_spdy_stream_body_manager.h
+++ b/quic/core/http/quic_spdy_stream_body_manager.h
@@ -7,11 +7,11 @@
 
 #include "absl/base/attributes.h"
 #include "absl/strings/string_view.h"
-#include "quic/core/quic_circular_deque.h"
 #include "quic/core/quic_constants.h"
 #include "quic/platform/api/quic_bug_tracker.h"
 #include "quic/platform/api/quic_export.h"
 #include "quic/platform/api/quic_iovec.h"
+#include "common/quiche_circular_deque.h"
 
 namespace quic {
 
@@ -84,7 +84,7 @@
     QuicByteCount trailing_non_body_byte_count;
   };
   // Queue of body fragments and trailing non-body byte counts.
-  QuicCircularDeque<Fragment> fragments_;
+  quiche::QuicheCircularDeque<Fragment> fragments_;
   // Total body bytes received.
   QuicByteCount total_body_bytes_received_;
 };

quic/core/http/web_transport_http3.h

diff --git a/quic/core/http/web_transport_http3.h b/quic/core/http/web_transport_http3.h
index 0c91c2b..667256e 100644
--- a/quic/core/http/web_transport_http3.h
+++ b/quic/core/http/web_transport_http3.h
@@ -75,8 +75,8 @@
   bool ready_ = false;
   std::unique_ptr<WebTransportVisitor> visitor_;
   absl::flat_hash_set<QuicStreamId> streams_;
-  QuicCircularDeque<QuicStreamId> incoming_bidirectional_streams_;
-  QuicCircularDeque<QuicStreamId> incoming_unidirectional_streams_;
+  quiche::QuicheCircularDeque<QuicStreamId> incoming_bidirectional_streams_;
+  quiche::QuicheCircularDeque<QuicStreamId> incoming_unidirectional_streams_;
 };
 
 class QUIC_EXPORT_PRIVATE WebTransportHttp3UnidirectionalStream

quic/core/packet_number_indexed_queue.h

diff --git a/quic/core/packet_number_indexed_queue.h b/quic/core/packet_number_indexed_queue.h
index b839160..8e80c7d 100644
--- a/quic/core/packet_number_indexed_queue.h
+++ b/quic/core/packet_number_indexed_queue.h
@@ -5,11 +5,11 @@
 #ifndef QUICHE_QUIC_CORE_PACKET_NUMBER_INDEXED_QUEUE_H_
 #define QUICHE_QUIC_CORE_PACKET_NUMBER_INDEXED_QUEUE_H_
 
-#include "quic/core/quic_circular_deque.h"
 #include "quic/core/quic_constants.h"
 #include "quic/core/quic_packet_number.h"
 #include "quic/core/quic_types.h"
 #include "quic/platform/api/quic_bug_tracker.h"
+#include "common/quiche_circular_deque.h"
 
 namespace quic {
 
@@ -115,7 +115,7 @@
     return const_cast<EntryWrapper*>(const_this->GetEntryWrapper(offset));
   }
 
-  QuicCircularDeque<EntryWrapper> entries_;
+  quiche::QuicheCircularDeque<EntryWrapper> entries_;
   // NOTE(wub): When --quic_bw_sampler_remove_packets_once_per_congestion_event
   // is enabled, |number_of_present_entries_| only represents number of holes,
   // which does not include number of acked or lost packets.

quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc

diff --git a/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc b/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc
index 6c3e351..b4ed2ef 100644
--- a/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc
+++ b/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc
@@ -15,11 +15,11 @@
 #include "quic/core/qpack/qpack_encoder.h"
 #include "quic/core/qpack/qpack_stream_sender_delegate.h"
 #include "quic/core/qpack/value_splitting_header_list.h"
-#include "quic/core/quic_circular_deque.h"
 #include "quic/core/quic_error_codes.h"
 #include "quic/platform/api/quic_fuzzed_data_provider.h"
 #include "quic/test_tools/qpack/qpack_decoder_test_utils.h"
 #include "quic/test_tools/qpack/qpack_encoder_peer.h"
+#include "common/quiche_circular_deque.h"
 #include "spdy/core/spdy_header_block.h"
 
 namespace quic {
@@ -437,7 +437,7 @@
  private:
   QpackStreamReceiver* const receiver_;
   QuicFuzzedDataProvider* const provider_;
-  QuicCircularDeque<std::string> stream_data;
+  quiche::QuicheCircularDeque<std::string> stream_data;
 };
 
 // Generate header list using fuzzer data.

quic/core/qpack/qpack_blocking_manager.h

diff --git a/quic/core/qpack/qpack_blocking_manager.h b/quic/core/qpack/qpack_blocking_manager.h
index 70870a6..4188350 100644
--- a/quic/core/qpack/qpack_blocking_manager.h
+++ b/quic/core/qpack/qpack_blocking_manager.h
@@ -75,8 +75,8 @@
   // A stream typically has only one header block, except for the rare cases of
   // 1xx responses, trailers, or push promises.  Even if there are multiple
   // header blocks sent on a single stream, they might not be blocked at the
-  // same time.  Use std::list instead of QuicCircularDeque because it has lower
-  // memory footprint when holding few elements.
+  // same time.  Use std::list instead of quiche::QuicheCircularDeque because it
+  // has lower memory footprint when holding few elements.
   using HeaderBlocksForStream = std::list<IndexSet>;
   using HeaderBlocks = absl::flat_hash_map<QuicStreamId, HeaderBlocksForStream>;
 

quic/core/quic_connection.h

diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index b81eb02..21555a8 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -36,7 +36,6 @@
 #include "quic/core/quic_alarm.h"
 #include "quic/core/quic_alarm_factory.h"
 #include "quic/core/quic_blocked_writer_interface.h"
-#include "quic/core/quic_circular_deque.h"
 #include "quic/core/quic_connection_id.h"
 #include "quic/core/quic_connection_id_manager.h"
 #include "quic/core/quic_connection_stats.h"
@@ -58,6 +57,7 @@
 #include "quic/platform/api/quic_export.h"
 #include "quic/platform/api/quic_flags.h"
 #include "quic/platform/api/quic_socket_address.h"
+#include "common/quiche_circular_deque.h"
 
 namespace quic {
 
@@ -1920,7 +1920,7 @@
 
   // Collection of coalesced packets which were received while processing
   // the current packet.
-  QuicCircularDeque<std::unique_ptr<QuicEncryptedPacket>>
+  quiche::QuicheCircularDeque<std::unique_ptr<QuicEncryptedPacket>>
       received_coalesced_packets_;
 
   // Maximum number of undecryptable packets the connection will store.
@@ -2130,13 +2130,15 @@
   // saved and responded to.
   // TODO(danzh) deprecate this field when deprecating
   // --quic_send_path_response.
-  QuicCircularDeque<QuicPathFrameBuffer> received_path_challenge_payloads_;
+  quiche::QuicheCircularDeque<QuicPathFrameBuffer>
+      received_path_challenge_payloads_;
 
   // Buffer outstanding PATH_CHALLENGEs if socket write is blocked, future
   // OnCanWrite will attempt to respond with PATH_RESPONSEs using the retained
   // payload and peer addresses.
   // TODO(fayang): remove this when deprecating quic_drop_unsent_path_response.
-  QuicCircularDeque<PendingPathChallenge> pending_path_challenge_payloads_;
+  quiche::QuicheCircularDeque<PendingPathChallenge>
+      pending_path_challenge_payloads_;
 
   // Set of connection IDs that should be accepted as destination on
   // received packets. This is conceptually a set but is implemented as a

quic/core/quic_control_frame_manager.h

diff --git a/quic/core/quic_control_frame_manager.h b/quic/core/quic_control_frame_manager.h
index 1bb3703..4f20666 100644
--- a/quic/core/quic_control_frame_manager.h
+++ b/quic/core/quic_control_frame_manager.h
@@ -9,9 +9,9 @@
 #include <string>
 
 #include "quic/core/frames/quic_frame.h"
-#include "quic/core/quic_circular_deque.h"
 #include "quic/core/quic_connection_id.h"
 #include "quic/core/quic_types.h"
+#include "common/quiche_circular_deque.h"
 
 namespace quic {
 
@@ -163,7 +163,7 @@
   // frame.
   void WriteOrBufferQuicFrame(QuicFrame frame);
 
-  QuicCircularDeque<QuicFrame> control_frames_;
+  quiche::QuicheCircularDeque<QuicFrame> control_frames_;
 
   // Id of latest saved control frame. 0 if no control frame has been saved.
   QuicControlFrameId last_control_frame_id_;

quic/core/quic_datagram_queue.h

diff --git a/quic/core/quic_datagram_queue.h b/quic/core/quic_datagram_queue.h
index 286aeae..4d3aa2f 100644
--- a/quic/core/quic_datagram_queue.h
+++ b/quic/core/quic_datagram_queue.h
@@ -8,10 +8,10 @@
 #include <memory>
 
 #include "absl/types/optional.h"
-#include "quic/core/quic_circular_deque.h"
 #include "quic/core/quic_time.h"
 #include "quic/core/quic_types.h"
 #include "quic/platform/api/quic_mem_slice.h"
+#include "common/quiche_circular_deque.h"
 
 namespace quic {
 
@@ -80,7 +80,7 @@
   const QuicClock* clock_;
 
   QuicTime::Delta max_time_in_queue_ = QuicTime::Delta::Zero();
-  QuicCircularDeque<Datagram> queue_;
+  quiche::QuicheCircularDeque<Datagram> queue_;
   std::unique_ptr<Observer> observer_;
 };
 

quic/core/quic_interval_deque.h

diff --git a/quic/core/quic_interval_deque.h b/quic/core/quic_interval_deque.h
index ba27aa9..274c2e3 100644
--- a/quic/core/quic_interval_deque.h
+++ b/quic/core/quic_interval_deque.h
@@ -8,12 +8,12 @@
 #include <algorithm>
 
 #include "absl/types/optional.h"
-#include "quic/core/quic_circular_deque.h"
 #include "quic/core/quic_interval.h"
 #include "quic/core/quic_types.h"
 #include "quic/platform/api/quic_bug_tracker.h"
 #include "quic/platform/api/quic_export.h"
 #include "quic/platform/api/quic_logging.h"
+#include "common/quiche_circular_deque.h"
 
 namespace quic {
 
@@ -137,7 +137,7 @@
 //   //   cached_index -> 1
 //   //   container -> {{2, [25, 30)}, {3, [35, 50)}}
 
-template <class T, class C = QUIC_NO_EXPORT QuicCircularDeque<T>>
+template <class T, class C = QUIC_NO_EXPORT quiche::QuicheCircularDeque<T>>
 class QUIC_NO_EXPORT QuicIntervalDeque {
  public:
   class QUIC_NO_EXPORT Iterator {
@@ -363,7 +363,7 @@
   // Adding an empty interval is a bug.
   if (interval.Empty()) {
     QUIC_BUG(quic_bug_10862_3)
-        << "Trying to save empty interval to QuicCircularDeque.";
+        << "Trying to save empty interval to quiche::QuicheCircularDeque.";
     return;
   }
   container_.push_back(std::forward<U>(item));

quic/core/quic_linux_socket_utils.h

diff --git a/quic/core/quic_linux_socket_utils.h b/quic/core/quic_linux_socket_utils.h
index 14c26dc..5bbd875 100644
--- a/quic/core/quic_linux_socket_utils.h
+++ b/quic/core/quic_linux_socket_utils.h
@@ -148,7 +148,7 @@
 // multiple packets at once via ::sendmmsg.
 //
 // Example:
-//   QuicCircularDeque<BufferedWrite> buffered_writes;
+//   quiche::QuicheCircularDeque<BufferedWrite> buffered_writes;
 //   ... (Populate buffered_writes) ...
 //
 //   QuicMMsgHdr mhdr(

quic/core/quic_linux_socket_utils_test.cc

diff --git a/quic/core/quic_linux_socket_utils_test.cc b/quic/core/quic_linux_socket_utils_test.cc
index 8425958..588c2be 100644
--- a/quic/core/quic_linux_socket_utils_test.cc
+++ b/quic/core/quic_linux_socket_utils_test.cc
@@ -12,9 +12,9 @@
 
 #include <string>
 
-#include "quic/core/quic_circular_deque.h"
 #include "quic/platform/api/quic_test.h"
 #include "quic/test_tools/quic_mock_syscall_wrapper.h"
+#include "common/quiche_circular_deque.h"
 
 using testing::_;
 using testing::InSequence;
@@ -28,8 +28,8 @@
  protected:
   WriteResult TestWriteMultiplePackets(
       int fd,
-      const QuicCircularDeque<BufferedWrite>::const_iterator& first,
-      const QuicCircularDeque<BufferedWrite>::const_iterator& last,
+      const quiche::QuicheCircularDeque<BufferedWrite>::const_iterator& first,
+      const quiche::QuicheCircularDeque<BufferedWrite>::const_iterator& last,
       int* num_packets_sent) {
     QuicMMsgHdr mhdr(
         first, last, kCmsgSpaceForIp,
@@ -171,7 +171,7 @@
 }
 
 TEST_F(QuicLinuxSocketUtilsTest, QuicMMsgHdr) {
-  QuicCircularDeque<BufferedWrite> buffered_writes;
+  quiche::QuicheCircularDeque<BufferedWrite> buffered_writes;
   char packet_buf1[1024];
   char packet_buf2[512];
   buffered_writes.emplace_back(
@@ -205,7 +205,7 @@
 
 TEST_F(QuicLinuxSocketUtilsTest, WriteMultiplePackets_NoPacketsToSend) {
   int num_packets_sent;
-  QuicCircularDeque<BufferedWrite> buffered_writes;
+  quiche::QuicheCircularDeque<BufferedWrite> buffered_writes;
 
   EXPECT_CALL(mock_syscalls_, Sendmmsg(_, _, _, _)).Times(0);
 
@@ -216,7 +216,7 @@
 
 TEST_F(QuicLinuxSocketUtilsTest, WriteMultiplePackets_WriteBlocked) {
   int num_packets_sent;
-  QuicCircularDeque<BufferedWrite> buffered_writes;
+  quiche::QuicheCircularDeque<BufferedWrite> buffered_writes;
   buffered_writes.emplace_back(nullptr, 0, QuicIpAddress(),
                                QuicSocketAddress(QuicIpAddress::Any4(), 0));
 
@@ -235,7 +235,7 @@
 
 TEST_F(QuicLinuxSocketUtilsTest, WriteMultiplePackets_WriteError) {
   int num_packets_sent;
-  QuicCircularDeque<BufferedWrite> buffered_writes;
+  quiche::QuicheCircularDeque<BufferedWrite> buffered_writes;
   buffered_writes.emplace_back(nullptr, 0, QuicIpAddress(),
                                QuicSocketAddress(QuicIpAddress::Any4(), 0));
 
@@ -254,7 +254,7 @@
 
 TEST_F(QuicLinuxSocketUtilsTest, WriteMultiplePackets_WriteSuccess) {
   int num_packets_sent;
-  QuicCircularDeque<BufferedWrite> buffered_writes;
+  quiche::QuicheCircularDeque<BufferedWrite> buffered_writes;
   const int kNumBufferedWrites = 10;
   static_assert(kNumBufferedWrites < 256, "Must be less than 256");
   std::vector<std::string> buffer_holder;

quic/core/quic_packet_creator.cc

diff --git a/quic/core/quic_packet_creator.cc b/quic/core/quic_packet_creator.cc
index 48fa88e..1267d81 100644
--- a/quic/core/quic_packet_creator.cc
+++ b/quic/core/quic_packet_creator.cc
@@ -937,7 +937,7 @@
 
 std::unique_ptr<SerializedPacket>
 QuicPacketCreator::SerializePathResponseConnectivityProbingPacket(
-    const QuicCircularDeque<QuicPathFrameBuffer>& payloads,
+    const quiche::QuicheCircularDeque<QuicPathFrameBuffer>& payloads,
     const bool is_padded) {
   QUIC_BUG_IF(quic_bug_12398_13,
               !VersionHasIetfQuicFrames(framer_->transport_version()))
@@ -1010,7 +1010,7 @@
     const QuicPacketHeader& header,
     char* buffer,
     size_t packet_length,
-    const QuicCircularDeque<QuicPathFrameBuffer>& payloads,
+    const quiche::QuicheCircularDeque<QuicPathFrameBuffer>& payloads,
     const bool is_padded,
     EncryptionLevel level) {
   if (payloads.empty()) {

quic/core/quic_packet_creator.h

diff --git a/quic/core/quic_packet_creator.h b/quic/core/quic_packet_creator.h
index 2fc32f6..a04df43 100644
--- a/quic/core/quic_packet_creator.h
+++ b/quic/core/quic_packet_creator.h
@@ -23,13 +23,13 @@
 #include "absl/base/attributes.h"
 #include "absl/strings/string_view.h"
 #include "quic/core/frames/quic_stream_frame.h"
-#include "quic/core/quic_circular_deque.h"
 #include "quic/core/quic_coalesced_packet.h"
 #include "quic/core/quic_connection_id.h"
 #include "quic/core/quic_framer.h"
 #include "quic/core/quic_packets.h"
 #include "quic/core/quic_types.h"
 #include "quic/platform/api/quic_export.h"
+#include "common/quiche_circular_deque.h"
 
 namespace quic {
 namespace test {
@@ -258,7 +258,7 @@
   // |payloads| is cleared.
   std::unique_ptr<SerializedPacket>
   SerializePathResponseConnectivityProbingPacket(
-      const QuicCircularDeque<QuicPathFrameBuffer>& payloads,
+      const quiche::QuicheCircularDeque<QuicPathFrameBuffer>& payloads,
       const bool is_padded);
 
   // Add PATH_RESPONSE to current packet, flush before or afterwards if needed.
@@ -465,7 +465,7 @@
       const QuicPacketHeader& header,
       char* buffer,
       size_t packet_length,
-      const QuicCircularDeque<QuicPathFrameBuffer>& payloads,
+      const quiche::QuicheCircularDeque<QuicPathFrameBuffer>& payloads,
       const bool is_padded,
       EncryptionLevel level);
 

quic/core/quic_packet_creator_test.cc

diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index 25b9a51..b371bb3 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -752,7 +752,7 @@
   };
   // clang-format on
   std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
-  QuicCircularDeque<QuicPathFrameBuffer> payloads;
+  quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
   payloads.push_back(payload0);
   size_t length = creator_.BuildPathResponsePacket(
       header, buffer.get(), ABSL_ARRAYSIZE(packet), payloads,
@@ -799,7 +799,7 @@
   };
   // clang-format on
   std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
-  QuicCircularDeque<QuicPathFrameBuffer> payloads;
+  quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
   payloads.push_back(payload0);
   size_t length = creator_.BuildPathResponsePacket(
       header, buffer.get(), ABSL_ARRAYSIZE(packet), payloads,
@@ -849,7 +849,7 @@
   // clang-format on
 
   std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
-  QuicCircularDeque<QuicPathFrameBuffer> payloads;
+  quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
   payloads.push_back(payload0);
   payloads.push_back(payload1);
   payloads.push_back(payload2);
@@ -903,7 +903,7 @@
   // clang-format on
 
   std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
-  QuicCircularDeque<QuicPathFrameBuffer> payloads;
+  quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
   payloads.push_back(payload0);
   payloads.push_back(payload1);
   payloads.push_back(payload2);
@@ -988,7 +988,7 @@
 
   creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
 
-  QuicCircularDeque<QuicPathFrameBuffer> payloads;
+  quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
   payloads.push_back(payload0);
 
   std::unique_ptr<SerializedPacket> encrypted(
@@ -1018,7 +1018,7 @@
 
   creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
 
-  QuicCircularDeque<QuicPathFrameBuffer> payloads;
+  quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
   payloads.push_back(payload0);
 
   std::unique_ptr<SerializedPacket> encrypted(
@@ -1048,7 +1048,7 @@
 
   creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
 
-  QuicCircularDeque<QuicPathFrameBuffer> payloads;
+  quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
   payloads.push_back(payload0);
   payloads.push_back(payload1);
 
@@ -1081,7 +1081,7 @@
 
   creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
 
-  QuicCircularDeque<QuicPathFrameBuffer> payloads;
+  quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
   payloads.push_back(payload0);
   payloads.push_back(payload1);
 
@@ -1114,7 +1114,7 @@
 
   creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
 
-  QuicCircularDeque<QuicPathFrameBuffer> payloads;
+  quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
   payloads.push_back(payload0);
   payloads.push_back(payload1);
   payloads.push_back(payload2);
@@ -1150,7 +1150,7 @@
 
   creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
 
-  QuicCircularDeque<QuicPathFrameBuffer> payloads;
+  quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
   payloads.push_back(payload0);
   payloads.push_back(payload1);
   payloads.push_back(payload2);

quic/core/quic_sent_packet_manager.h

diff --git a/quic/core/quic_sent_packet_manager.h b/quic/core/quic_sent_packet_manager.h
index 13e2396..781f6f9 100644
--- a/quic/core/quic_sent_packet_manager.h
+++ b/quic/core/quic_sent_packet_manager.h
@@ -19,7 +19,6 @@
 #include "quic/core/congestion_control/send_algorithm_interface.h"
 #include "quic/core/congestion_control/uber_loss_algorithm.h"
 #include "quic/core/proto/cached_network_parameters_proto.h"
-#include "quic/core/quic_circular_deque.h"
 #include "quic/core/quic_packets.h"
 #include "quic/core/quic_sustained_bandwidth_recorder.h"
 #include "quic/core/quic_time.h"
@@ -28,6 +27,7 @@
 #include "quic/core/quic_unacked_packet_map.h"
 #include "quic/platform/api/quic_containers.h"
 #include "quic/platform/api/quic_export.h"
+#include "common/quiche_circular_deque.h"
 
 namespace quic {
 
@@ -673,7 +673,8 @@
   // The history of outstanding max_ack_delays sent to peer. Outstanding means
   // a max_ack_delay is sent as part of the last acked AckFrequencyFrame or
   // an unacked AckFrequencyFrame after that.
-  QuicCircularDeque<std::pair<QuicTime::Delta, /*sequence_number=*/uint64_t>>
+  quiche::QuicheCircularDeque<
+      std::pair<QuicTime::Delta, /*sequence_number=*/uint64_t>>
       in_use_sent_ack_delays_;
 
   // Latest received ack frame.

quic/core/quic_stream_send_buffer.h

diff --git a/quic/core/quic_stream_send_buffer.h b/quic/core/quic_stream_send_buffer.h
index cb6e3aa..4b23d3d 100644
--- a/quic/core/quic_stream_send_buffer.h
+++ b/quic/core/quic_stream_send_buffer.h
@@ -6,13 +6,13 @@
 #define QUICHE_QUIC_CORE_QUIC_STREAM_SEND_BUFFER_H_
 
 #include "quic/core/frames/quic_stream_frame.h"
-#include "quic/core/quic_circular_deque.h"
 #include "quic/core/quic_interval_deque.h"
 #include "quic/core/quic_interval_set.h"
 #include "quic/core/quic_types.h"
 #include "quic/platform/api/quic_iovec.h"
 #include "quic/platform/api/quic_mem_slice.h"
 #include "quic/platform/api/quic_mem_slice_span.h"
+#include "common/quiche_circular_deque.h"
 
 namespace quic {
 

quic/core/quic_time_wait_list_manager.h

diff --git a/quic/core/quic_time_wait_list_manager.h b/quic/core/quic_time_wait_list_manager.h
index 2018f72..ac371f2 100644
--- a/quic/core/quic_time_wait_list_manager.h
+++ b/quic/core/quic_time_wait_list_manager.h
@@ -224,7 +224,7 @@
   virtual bool SendOrQueuePacket(std::unique_ptr<QueuedPacket> packet,
                                  const QuicPerPacketContext* packet_context);
 
-  const QuicCircularDeque<std::unique_ptr<QueuedPacket>>&
+  const quiche::QuicheCircularDeque<std::unique_ptr<QueuedPacket>>&
   pending_packets_queue() const {
     return pending_packets_queue_;
   }
@@ -318,7 +318,8 @@
 
   // Pending termination packets that need to be sent out to the peer when we
   // are given a chance to write by the dispatcher.
-  QuicCircularDeque<std::unique_ptr<QueuedPacket>> pending_packets_queue_;
+  quiche::QuicheCircularDeque<std::unique_ptr<QueuedPacket>>
+      pending_packets_queue_;
 
   // Time period for which connection_ids should remain in time wait state.
   const QuicTime::Delta time_wait_period_;

quic/core/quic_unacked_packet_map.h

diff --git a/quic/core/quic_unacked_packet_map.h b/quic/core/quic_unacked_packet_map.h
index 75c835d..67c25f7 100644
--- a/quic/core/quic_unacked_packet_map.h
+++ b/quic/core/quic_unacked_packet_map.h
@@ -10,12 +10,12 @@
 #include <deque>
 
 #include "absl/strings/str_cat.h"
-#include "quic/core/quic_circular_deque.h"
 #include "quic/core/quic_packets.h"
 #include "quic/core/quic_transmission_info.h"
 #include "quic/core/session_notifier_interface.h"
 #include "quic/platform/api/quic_export.h"
 #include "quic/platform/api/quic_flags.h"
+#include "common/quiche_circular_deque.h"
 
 namespace quic {
 
@@ -113,10 +113,10 @@
   QuicPacketNumber GetLeastUnacked() const;
 
   using const_iterator =
-      QuicCircularDeque<QuicTransmissionInfo>::const_iterator;
+      quiche::QuicheCircularDeque<QuicTransmissionInfo>::const_iterator;
   using const_reverse_iterator =
-      QuicCircularDeque<QuicTransmissionInfo>::const_reverse_iterator;
-  using iterator = QuicCircularDeque<QuicTransmissionInfo>::iterator;
+      quiche::QuicheCircularDeque<QuicTransmissionInfo>::const_reverse_iterator;
+  using iterator = quiche::QuicheCircularDeque<QuicTransmissionInfo>::iterator;
 
   const_iterator begin() const { return unacked_packets_.begin(); }
   const_iterator end() const { return unacked_packets_.end(); }
@@ -300,7 +300,7 @@
   // If the old packet is acked before the new packet, then the old entry will
   // be removed from the map and the new entry's retransmittable frames will be
   // set to nullptr.
-  QuicCircularDeque<QuicTransmissionInfo> unacked_packets_;
+  quiche::QuicheCircularDeque<QuicTransmissionInfo> unacked_packets_;
 
   // The packet at the 0th index of unacked_packets_.
   QuicPacketNumber least_unacked_;

quic/platform/api/quic_test.h

diff --git a/quic/platform/api/quic_test.h b/quic/platform/api/quic_test.h
index 69995c3..58896f7 100644
--- a/quic/platform/api/quic_test.h
+++ b/quic/platform/api/quic_test.h
@@ -25,9 +25,6 @@
   return QuicGetTestMemoryCachePathImpl();
 }
 
-#define EXPECT_QUIC_DEBUG_DEATH(condition, message) \
-  EXPECT_QUIC_DEBUG_DEATH_IMPL(condition, message)
-
 #define QUIC_SLOW_TEST(test) QUIC_SLOW_TEST_IMPL(test)
 
 #endif  // QUICHE_QUIC_PLATFORM_API_QUIC_TEST_H_

quic/quic_transport/quic_transport_client_session.h

diff --git a/quic/quic_transport/quic_transport_client_session.h b/quic/quic_transport/quic_transport_client_session.h
index 6f6d091..ad29a15 100644
--- a/quic/quic_transport/quic_transport_client_session.h
+++ b/quic/quic_transport/quic_transport_client_session.h
@@ -152,8 +152,10 @@
   // has not accepted to a smaller number, by checking the size of
   // |incoming_bidirectional_streams_| and |incoming_unidirectional_streams_|
   // before sending MAX_STREAMS.
-  QuicCircularDeque<QuicTransportStream*> incoming_bidirectional_streams_;
-  QuicCircularDeque<QuicTransportStream*> incoming_unidirectional_streams_;
+  quiche::QuicheCircularDeque<QuicTransportStream*>
+      incoming_bidirectional_streams_;
+  quiche::QuicheCircularDeque<QuicTransportStream*>
+      incoming_unidirectional_streams_;
 };
 
 }  // namespace quic

quic/test_tools/quic_test_backend.cc

diff --git a/quic/test_tools/quic_test_backend.cc b/quic/test_tools/quic_test_backend.cc
index b88301a..eb419b6 100644
--- a/quic/test_tools/quic_test_backend.cc
+++ b/quic/test_tools/quic_test_backend.cc
@@ -9,7 +9,6 @@
 
 #include "absl/strings/string_view.h"
 #include "quic/core/quic_buffer_allocator.h"
-#include "quic/core/quic_circular_deque.h"
 #include "quic/core/quic_simple_buffer_allocator.h"
 #include "quic/core/web_transport_interface.h"
 #include "quic/platform/api/quic_mem_slice.h"

quic/test_tools/server_thread.cc

diff --git a/quic/test_tools/server_thread.cc b/quic/test_tools/server_thread.cc
index f5c9b7e..f9315677 100644
--- a/quic/test_tools/server_thread.cc
+++ b/quic/test_tools/server_thread.cc
@@ -126,7 +126,7 @@
 }
 
 void ServerThread::ExecuteScheduledActions() {
-  QuicCircularDeque<std::function<void()>> actions;
+  quiche::QuicheCircularDeque<std::function<void()>> actions;
   {
     QuicWriterMutexLock lock(&scheduled_actions_lock_);
     actions.swap(scheduled_actions_);

quic/test_tools/server_thread.h

diff --git a/quic/test_tools/server_thread.h b/quic/test_tools/server_thread.h
index fa604a8..81d0bf2 100644
--- a/quic/test_tools/server_thread.h
+++ b/quic/test_tools/server_thread.h
@@ -86,7 +86,7 @@
   bool initialized_;
 
   QuicMutex scheduled_actions_lock_;
-  QuicCircularDeque<std::function<void()>> scheduled_actions_
+  quiche::QuicheCircularDeque<std::function<void()>> scheduled_actions_
       QUIC_GUARDED_BY(scheduled_actions_lock_);
 };
 

quic/test_tools/simple_session_notifier.h

diff --git a/quic/test_tools/simple_session_notifier.h b/quic/test_tools/simple_session_notifier.h
index 2219c27..bc76ddc 100644
--- a/quic/test_tools/simple_session_notifier.h
+++ b/quic/test_tools/simple_session_notifier.h
@@ -6,10 +6,10 @@
 #define QUICHE_QUIC_TEST_TOOLS_SIMPLE_SESSION_NOTIFIER_H_
 
 #include "absl/container/flat_hash_map.h"
-#include "quic/core/quic_circular_deque.h"
 #include "quic/core/quic_interval_set.h"
 #include "quic/core/session_notifier_interface.h"
 #include "quic/platform/api/quic_test.h"
+#include "common/quiche_circular_deque.h"
 
 namespace quic {
 
@@ -132,7 +132,7 @@
 
   bool StreamHasBufferedData(QuicStreamId id) const;
 
-  QuicCircularDeque<QuicFrame> control_frames_;
+  quiche::QuicheCircularDeque<QuicFrame> control_frames_;
 
   QuicLinkedHashMap<QuicControlFrameId, bool> lost_control_frames_;
 

quic/test_tools/simulator/link.h

diff --git a/quic/test_tools/simulator/link.h b/quic/test_tools/simulator/link.h
index 7d2f92d..5d72385 100644
--- a/quic/test_tools/simulator/link.h
+++ b/quic/test_tools/simulator/link.h
@@ -9,9 +9,9 @@
 
 #include "quic/core/crypto/quic_random.h"
 #include "quic/core/quic_bandwidth.h"
-#include "quic/core/quic_circular_deque.h"
 #include "quic/test_tools/simulator/actor.h"
 #include "quic/test_tools/simulator/port.h"
+#include "common/quiche_circular_deque.h"
 
 namespace quic {
 namespace simulator {
@@ -61,7 +61,7 @@
   void ScheduleNextPacketDeparture();
 
   UnconstrainedPortInterface* sink_;
-  QuicCircularDeque<QueuedPacket> packets_in_transit_;
+  quiche::QuicheCircularDeque<QueuedPacket> packets_in_transit_;
 
   QuicBandwidth bandwidth_;
   const QuicTime::Delta propagation_delay_;

quic/test_tools/simulator/queue.h

diff --git a/quic/test_tools/simulator/queue.h b/quic/test_tools/simulator/queue.h
index 943b8b0..7e4be83 100644
--- a/quic/test_tools/simulator/queue.h
+++ b/quic/test_tools/simulator/queue.h
@@ -6,8 +6,8 @@
 #define QUICHE_QUIC_TEST_TOOLS_SIMULATOR_QUEUE_H_
 
 #include "quic/core/quic_alarm.h"
-#include "quic/core/quic_circular_deque.h"
 #include "quic/test_tools/simulator/link.h"
+#include "common/quiche_circular_deque.h"
 
 namespace quic {
 namespace simulator {
@@ -110,7 +110,7 @@
   std::unique_ptr<QuicAlarm> aggregation_timeout_alarm_;
 
   ConstrainedPortInterface* tx_port_;
-  QuicCircularDeque<EnqueuedPacket> queue_;
+  quiche::QuicheCircularDeque<EnqueuedPacket> queue_;
 
   ListenerInterface* listener_;
 };

quic/test_tools/simulator/switch.h

diff --git a/quic/test_tools/simulator/switch.h b/quic/test_tools/simulator/switch.h
index bd4e7b6..eebb47c 100644
--- a/quic/test_tools/simulator/switch.h
+++ b/quic/test_tools/simulator/switch.h
@@ -78,7 +78,7 @@
   void DispatchPacket(SwitchPortNumber port_number,
                       std::unique_ptr<Packet> packet);
 
-  // This can not be a QuicCircularDeque since pointers into this are
+  // This cannot be a quiche::QuicheCircularDeque since pointers into this are
   // assumed to be stable.
   std::deque<Port> ports_;
   absl::flat_hash_map<std::string, Port*> switching_table_;

quic/tools/quic_simple_server_session.h

diff --git a/quic/tools/quic_simple_server_session.h b/quic/tools/quic_simple_server_session.h
index 636b8e1..2cc3dcf 100644
--- a/quic/tools/quic_simple_server_session.h
+++ b/quic/tools/quic_simple_server_session.h
@@ -144,7 +144,7 @@
   // the queue also increases by 2 from previous one's. The front element's
   // stream_id is always next_outgoing_stream_id_, and the last one is always
   // highest_promised_stream_id_.
-  QuicCircularDeque<PromisedStreamInfo> promised_streams_;
+  quiche::QuicheCircularDeque<PromisedStreamInfo> promised_streams_;
 
   QuicSimpleServerBackend* quic_simple_server_backend_;  // Not owned.
 };

quic/tools/quic_transport_simple_server_session.h

diff --git a/quic/tools/quic_transport_simple_server_session.h b/quic/tools/quic_transport_simple_server_session.h
index 2d3be8a..a51eab6 100644
--- a/quic/tools/quic_transport_simple_server_session.h
+++ b/quic/tools/quic_transport_simple_server_session.h
@@ -73,7 +73,7 @@
   size_t pending_outgoing_bidirectional_streams_ = 0u;
   Mode mode_;
   std::vector<url::Origin> accepted_origins_;
-  QuicCircularDeque<std::string> streams_to_echo_back_;
+  quiche::QuicheCircularDeque<std::string> streams_to_echo_back_;
 };
 
 }  // namespace quic

quic/tools/web_transport_test_visitors.h

diff --git a/quic/tools/web_transport_test_visitors.h b/quic/tools/web_transport_test_visitors.h
index c9efcb7..e348750 100644
--- a/quic/tools/web_transport_test_visitors.h
+++ b/quic/tools/web_transport_test_visitors.h
@@ -7,10 +7,10 @@
 
 #include <string>
 
-#include "quic/core/quic_circular_deque.h"
 #include "quic/core/quic_simple_buffer_allocator.h"
 #include "quic/core/web_transport_interface.h"
 #include "quic/platform/api/quic_logging.h"
+#include "common/quiche_circular_deque.h"
 
 namespace quic {
 
@@ -220,7 +220,7 @@
   SimpleBufferAllocator allocator_;
   bool echo_stream_opened_ = false;
 
-  QuicCircularDeque<std::string> streams_to_echo_back_;
+  quiche::QuicheCircularDeque<std::string> streams_to_echo_back_;
 };
 
 }  // namespace quic