Move quic::QuicCircularDeque to quiche::QuicheCircularDeque.
See last comment at cl/366295336 for motivation.
PiperOrigin-RevId: 370769667
Change-Id: I41907c4e7ef592fb8b7f6a298daf4e1ed15f4d2f
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_
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_
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
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.
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();
}
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
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_;
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
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
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 {
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_;
};
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
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.
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.
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>;
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
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_;
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_;
};
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));
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(
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;
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()) {
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);
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);
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.
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 {
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_;
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_;
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_
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
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"
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_);
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_);
};
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_;
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_;
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_;
};
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_;
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.
};
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
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
