Move QuicBufferAllocator and SimpleBufferAllocator to third_party/quiche.
Move QuicBufferAllocator and SimpleBufferAllocator from third_party/quic/core to
third_party/quiche/common, because they are used by QuicheMemSliceStorage and
its tests in third_party/quiche/common/.
PiperOrigin-RevId: 432173303
diff --git a/common/platform/api/quiche_mem_slice.h b/common/platform/api/quiche_mem_slice.h
index 61249bc..ce59c75 100644
--- a/common/platform/api/quiche_mem_slice.h
+++ b/common/platform/api/quiche_mem_slice.h
@@ -9,8 +9,8 @@
#include "quiche_platform_impl/quiche_mem_slice_impl.h"
#include "absl/strings/string_view.h"
-#include "quic/core/quic_buffer_allocator.h"
#include "common/platform/api/quiche_export.h"
+#include "common/quiche_buffer_allocator.h"
namespace quiche {
@@ -24,7 +24,7 @@
// Constructs a QuicheMemSlice that takes ownership of |buffer|. The length
// of the |buffer| must not be zero. To construct an empty QuicheMemSlice,
// use the zero-argument constructor instead.
- explicit QuicheMemSlice(quic::QuicBuffer buffer) : impl_(std::move(buffer)) {}
+ explicit QuicheMemSlice(QuicheBuffer buffer) : impl_(std::move(buffer)) {}
// Constructs a QuicheMemSlice that takes ownership of |buffer| allocated on
// heap. |length| must not be zero.
diff --git a/common/platform/api/quiche_mem_slice_test.cc b/common/platform/api/quiche_mem_slice_test.cc
index 4500b5d..e110f90 100644
--- a/common/platform/api/quiche_mem_slice_test.cc
+++ b/common/platform/api/quiche_mem_slice_test.cc
@@ -7,9 +7,9 @@
#include <memory>
#include "absl/strings/string_view.h"
-#include "quic/core/quic_buffer_allocator.h"
-#include "quic/core/quic_simple_buffer_allocator.h"
#include "common/platform/api/quiche_test.h"
+#include "common/quiche_buffer_allocator.h"
+#include "common/simple_buffer_allocator.h"
namespace quiche {
namespace test {
@@ -19,12 +19,12 @@
public:
QuicheMemSliceTest() {
size_t length = 1024;
- slice_ = QuicheMemSlice(quic::QuicBuffer(&allocator_, length));
+ slice_ = QuicheMemSlice(QuicheBuffer(&allocator_, length));
orig_data_ = slice_.data();
orig_length_ = slice_.length();
}
- quic::SimpleBufferAllocator allocator_;
+ SimpleBufferAllocator allocator_;
QuicheMemSlice slice_;
const char* orig_data_;
size_t orig_length_;
@@ -62,7 +62,7 @@
TEST_F(QuicheMemSliceTest, SliceFromBuffer) {
const absl::string_view kTestString =
"RFC 9000 Release Celebration Memorial Test String";
- auto buffer = quic::QuicBuffer::Copy(&allocator_, kTestString);
+ auto buffer = QuicheBuffer::Copy(&allocator_, kTestString);
QuicheMemSlice slice(std::move(buffer));
EXPECT_EQ(buffer.data(), nullptr); // NOLINT(bugprone-use-after-move)
diff --git a/common/platform/default/quiche_platform_impl/quiche_mem_slice_impl.h b/common/platform/default/quiche_platform_impl/quiche_mem_slice_impl.h
index 0d13dec..2db6c44 100644
--- a/common/platform/default/quiche_platform_impl/quiche_mem_slice_impl.h
+++ b/common/platform/default/quiche_platform_impl/quiche_mem_slice_impl.h
@@ -1,9 +1,9 @@
#ifndef QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_MEM_SLICE_IMPL_H_
#define QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_MEM_SLICE_IMPL_H_
-#include "quic/core/quic_buffer_allocator.h"
-#include "quic/core/quic_simple_buffer_allocator.h"
#include "common/platform/api/quiche_export.h"
+#include "common/quiche_buffer_allocator.h"
+#include "common/simple_buffer_allocator.h"
namespace quiche {
@@ -11,15 +11,15 @@
public:
QuicheMemSliceImpl() = default;
- explicit QuicheMemSliceImpl(quic::QuicBuffer buffer)
+ explicit QuicheMemSliceImpl(QuicheBuffer buffer)
: buffer_(std::move(buffer)) {}
QuicheMemSliceImpl(std::unique_ptr<char[]> buffer, size_t length)
- : buffer_(quic::QuicBuffer(
- quic::QuicUniqueBufferPtr(
- buffer.release(),
- quic::QuicBufferDeleter(quic::SimpleBufferAllocator::Get())),
- length)) {}
+ : buffer_(
+ QuicheBuffer(QuicheUniqueBufferPtr(
+ buffer.release(),
+ QuicheBufferDeleter(SimpleBufferAllocator::Get())),
+ length)) {}
QuicheMemSliceImpl(const QuicheMemSliceImpl& other) = delete;
QuicheMemSliceImpl& operator=(const QuicheMemSliceImpl& other) = delete;
@@ -31,14 +31,14 @@
~QuicheMemSliceImpl() = default;
- void Reset() { buffer_ = quic::QuicBuffer(); }
+ void Reset() { buffer_ = QuicheBuffer(); }
const char* data() const { return buffer_.data(); }
size_t length() const { return buffer_.size(); }
bool empty() const { return buffer_.empty(); }
private:
- quic::QuicBuffer buffer_;
+ QuicheBuffer buffer_;
};
} // namespace quiche
diff --git a/common/quiche_buffer_allocator.h b/common/quiche_buffer_allocator.h
new file mode 100644
index 0000000..40140ac
--- /dev/null
+++ b/common/quiche_buffer_allocator.h
@@ -0,0 +1,117 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_COMMON_QUICHE_BUFFER_ALLOCATOR_H_
+#define QUICHE_COMMON_QUICHE_BUFFER_ALLOCATOR_H_
+
+#include <stddef.h>
+
+#include <memory>
+
+#include "absl/strings/string_view.h"
+#include "common/platform/api/quiche_export.h"
+
+namespace quiche {
+
+// Abstract base class for classes which allocate and delete buffers.
+class QUICHE_EXPORT_PRIVATE QuicheBufferAllocator {
+ public:
+ virtual ~QuicheBufferAllocator() = default;
+
+ // Returns or allocates a new buffer of |size|. Never returns null.
+ virtual char* New(size_t size) = 0;
+
+ // Returns or allocates a new buffer of |size| if |flag_enable| is true.
+ // Otherwise, returns a buffer that is compatible with this class directly
+ // with operator new. Never returns null.
+ virtual char* New(size_t size, bool flag_enable) = 0;
+
+ // Releases a buffer.
+ virtual void Delete(char* buffer) = 0;
+
+ // Marks the allocator as being idle. Serves as a hint to notify the allocator
+ // that it should release any resources it's still holding on to.
+ virtual void MarkAllocatorIdle() {}
+};
+
+// A deleter that can be used to manage ownership of buffers allocated via
+// QuicheBufferAllocator through std::unique_ptr.
+class QUICHE_EXPORT_PRIVATE QuicheBufferDeleter {
+ public:
+ explicit QuicheBufferDeleter(QuicheBufferAllocator* allocator)
+ : allocator_(allocator) {}
+
+ QuicheBufferAllocator* allocator() { return allocator_; }
+ void operator()(char* buffer) { allocator_->Delete(buffer); }
+
+ private:
+ QuicheBufferAllocator* allocator_;
+};
+
+using QuicheUniqueBufferPtr = std::unique_ptr<char[], QuicheBufferDeleter>;
+
+inline QuicheUniqueBufferPtr MakeUniqueBuffer(QuicheBufferAllocator* allocator,
+ size_t size) {
+ return QuicheUniqueBufferPtr(allocator->New(size),
+ QuicheBufferDeleter(allocator));
+}
+
+// QuicheUniqueBufferPtr with a length attached to it. Similar to
+// QuicheMemSlice, except unlike QuicheMemSlice, QuicheBuffer is mutable and is
+// not platform-specific. Also unlike QuicheMemSlice, QuicheBuffer can be
+// empty.
+class QUICHE_EXPORT_PRIVATE QuicheBuffer {
+ public:
+ QuicheBuffer() : buffer_(nullptr, QuicheBufferDeleter(nullptr)), size_(0) {}
+ QuicheBuffer(QuicheBufferAllocator* allocator, size_t size)
+ : buffer_(MakeUniqueBuffer(allocator, size)), size_(size) {}
+
+ QuicheBuffer(QuicheUniqueBufferPtr buffer, size_t size)
+ : buffer_(std::move(buffer)), size_(size) {}
+
+ // Make sure the move constructor zeroes out the size field.
+ QuicheBuffer(QuicheBuffer&& other)
+ : buffer_(std::move(other.buffer_)), size_(other.size_) {
+ other.buffer_ = nullptr;
+ other.size_ = 0;
+ }
+ QuicheBuffer& operator=(QuicheBuffer&& other) {
+ buffer_ = std::move(other.buffer_);
+ size_ = other.size_;
+
+ other.buffer_ = nullptr;
+ other.size_ = 0;
+ return *this;
+ }
+
+ // Factory method to create a QuicheBuffer that holds a copy of `data`.
+ static QuicheBuffer Copy(QuicheBufferAllocator* allocator,
+ absl::string_view data) {
+ QuicheBuffer result(allocator, data.size());
+ memcpy(result.data(), data.data(), data.size());
+ return result;
+ }
+
+ const char* data() const { return buffer_.get(); }
+ char* data() { return buffer_.get(); }
+ size_t size() const { return size_; }
+ bool empty() const { return size_ == 0; }
+ absl::string_view AsStringView() const {
+ return absl::string_view(data(), size());
+ }
+
+ // Releases the ownership of the underlying buffer.
+ QuicheUniqueBufferPtr Release() {
+ size_ = 0;
+ return std::move(buffer_);
+ }
+
+ private:
+ QuicheUniqueBufferPtr buffer_;
+ size_t size_;
+};
+
+} // namespace quiche
+
+#endif // QUICHE_COMMON_QUICHE_BUFFER_ALLOCATOR_H_
diff --git a/common/quiche_mem_slice_storage.cc b/common/quiche_mem_slice_storage.cc
index e3e1c5a..2b1b5e1 100644
--- a/common/quiche_mem_slice_storage.cc
+++ b/common/quiche_mem_slice_storage.cc
@@ -9,8 +9,7 @@
namespace quiche {
QuicheMemSliceStorage::QuicheMemSliceStorage(
- const struct iovec* iov, int iov_count,
- quic::QuicBufferAllocator* allocator,
+ const struct iovec* iov, int iov_count, QuicheBufferAllocator* allocator,
const quic::QuicByteCount max_slice_len) {
if (iov == nullptr) {
return;
@@ -24,7 +23,7 @@
size_t io_offset = 0;
while (write_len > 0) {
size_t slice_len = std::min(write_len, max_slice_len);
- quic::QuicBuffer buffer(allocator, slice_len);
+ QuicheBuffer buffer(allocator, slice_len);
quic::QuicUtils::CopyToBuffer(iov, iov_count, io_offset, slice_len,
buffer.data());
storage_.push_back(QuicheMemSlice(std::move(buffer)));
diff --git a/common/quiche_mem_slice_storage.h b/common/quiche_mem_slice_storage.h
index 6ec68bb..155169f 100644
--- a/common/quiche_mem_slice_storage.h
+++ b/common/quiche_mem_slice_storage.h
@@ -8,11 +8,11 @@
#include <vector>
#include "absl/types/span.h"
-#include "quic/core/quic_buffer_allocator.h"
#include "quic/core/quic_types.h"
#include "quic/platform/api/quic_iovec.h"
#include "common/platform/api/quiche_export.h"
#include "common/platform/api/quiche_mem_slice.h"
+#include "common/quiche_buffer_allocator.h"
namespace quiche {
@@ -21,7 +21,7 @@
class QUICHE_EXPORT_PRIVATE QuicheMemSliceStorage {
public:
QuicheMemSliceStorage(const struct iovec* iov, int iov_count,
- quic::QuicBufferAllocator* allocator,
+ QuicheBufferAllocator* allocator,
const quic::QuicByteCount max_slice_len);
QuicheMemSliceStorage(const QuicheMemSliceStorage& other) = default;
diff --git a/common/quiche_mem_slice_storage_test.cc b/common/quiche_mem_slice_storage_test.cc
index a07c71d..15d8294 100644
--- a/common/quiche_mem_slice_storage_test.cc
+++ b/common/quiche_mem_slice_storage_test.cc
@@ -4,8 +4,8 @@
#include "common/quiche_mem_slice_storage.h"
-#include "quic/core/quic_simple_buffer_allocator.h"
#include "common/platform/api/quiche_test.h"
+#include "common/simple_buffer_allocator.h"
namespace quiche {
namespace test {
@@ -22,7 +22,7 @@
}
TEST_F(QuicheMemSliceStorageImplTest, SingleIov) {
- quic::SimpleBufferAllocator allocator;
+ SimpleBufferAllocator allocator;
std::string body(3, 'c');
struct iovec iov = {const_cast<char*>(body.data()), body.length()};
QuicheMemSliceStorage storage(&iov, 1, &allocator, 1024);
@@ -32,7 +32,7 @@
}
TEST_F(QuicheMemSliceStorageImplTest, MultipleIovInSingleSlice) {
- quic::SimpleBufferAllocator allocator;
+ SimpleBufferAllocator allocator;
std::string body1(3, 'a');
std::string body2(4, 'b');
struct iovec iov[] = {{const_cast<char*>(body1.data()), body1.length()},
@@ -44,7 +44,7 @@
}
TEST_F(QuicheMemSliceStorageImplTest, MultipleIovInMultipleSlice) {
- quic::SimpleBufferAllocator allocator;
+ SimpleBufferAllocator allocator;
std::string body1(4, 'a');
std::string body2(4, 'b');
struct iovec iov[] = {{const_cast<char*>(body1.data()), body1.length()},
diff --git a/quic/core/quic_simple_buffer_allocator.cc b/common/simple_buffer_allocator.cc
similarity index 81%
rename from quic/core/quic_simple_buffer_allocator.cc
rename to common/simple_buffer_allocator.cc
index aba8c43..64501a1 100644
--- a/quic/core/quic_simple_buffer_allocator.cc
+++ b/common/simple_buffer_allocator.cc
@@ -2,9 +2,9 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "quic/core/quic_simple_buffer_allocator.h"
+#include "common/simple_buffer_allocator.h"
-namespace quic {
+namespace quiche {
char* SimpleBufferAllocator::New(size_t size) {
return new char[size];
@@ -18,4 +18,4 @@
delete[] buffer;
}
-} // namespace quic
+} // namespace quiche
diff --git a/quic/core/quic_simple_buffer_allocator.h b/common/simple_buffer_allocator.h
similarity index 62%
rename from quic/core/quic_simple_buffer_allocator.h
rename to common/simple_buffer_allocator.h
index 62f406b..586c0f3 100644
--- a/quic/core/quic_simple_buffer_allocator.h
+++ b/common/simple_buffer_allocator.h
@@ -2,18 +2,19 @@
// 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_SIMPLE_BUFFER_ALLOCATOR_H_
-#define QUICHE_QUIC_CORE_QUIC_SIMPLE_BUFFER_ALLOCATOR_H_
+#ifndef QUICHE_COMMON_QUICHE_SIMPLE_BUFFER_ALLOCATOR_H_
+#define QUICHE_COMMON_QUICHE_SIMPLE_BUFFER_ALLOCATOR_H_
-#include "quic/core/quic_buffer_allocator.h"
-#include "quic/platform/api/quic_export.h"
+#include "common/platform/api/quiche_export.h"
+#include "common/quiche_buffer_allocator.h"
-namespace quic {
+namespace quiche {
// Provides buffer allocation using operators new[] and delete[] on char arrays.
// Note that some of the QUICHE code relies on this being the case for deleting
// new[]-allocated arrays from elsewhere.
-class QUIC_EXPORT_PRIVATE SimpleBufferAllocator : public QuicBufferAllocator {
+class QUICHE_EXPORT_PRIVATE SimpleBufferAllocator
+ : public QuicheBufferAllocator {
public:
static SimpleBufferAllocator* Get() {
static SimpleBufferAllocator* singleton = new SimpleBufferAllocator();
@@ -25,6 +26,6 @@
void Delete(char* buffer) override;
};
-} // namespace quic
+} // namespace quiche
-#endif // QUICHE_QUIC_CORE_QUIC_SIMPLE_BUFFER_ALLOCATOR_H_
+#endif // QUICHE_COMMON_QUICHE_SIMPLE_BUFFER_ALLOCATOR_H_
diff --git a/quic/core/quic_simple_buffer_allocator_test.cc b/common/simple_buffer_allocator_test.cc
similarity index 63%
rename from quic/core/quic_simple_buffer_allocator_test.cc
rename to common/simple_buffer_allocator_test.cc
index 5416cd4..e768bbb 100644
--- a/quic/core/quic_simple_buffer_allocator_test.cc
+++ b/common/simple_buffer_allocator_test.cc
@@ -2,46 +2,43 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "quic/core/quic_simple_buffer_allocator.h"
+#include "common/simple_buffer_allocator.h"
-#include "quic/core/quic_packets.h"
-#include "quic/platform/api/quic_test.h"
+#include "common/platform/api/quiche_test.h"
-namespace quic {
+namespace quiche {
namespace {
-class SimpleBufferAllocatorTest : public QuicTest {};
-
-TEST_F(SimpleBufferAllocatorTest, NewDelete) {
+TEST(SimpleBufferAllocatorTest, NewDelete) {
SimpleBufferAllocator alloc;
char* buf = alloc.New(4);
EXPECT_NE(nullptr, buf);
alloc.Delete(buf);
}
-TEST_F(SimpleBufferAllocatorTest, DeleteNull) {
+TEST(SimpleBufferAllocatorTest, DeleteNull) {
SimpleBufferAllocator alloc;
alloc.Delete(nullptr);
}
-TEST_F(SimpleBufferAllocatorTest, MoveBuffersConstructor) {
+TEST(SimpleBufferAllocatorTest, MoveBuffersConstructor) {
SimpleBufferAllocator alloc;
- QuicBuffer buffer1(&alloc, 16);
+ QuicheBuffer buffer1(&alloc, 16);
EXPECT_NE(buffer1.data(), nullptr);
EXPECT_EQ(buffer1.size(), 16u);
- QuicBuffer buffer2(std::move(buffer1));
+ QuicheBuffer buffer2(std::move(buffer1));
EXPECT_EQ(buffer1.data(), nullptr); // NOLINT(bugprone-use-after-move)
EXPECT_EQ(buffer1.size(), 0u);
EXPECT_NE(buffer2.data(), nullptr);
EXPECT_EQ(buffer2.size(), 16u);
}
-TEST_F(SimpleBufferAllocatorTest, MoveBuffersAssignment) {
+TEST(SimpleBufferAllocatorTest, MoveBuffersAssignment) {
SimpleBufferAllocator alloc;
- QuicBuffer buffer1(&alloc, 16);
- QuicBuffer buffer2;
+ QuicheBuffer buffer1(&alloc, 16);
+ QuicheBuffer buffer2;
EXPECT_NE(buffer1.data(), nullptr);
EXPECT_EQ(buffer1.size(), 16u);
@@ -55,12 +52,12 @@
EXPECT_EQ(buffer2.size(), 16u);
}
-TEST_F(SimpleBufferAllocatorTest, CopyBuffer) {
+TEST(SimpleBufferAllocatorTest, CopyBuffer) {
SimpleBufferAllocator alloc;
const absl::string_view original = "Test string";
- QuicBuffer copy = QuicBuffer::Copy(&alloc, original);
+ QuicheBuffer copy = QuicheBuffer::Copy(&alloc, original);
EXPECT_EQ(copy.AsStringView(), original);
}
} // namespace
-} // namespace quic
+} // namespace quiche
diff --git a/quic/core/frames/quic_crypto_frame.h b/quic/core/frames/quic_crypto_frame.h
index e1e79a6..6e15fbe 100644
--- a/quic/core/frames/quic_crypto_frame.h
+++ b/quic/core/frames/quic_crypto_frame.h
@@ -9,7 +9,6 @@
#include <ostream>
#include "absl/strings/string_view.h"
-#include "quic/core/quic_buffer_allocator.h"
#include "quic/core/quic_types.h"
#include "quic/platform/api/quic_export.h"
diff --git a/quic/core/frames/quic_frame.cc b/quic/core/frames/quic_frame.cc
index e83e422..48bc12a 100644
--- a/quic/core/frames/quic_frame.cc
+++ b/quic/core/frames/quic_frame.cc
@@ -6,12 +6,12 @@
#include "quic/core/frames/quic_new_connection_id_frame.h"
#include "quic/core/frames/quic_retire_connection_id_frame.h"
-#include "quic/core/quic_buffer_allocator.h"
#include "quic/core/quic_constants.h"
#include "quic/core/quic_types.h"
#include "quic/platform/api/quic_bug_tracker.h"
#include "quic/platform/api/quic_logging.h"
#include "common/platform/api/quiche_mem_slice.h"
+#include "common/quiche_buffer_allocator.h"
namespace quic {
@@ -327,7 +327,7 @@
return copy;
}
-QuicFrame CopyQuicFrame(QuicBufferAllocator* allocator,
+QuicFrame CopyQuicFrame(quiche::QuicheBufferAllocator* allocator,
const QuicFrame& frame) {
QuicFrame copy;
switch (frame.type) {
@@ -392,7 +392,8 @@
copy.message_frame->data = frame.message_frame->data;
copy.message_frame->message_length = frame.message_frame->message_length;
for (const auto& slice : frame.message_frame->message_data) {
- QuicBuffer buffer = QuicBuffer::Copy(allocator, slice.AsStringView());
+ quiche::QuicheBuffer buffer =
+ quiche::QuicheBuffer::Copy(allocator, slice.AsStringView());
copy.message_frame->message_data.push_back(
quiche::QuicheMemSlice(std::move(buffer)));
}
@@ -419,7 +420,7 @@
return copy;
}
-QuicFrames CopyQuicFrames(QuicBufferAllocator* allocator,
+QuicFrames CopyQuicFrames(quiche::QuicheBufferAllocator* allocator,
const QuicFrames& frames) {
QuicFrames copy;
for (const auto& frame : frames) {
diff --git a/quic/core/frames/quic_frame.h b/quic/core/frames/quic_frame.h
index 9ee4568..7de9bb6 100644
--- a/quic/core/frames/quic_frame.h
+++ b/quic/core/frames/quic_frame.h
@@ -163,12 +163,12 @@
CopyRetransmittableControlFrame(const QuicFrame& frame);
// Returns a copy of |frame|.
-QUIC_EXPORT_PRIVATE QuicFrame CopyQuicFrame(QuicBufferAllocator* allocator,
- const QuicFrame& frame);
+QUIC_EXPORT_PRIVATE QuicFrame
+CopyQuicFrame(quiche::QuicheBufferAllocator* allocator, const QuicFrame& frame);
// Returns a copy of |frames|.
-QUIC_EXPORT_PRIVATE QuicFrames CopyQuicFrames(QuicBufferAllocator* allocator,
- const QuicFrames& frames);
+QUIC_EXPORT_PRIVATE QuicFrames CopyQuicFrames(
+ quiche::QuicheBufferAllocator* allocator, const QuicFrames& frames);
// Human-readable description suitable for logging.
QUIC_EXPORT_PRIVATE std::string QuicFramesToString(const QuicFrames& frames);
diff --git a/quic/core/frames/quic_frames_test.cc b/quic/core/frames/quic_frames_test.cc
index 43eabf7..6955094 100644
--- a/quic/core/frames/quic_frames_test.cc
+++ b/quic/core/frames/quic_frames_test.cc
@@ -625,7 +625,8 @@
}
}
- QuicFrames copy = CopyQuicFrames(SimpleBufferAllocator::Get(), frames);
+ QuicFrames copy =
+ CopyQuicFrames(quiche::SimpleBufferAllocator::Get(), frames);
ASSERT_EQ(NUM_FRAME_TYPES, copy.size());
for (uint8_t i = 0; i < NUM_FRAME_TYPES; ++i) {
EXPECT_EQ(i, copy[i].type);
diff --git a/quic/core/frames/quic_new_token_frame.h b/quic/core/frames/quic_new_token_frame.h
index 805216b..d0d7e8e 100644
--- a/quic/core/frames/quic_new_token_frame.h
+++ b/quic/core/frames/quic_new_token_frame.h
@@ -9,7 +9,6 @@
#include <ostream>
#include "absl/strings/string_view.h"
-#include "quic/core/quic_buffer_allocator.h"
#include "quic/core/quic_constants.h"
#include "quic/core/quic_types.h"
#include "quic/platform/api/quic_export.h"
diff --git a/quic/core/frames/quic_stream_frame.h b/quic/core/frames/quic_stream_frame.h
index 9ba8ccc..2e2daba 100644
--- a/quic/core/frames/quic_stream_frame.h
+++ b/quic/core/frames/quic_stream_frame.h
@@ -10,7 +10,6 @@
#include "absl/strings/string_view.h"
#include "quic/core/frames/quic_inlined_frame.h"
-#include "quic/core/quic_buffer_allocator.h"
#include "quic/core/quic_types.h"
#include "quic/platform/api/quic_export.h"
diff --git a/quic/core/http/capsule.cc b/quic/core/http/capsule.cc
index 21df166..fd89b38 100644
--- a/quic/core/http/capsule.cc
+++ b/quic/core/http/capsule.cc
@@ -392,8 +392,8 @@
QUICHE_DCHECK_NE(visitor_, nullptr);
}
-QuicBuffer SerializeCapsule(const Capsule& capsule,
- QuicBufferAllocator* allocator) {
+quiche::QuicheBuffer SerializeCapsule(
+ const Capsule& capsule, quiche::QuicheBufferAllocator* allocator) {
QuicByteCount capsule_type_length = QuicDataWriter::GetVarInt62Len(
static_cast<uint64_t>(capsule.capsule_type()));
QuicByteCount capsule_data_length;
@@ -454,15 +454,15 @@
QuicDataWriter::GetVarInt62Len(capsule_data_length);
QuicByteCount total_capsule_length =
capsule_type_length + capsule_length_length + capsule_data_length;
- QuicBuffer buffer(allocator, total_capsule_length);
+ quiche::QuicheBuffer buffer(allocator, total_capsule_length);
QuicDataWriter writer(buffer.size(), buffer.data());
if (!writer.WriteVarInt62(static_cast<uint64_t>(capsule.capsule_type()))) {
QUIC_BUG(capsule type write fail) << "Failed to write CAPSULE type";
- return QuicBuffer();
+ return {};
}
if (!writer.WriteVarInt62(capsule_data_length)) {
QUIC_BUG(capsule length write fail) << "Failed to write CAPSULE length";
- return QuicBuffer();
+ return {};
}
switch (capsule.capsule_type()) {
case CapsuleType::LEGACY_DATAGRAM:
@@ -471,14 +471,14 @@
capsule.legacy_datagram_capsule().context_id.value())) {
QUIC_BUG(datagram capsule context ID write fail)
<< "Failed to write LEGACY_DATAGRAM CAPSULE context ID";
- return QuicBuffer();
+ return {};
}
}
if (!writer.WriteStringPiece(
capsule.legacy_datagram_capsule().http_datagram_payload)) {
QUIC_BUG(datagram capsule payload write fail)
<< "Failed to write LEGACY_DATAGRAM CAPSULE payload";
- return QuicBuffer();
+ return {};
}
break;
case CapsuleType::DATAGRAM_WITH_CONTEXT:
@@ -486,13 +486,13 @@
capsule.datagram_with_context_capsule().context_id)) {
QUIC_BUG(datagram capsule context ID write fail)
<< "Failed to write DATAGRAM_WITH_CONTEXT CAPSULE context ID";
- return QuicBuffer();
+ return {};
}
if (!writer.WriteStringPiece(
capsule.datagram_with_context_capsule().http_datagram_payload)) {
QUIC_BUG(datagram capsule payload write fail)
<< "Failed to write DATAGRAM_WITH_CONTEXT CAPSULE payload";
- return QuicBuffer();
+ return {};
}
break;
case CapsuleType::DATAGRAM_WITHOUT_CONTEXT:
@@ -500,7 +500,7 @@
.http_datagram_payload)) {
QUIC_BUG(datagram capsule payload write fail)
<< "Failed to write DATAGRAM_WITHOUT_CONTEXT CAPSULE payload";
- return QuicBuffer();
+ return {};
}
break;
case CapsuleType::REGISTER_DATAGRAM_CONTEXT:
@@ -508,20 +508,20 @@
capsule.register_datagram_context_capsule().context_id)) {
QUIC_BUG(register context capsule context ID write fail)
<< "Failed to write REGISTER_DATAGRAM_CONTEXT CAPSULE context ID";
- return QuicBuffer();
+ return {};
}
if (!writer.WriteVarInt62(static_cast<uint64_t>(
capsule.register_datagram_context_capsule().format_type))) {
QUIC_BUG(register context capsule format type write fail)
<< "Failed to write REGISTER_DATAGRAM_CONTEXT CAPSULE format type";
- return QuicBuffer();
+ return {};
}
if (!writer.WriteStringPiece(capsule.register_datagram_context_capsule()
.format_additional_data)) {
QUIC_BUG(register context capsule additional data write fail)
<< "Failed to write REGISTER_DATAGRAM_CONTEXT CAPSULE additional "
"data";
- return QuicBuffer();
+ return {};
}
break;
case CapsuleType::REGISTER_DATAGRAM_NO_CONTEXT:
@@ -530,7 +530,7 @@
QUIC_BUG(register no context capsule format type write fail)
<< "Failed to write REGISTER_DATAGRAM_NO_CONTEXT CAPSULE format "
"type";
- return QuicBuffer();
+ return {};
}
if (!writer.WriteStringPiece(
capsule.register_datagram_no_context_capsule()
@@ -538,7 +538,7 @@
QUIC_BUG(register no context capsule additional data write fail)
<< "Failed to write REGISTER_DATAGRAM_NO_CONTEXT CAPSULE "
"additional data";
- return QuicBuffer();
+ return {};
}
break;
case CapsuleType::CLOSE_DATAGRAM_CONTEXT:
@@ -546,19 +546,19 @@
capsule.close_datagram_context_capsule().context_id)) {
QUIC_BUG(close context capsule context ID write fail)
<< "Failed to write CLOSE_DATAGRAM_CONTEXT CAPSULE context ID";
- return QuicBuffer();
+ return {};
}
if (!writer.WriteVarInt62(static_cast<uint64_t>(
capsule.close_datagram_context_capsule().close_code))) {
QUIC_BUG(close context capsule close code write fail)
<< "Failed to write CLOSE_DATAGRAM_CONTEXT CAPSULE close code";
- return QuicBuffer();
+ return {};
}
if (!writer.WriteStringPiece(
capsule.close_datagram_context_capsule().close_details)) {
QUIC_BUG(close context capsule close details write fail)
<< "Failed to write CLOSE_DATAGRAM_CONTEXT CAPSULE close details";
- return QuicBuffer();
+ return {};
}
break;
case CapsuleType::CLOSE_WEBTRANSPORT_SESSION:
@@ -566,19 +566,19 @@
capsule.close_web_transport_session_capsule().error_code)) {
QUIC_BUG(close webtransport session capsule error code write fail)
<< "Failed to write CLOSE_WEBTRANSPORT_SESSION error code";
- return QuicBuffer();
+ return {};
}
if (!writer.WriteStringPiece(
capsule.close_web_transport_session_capsule().error_message)) {
QUIC_BUG(close webtransport session capsule error message write fail)
<< "Failed to write CLOSE_WEBTRANSPORT_SESSION error message";
- return QuicBuffer();
+ return {};
}
break;
default:
if (!writer.WriteStringPiece(capsule.unknown_capsule_data())) {
QUIC_BUG(capsule data write fail) << "Failed to write CAPSULE data";
- return QuicBuffer();
+ return {};
}
break;
}
@@ -586,7 +586,7 @@
QUIC_BUG(capsule write length mismatch)
<< "CAPSULE serialization wrote " << writer.length() << " instead of "
<< writer.capacity();
- return QuicBuffer();
+ return {};
}
return buffer;
}
diff --git a/quic/core/http/capsule.h b/quic/core/http/capsule.h
index 42190bb..94601f9 100644
--- a/quic/core/http/capsule.h
+++ b/quic/core/http/capsule.h
@@ -11,10 +11,10 @@
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
-#include "quic/core/quic_buffer_allocator.h"
#include "quic/core/quic_data_reader.h"
#include "quic/core/quic_types.h"
#include "common/platform/api/quiche_logging.h"
+#include "common/quiche_buffer_allocator.h"
namespace quic {
@@ -283,8 +283,8 @@
};
// Serializes |capsule| into a newly allocated buffer.
-QUIC_EXPORT_PRIVATE QuicBuffer SerializeCapsule(const Capsule& capsule,
- QuicBufferAllocator* allocator);
+QUIC_EXPORT_PRIVATE quiche::QuicheBuffer SerializeCapsule(
+ const Capsule& capsule, quiche::QuicheBufferAllocator* allocator);
} // namespace quic
diff --git a/quic/core/http/capsule_test.cc b/quic/core/http/capsule_test.cc
index 2dfdef4..c971826 100644
--- a/quic/core/http/capsule_test.cc
+++ b/quic/core/http/capsule_test.cc
@@ -60,8 +60,8 @@
void TestSerialization(const Capsule& capsule,
const std::string& expected_bytes) {
- QuicBuffer serialized_capsule =
- SerializeCapsule(capsule, SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer serialized_capsule =
+ SerializeCapsule(capsule, quiche::SimpleBufferAllocator::Get());
quiche::test::CompareCharArraysWithHexError(
"Serialized capsule", serialized_capsule.data(),
serialized_capsule.size(), expected_bytes.data(),
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index ccf2d3a..c778faa 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -6642,7 +6642,7 @@
ASSERT_TRUE(session != nullptr);
NiceMock<MockClientVisitor>& visitor = SetupWebTransportVisitor(session);
- SimpleBufferAllocator allocator;
+ quiche::SimpleBufferAllocator allocator;
for (int i = 0; i < 10; i++) {
session->SendOrQueueDatagram(MemSliceFromString("test"));
}
@@ -6672,7 +6672,7 @@
ASSERT_TRUE(connect_stream != nullptr);
NiceMock<MockClientVisitor>& visitor = SetupWebTransportVisitor(session);
- SimpleBufferAllocator allocator;
+ quiche::SimpleBufferAllocator allocator;
for (int i = 0; i < 10; i++) {
session->SendOrQueueDatagram(MemSliceFromString("test"));
}
diff --git a/quic/core/http/http_decoder_test.cc b/quic/core/http/http_decoder_test.cc
index 95d5913..d8a54e0 100644
--- a/quic/core/http/http_decoder_test.cc
+++ b/quic/core/http/http_decoder_test.cc
@@ -419,8 +419,8 @@
InSequence s;
// A large input that will occupy more than 1 byte in the length field.
std::string input(2048, 'x');
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- input.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ input.length(), quiche::SimpleBufferAllocator::Get());
// Partially send only 1 byte of the header to process.
EXPECT_EQ(1u, decoder_.ProcessInput(header.data(), 1));
EXPECT_THAT(decoder_.error(), IsQuicNoError());
diff --git a/quic/core/http/http_encoder.cc b/quic/core/http/http_encoder.cc
index 25f6200..684fdde 100644
--- a/quic/core/http/http_encoder.cc
+++ b/quic/core/http/http_encoder.cc
@@ -43,13 +43,12 @@
}
// static
-QuicBuffer HttpEncoder::SerializeDataFrameHeader(
- QuicByteCount payload_length,
- QuicBufferAllocator* allocator) {
+quiche::QuicheBuffer HttpEncoder::SerializeDataFrameHeader(
+ QuicByteCount payload_length, quiche::QuicheBufferAllocator* allocator) {
QUICHE_DCHECK_NE(0u, payload_length);
QuicByteCount header_length = GetDataFrameHeaderLength(payload_length);
- QuicBuffer header(allocator, header_length);
+ quiche::QuicheBuffer header(allocator, header_length);
QuicDataWriter writer(header.size(), header.data());
if (WriteFrameHeader(payload_length, HttpFrameType::DATA, &writer)) {
@@ -57,7 +56,7 @@
}
QUIC_DLOG(ERROR)
<< "Http encoder failed when attempting to serialize data frame header.";
- return QuicBuffer();
+ return quiche::QuicheBuffer();
}
// static
diff --git a/quic/core/http/http_encoder.h b/quic/core/http/http_encoder.h
index 585e739..97f4b3d 100644
--- a/quic/core/http/http_encoder.h
+++ b/quic/core/http/http_encoder.h
@@ -6,11 +6,12 @@
#define QUICHE_QUIC_CORE_HTTP_HTTP_ENCODER_H_
#include <memory>
+
#include "quic/core/http/http_frames.h"
-#include "quic/core/quic_buffer_allocator.h"
#include "quic/core/quic_error_codes.h"
#include "quic/core/quic_types.h"
#include "quic/platform/api/quic_export.h"
+#include "common/quiche_buffer_allocator.h"
namespace quic {
@@ -25,10 +26,10 @@
// Returns the length of the header for a DATA frame.
static QuicByteCount GetDataFrameHeaderLength(QuicByteCount payload_length);
- // Serializes a DATA frame header into a QuicBuffer; returns said QuicBuffer
- // on success, empty buffer otherwise.
- static QuicBuffer SerializeDataFrameHeader(QuicByteCount payload_length,
- QuicBufferAllocator* allocator);
+ // Serializes a DATA frame header into a QuicheBuffer; returns said
+ // QuicheBuffer on success, empty buffer otherwise.
+ static quiche::QuicheBuffer SerializeDataFrameHeader(
+ QuicByteCount payload_length, quiche::QuicheBufferAllocator* allocator);
// Serializes a HEADERS frame header into a new buffer stored in |output|.
// Returns the length of the buffer on success, or 0 otherwise.
diff --git a/quic/core/http/http_encoder_test.cc b/quic/core/http/http_encoder_test.cc
index c2b0f36..aab63a1 100644
--- a/quic/core/http/http_encoder_test.cc
+++ b/quic/core/http/http_encoder_test.cc
@@ -5,18 +5,18 @@
#include "quic/core/http/http_encoder.h"
#include "absl/base/macros.h"
-#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/platform/api/quic_flags.h"
#include "quic/platform/api/quic_test.h"
#include "quic/test_tools/quic_test_utils.h"
+#include "common/simple_buffer_allocator.h"
#include "common/test_tools/quiche_test_utils.h"
namespace quic {
namespace test {
TEST(HttpEncoderTest, SerializeDataFrameHeader) {
- QuicBuffer buffer = HttpEncoder::SerializeDataFrameHeader(
- /* payload_length = */ 5, SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer buffer = HttpEncoder::SerializeDataFrameHeader(
+ /* payload_length = */ 5, quiche::SimpleBufferAllocator::Get());
char output[] = {// type (DATA)
0x00,
// length
diff --git a/quic/core/http/quic_receive_control_stream_test.cc b/quic/core/http/quic_receive_control_stream_test.cc
index ae7a0d8..4fc2ddf 100644
--- a/quic/core/http/quic_receive_control_stream_test.cc
+++ b/quic/core/http/quic_receive_control_stream_test.cc
@@ -9,13 +9,13 @@
#include "absl/strings/string_view.h"
#include "quic/core/http/http_constants.h"
#include "quic/core/qpack/qpack_header_table.h"
-#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/core/quic_types.h"
#include "quic/core/quic_utils.h"
#include "quic/test_tools/qpack/qpack_encoder_peer.h"
#include "quic/test_tools/quic_spdy_session_peer.h"
#include "quic/test_tools/quic_stream_peer.h"
#include "quic/test_tools/quic_test_utils.h"
+#include "common/simple_buffer_allocator.h"
namespace quic {
@@ -240,8 +240,8 @@
TEST_P(QuicReceiveControlStreamTest, ReceiveWrongFrame) {
// DATA frame header without payload.
- QuicBuffer data = HttpEncoder::SerializeDataFrameHeader(
- /* payload_length = */ 2, SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer data = HttpEncoder::SerializeDataFrameHeader(
+ /* payload_length = */ 2, quiche::SimpleBufferAllocator::Get());
QuicStreamFrame frame(receive_control_stream_->id(), false, 1,
data.AsStringView());
diff --git a/quic/core/http/quic_spdy_client_stream_test.cc b/quic/core/http/quic_spdy_client_stream_test.cc
index 32a0c0c..a7e5d86 100644
--- a/quic/core/http/quic_spdy_client_stream_test.cc
+++ b/quic/core/http/quic_spdy_client_stream_test.cc
@@ -12,7 +12,6 @@
#include "quic/core/crypto/null_encrypter.h"
#include "quic/core/http/quic_spdy_client_session.h"
#include "quic/core/http/spdy_utils.h"
-#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/core/quic_utils.h"
#include "quic/platform/api/quic_logging.h"
#include "quic/platform/api/quic_socket_address.h"
@@ -20,6 +19,7 @@
#include "quic/test_tools/crypto_test_utils.h"
#include "quic/test_tools/quic_spdy_session_peer.h"
#include "quic/test_tools/quic_test_utils.h"
+#include "common/simple_buffer_allocator.h"
using spdy::SpdyHeaderBlock;
using testing::_;
@@ -158,8 +158,8 @@
auto headers = AsHeaderList(headers_);
stream_->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
headers);
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- body_.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ body_.length(), quiche::SimpleBufferAllocator::Get());
std::string data = VersionUsesHttp3(connection_->transport_version())
? absl::StrCat(header.AsStringView(), body_)
: body_;
@@ -185,8 +185,8 @@
headers = AsHeaderList(headers_);
stream_->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
headers);
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- body_.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ body_.length(), quiche::SimpleBufferAllocator::Get());
std::string data = VersionUsesHttp3(connection_->transport_version())
? absl::StrCat(header.AsStringView(), body_)
: body_;
@@ -214,8 +214,8 @@
headers = AsHeaderList(headers_);
stream_->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
headers);
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- body_.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ body_.length(), quiche::SimpleBufferAllocator::Get());
std::string data = VersionUsesHttp3(connection_->transport_version())
? absl::StrCat(header.AsStringView(), body_)
: body_;
@@ -245,8 +245,8 @@
auto headers = AsHeaderList(headers_);
stream_->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
headers);
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- body_.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ body_.length(), quiche::SimpleBufferAllocator::Get());
std::string data = VersionUsesHttp3(connection_->transport_version())
? absl::StrCat(header.AsStringView(), body_)
: body_;
@@ -268,8 +268,8 @@
EXPECT_THAT(stream_->stream_error(), IsQuicStreamNoError());
EXPECT_EQ("200", stream_->response_headers().find(":status")->second);
EXPECT_EQ(200, stream_->response_code());
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- large_body.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ large_body.length(), quiche::SimpleBufferAllocator::Get());
std::string data = VersionUsesHttp3(connection_->transport_version())
? absl::StrCat(header.AsStringView(), large_body)
: large_body;
@@ -309,8 +309,8 @@
// Now send the body, which should close the stream as the FIN has been
// received, as well as all data.
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- body_.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ body_.length(), quiche::SimpleBufferAllocator::Get());
std::string data = VersionUsesHttp3(connection_->transport_version())
? absl::StrCat(header.AsStringView(), body_)
: body_;
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index 6a57107..095efdd 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -1663,8 +1663,8 @@
if (context_id.has_value()) {
slice_length += QuicDataWriter::GetVarInt62Len(context_id.value());
}
- QuicBuffer buffer(connection()->helper()->GetStreamSendBufferAllocator(),
- slice_length);
+ quiche::QuicheBuffer buffer(
+ connection()->helper()->GetStreamSendBufferAllocator(), slice_length);
QuicDataWriter writer(slice_length, buffer.data());
if (!writer.WriteVarInt62(stream_id_to_write)) {
QUIC_BUG(h3 datagram stream ID write fail)
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index 2fcece7..adeb224 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -401,7 +401,7 @@
bool force_write) {
QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
QUICHE_DCHECK_GT(data_length, 0u);
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
data_length,
spdy_session_->connection()->helper()->GetStreamSendBufferAllocator());
const bool can_write = CanWriteNewDataAfterData(header.size());
@@ -1563,7 +1563,7 @@
void QuicSpdyStream::WriteCapsule(const Capsule& capsule, bool fin) {
QUIC_DLOG(INFO) << ENDPOINT << "Stream " << id() << " sending capsule "
<< capsule;
- QuicBuffer serialized_capsule = SerializeCapsule(
+ quiche::QuicheBuffer serialized_capsule = SerializeCapsule(
capsule,
spdy_session_->connection()->helper()->GetStreamSendBufferAllocator());
QUICHE_DCHECK_GT(serialized_capsule.size(), 0u);
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index cb00c2a..bf4dc45 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -20,7 +20,6 @@
#include "quic/core/http/spdy_utils.h"
#include "quic/core/http/web_transport_http3.h"
#include "quic/core/quic_connection.h"
-#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/core/quic_stream_sequencer_buffer.h"
#include "quic/core/quic_utils.h"
#include "quic/core/quic_versions.h"
@@ -38,6 +37,7 @@
#include "quic/test_tools/quic_stream_peer.h"
#include "quic/test_tools/quic_test_utils.h"
#include "common/quiche_mem_slice_storage.h"
+#include "common/simple_buffer_allocator.h"
using spdy::kV3HighestPriority;
using spdy::kV3LowestPriority;
@@ -477,8 +477,8 @@
}
std::string DataFrame(absl::string_view payload) {
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- payload.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ payload.length(), quiche::SimpleBufferAllocator::Get());
return absl::StrCat(header.AsStringView(), payload);
}
@@ -1010,8 +1010,8 @@
std::string data;
if (UsesHttp3()) {
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- body.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ body.length(), quiche::SimpleBufferAllocator::Get());
data = absl::StrCat(header.AsStringView(), body);
header_length = header.size();
} else {
@@ -1053,8 +1053,8 @@
std::string data;
if (UsesHttp3()) {
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- body.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ body.length(), quiche::SimpleBufferAllocator::Get());
data = absl::StrCat(header.AsStringView(), body);
header_length = header.size();
} else {
@@ -1118,12 +1118,12 @@
if (UsesHttp3()) {
body = std::string(kWindow / 4 - 2, 'a');
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- body.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ body.length(), quiche::SimpleBufferAllocator::Get());
data = absl::StrCat(header.AsStringView(), body);
header_length = header.size();
- QuicBuffer header2 = HttpEncoder::SerializeDataFrameHeader(
- body.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header2 = HttpEncoder::SerializeDataFrameHeader(
+ body.length(), quiche::SimpleBufferAllocator::Get());
data2 = absl::StrCat(header2.AsStringView(), body2);
} else {
body = std::string(kWindow / 4, 'a');
@@ -1596,7 +1596,7 @@
QuicByteCount header_length = 0;
if (UsesHttp3()) {
header_length = HttpEncoder::SerializeDataFrameHeader(
- body.length(), SimpleBufferAllocator::Get())
+ body.length(), quiche::SimpleBufferAllocator::Get())
.size();
}
@@ -1940,10 +1940,10 @@
stream_->WriteOrBufferBody(body, false);
stream_->WriteOrBufferBody(body2, true);
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- body.length(), SimpleBufferAllocator::Get());
- QuicBuffer header2 = HttpEncoder::SerializeDataFrameHeader(
- body2.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ body.length(), quiche::SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header2 = HttpEncoder::SerializeDataFrameHeader(
+ body2.length(), quiche::SimpleBufferAllocator::Get());
EXPECT_CALL(*mock_ack_listener, OnPacketAcked(body.length(), _));
QuicStreamFrame frame(stream_->id(), false, 0,
diff --git a/quic/core/http/web_transport_stream_adapter.cc b/quic/core/http/web_transport_stream_adapter.cc
index eb42fd8..7c6e990 100644
--- a/quic/core/http/web_transport_stream_adapter.cc
+++ b/quic/core/http/web_transport_stream_adapter.cc
@@ -46,7 +46,7 @@
return false;
}
- quiche::QuicheMemSlice memslice(QuicBuffer::Copy(
+ quiche::QuicheMemSlice memslice(quiche::QuicheBuffer::Copy(
session_->connection()->helper()->GetStreamSendBufferAllocator(), data));
QuicConsumedData consumed =
stream_->WriteMemSlices(absl::MakeSpan(&memslice, 1), /*fin=*/false);
diff --git a/quic/core/quic_buffer_allocator.cc b/quic/core/quic_buffer_allocator.cc
deleted file mode 100644
index 41491d9..0000000
--- a/quic/core/quic_buffer_allocator.cc
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "quic/core/quic_buffer_allocator.h"
-
-namespace quic {
-
-QuicBufferAllocator::~QuicBufferAllocator() = default;
-
-} // namespace quic
diff --git a/quic/core/quic_buffer_allocator.h b/quic/core/quic_buffer_allocator.h
deleted file mode 100644
index 4d62f84..0000000
--- a/quic/core/quic_buffer_allocator.h
+++ /dev/null
@@ -1,117 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef QUICHE_QUIC_CORE_QUIC_BUFFER_ALLOCATOR_H_
-#define QUICHE_QUIC_CORE_QUIC_BUFFER_ALLOCATOR_H_
-
-#include <stddef.h>
-
-#include <memory>
-
-#include "absl/strings/string_view.h"
-#include "quic/platform/api/quic_export.h"
-
-namespace quic {
-
-// Abstract base class for classes which allocate and delete buffers.
-class QUIC_EXPORT_PRIVATE QuicBufferAllocator {
- public:
- virtual ~QuicBufferAllocator();
-
- // Returns or allocates a new buffer of |size|. Never returns null.
- virtual char* New(size_t size) = 0;
-
- // Returns or allocates a new buffer of |size| if |flag_enable| is true.
- // Otherwise, returns a buffer that is compatible with this class directly
- // with operator new. Never returns null.
- virtual char* New(size_t size, bool flag_enable) = 0;
-
- // Releases a buffer.
- virtual void Delete(char* buffer) = 0;
-
- // Marks the allocator as being idle. Serves as a hint to notify the allocator
- // that it should release any resources it's still holding on to.
- virtual void MarkAllocatorIdle() {}
-};
-
-// A deleter that can be used to manage ownership of buffers allocated via
-// QuicBufferAllocator through std::unique_ptr.
-class QUIC_EXPORT_PRIVATE QuicBufferDeleter {
- public:
- explicit QuicBufferDeleter(QuicBufferAllocator* allocator)
- : allocator_(allocator) {}
-
- QuicBufferAllocator* allocator() { return allocator_; }
- void operator()(char* buffer) { allocator_->Delete(buffer); }
-
- private:
- QuicBufferAllocator* allocator_;
-};
-
-using QuicUniqueBufferPtr = std::unique_ptr<char[], QuicBufferDeleter>;
-
-inline QuicUniqueBufferPtr MakeUniqueBuffer(QuicBufferAllocator* allocator,
- size_t size) {
- return QuicUniqueBufferPtr(allocator->New(size),
- QuicBufferDeleter(allocator));
-}
-
-// QuicUniqueBufferPtr with a length attached to it. Similar to QuicheMemSlice,
-// except unlike QuicheMemSlice, QuicBuffer is mutable and is not
-// platform-specific. Also unlike QuicheMemSlice, QuicBuffer can be empty.
-class QUIC_EXPORT_PRIVATE QuicBuffer {
- public:
- QuicBuffer() : buffer_(nullptr, QuicBufferDeleter(nullptr)), size_(0) {}
- QuicBuffer(QuicBufferAllocator* allocator, size_t size)
- : buffer_(MakeUniqueBuffer(allocator, size)), size_(size) {}
-
- QuicBuffer(QuicUniqueBufferPtr buffer, size_t size)
- : buffer_(std::move(buffer)), size_(size) {}
-
- // Make sure the move constructor zeroes out the size field.
- QuicBuffer(QuicBuffer&& other)
- : buffer_(std::move(other.buffer_)), size_(other.size_) {
- other.buffer_ = nullptr;
- other.size_ = 0;
- }
- QuicBuffer& operator=(QuicBuffer&& other) {
- buffer_ = std::move(other.buffer_);
- size_ = other.size_;
-
- other.buffer_ = nullptr;
- other.size_ = 0;
- return *this;
- }
-
- // Convenience method to initialize a QuicBuffer by copying from an existing
- // one.
- static QuicBuffer Copy(QuicBufferAllocator* allocator,
- absl::string_view data) {
- QuicBuffer result(allocator, data.size());
- memcpy(result.data(), data.data(), data.size());
- return result;
- }
-
- const char* data() const { return buffer_.get(); }
- char* data() { return buffer_.get(); }
- size_t size() const { return size_; }
- bool empty() const { return size_ == 0; }
- absl::string_view AsStringView() const {
- return absl::string_view(data(), size());
- }
-
- // Releases the ownership of the underlying buffer.
- QuicUniqueBufferPtr Release() {
- size_ = 0;
- return std::move(buffer_);
- }
-
- private:
- QuicUniqueBufferPtr buffer_;
- size_t size_;
-};
-
-} // namespace quic
-
-#endif // QUICHE_QUIC_CORE_QUIC_BUFFER_ALLOCATOR_H_
diff --git a/quic/core/quic_coalesced_packet.cc b/quic/core/quic_coalesced_packet.cc
index 52673b6..e8ce931 100644
--- a/quic/core/quic_coalesced_packet.cc
+++ b/quic/core/quic_coalesced_packet.cc
@@ -18,10 +18,9 @@
}
bool QuicCoalescedPacket::MaybeCoalescePacket(
- const SerializedPacket& packet,
- const QuicSocketAddress& self_address,
+ const SerializedPacket& packet, const QuicSocketAddress& self_address,
const QuicSocketAddress& peer_address,
- QuicBufferAllocator* allocator,
+ quiche::QuicheBufferAllocator* allocator,
QuicPacketLength current_max_packet_length) {
if (packet.encrypted_length == 0) {
QUIC_BUG(quic_bug_10611_1) << "Trying to coalesce an empty packet";
diff --git a/quic/core/quic_coalesced_packet.h b/quic/core/quic_coalesced_packet.h
index e8bc2c3..9b8295c 100644
--- a/quic/core/quic_coalesced_packet.h
+++ b/quic/core/quic_coalesced_packet.h
@@ -21,7 +21,7 @@
bool MaybeCoalescePacket(const SerializedPacket& packet,
const QuicSocketAddress& self_address,
const QuicSocketAddress& peer_address,
- QuicBufferAllocator* allocator,
+ quiche::QuicheBufferAllocator* allocator,
QuicPacketLength current_max_packet_length);
// Clears this coalesced packet.
diff --git a/quic/core/quic_coalesced_packet_test.cc b/quic/core/quic_coalesced_packet_test.cc
index 34f6da3..f626891 100644
--- a/quic/core/quic_coalesced_packet_test.cc
+++ b/quic/core/quic_coalesced_packet_test.cc
@@ -17,7 +17,7 @@
QuicCoalescedPacket coalesced;
EXPECT_EQ("total_length: 0 padding_size: 0 packets: {}",
coalesced.ToString(0));
- SimpleBufferAllocator allocator;
+ quiche::SimpleBufferAllocator allocator;
EXPECT_EQ(0u, coalesced.length());
EXPECT_EQ(0u, coalesced.NumberOfPackets());
char buffer[1000];
@@ -96,7 +96,7 @@
TEST(QuicCoalescedPacketTest, CopyEncryptedBuffers) {
QuicCoalescedPacket coalesced;
- SimpleBufferAllocator allocator;
+ quiche::SimpleBufferAllocator allocator;
QuicSocketAddress self_address(QuicIpAddress::Loopback4(), 1);
QuicSocketAddress peer_address(QuicIpAddress::Loopback4(), 2);
std::string buffer(500, 'a');
@@ -139,7 +139,7 @@
EXPECT_EQ("total_length: 0 padding_size: 0 packets: {}",
coalesced.ToString(0));
- SimpleBufferAllocator allocator;
+ quiche::SimpleBufferAllocator allocator;
EXPECT_EQ(0u, coalesced.length());
char buffer[1000];
QuicSocketAddress self_address(QuicIpAddress::Loopback4(), 1);
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index 42b4358..40c55a3 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -452,8 +452,8 @@
// Returns a QuicRandom to be used for all random number related functions.
virtual QuicRandom* GetRandomGenerator() = 0;
- // Returns a QuicBufferAllocator to be used for stream send buffers.
- virtual QuicBufferAllocator* GetStreamSendBufferAllocator() = 0;
+ // Returns a QuicheBufferAllocator to be used for stream send buffers.
+ virtual quiche::QuicheBufferAllocator* GetStreamSendBufferAllocator() = 0;
};
class QUIC_EXPORT_PRIVATE QuicConnection
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 1162de1..fc4df23 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -30,7 +30,6 @@
#include "quic/core/quic_packet_creator.h"
#include "quic/core/quic_packets.h"
#include "quic/core/quic_path_validator.h"
-#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/core/quic_types.h"
#include "quic/core/quic_utils.h"
#include "quic/core/quic_versions.h"
@@ -53,6 +52,7 @@
#include "quic/test_tools/quic_test_utils.h"
#include "quic/test_tools/simple_data_producer.h"
#include "quic/test_tools/simple_session_notifier.h"
+#include "common/simple_buffer_allocator.h"
using testing::_;
using testing::AnyNumber;
@@ -169,14 +169,14 @@
QuicRandom* GetRandomGenerator() override { return random_generator_; }
- QuicBufferAllocator* GetStreamSendBufferAllocator() override {
+ quiche::QuicheBufferAllocator* GetStreamSendBufferAllocator() override {
return &buffer_allocator_;
}
private:
MockClock* clock_;
MockRandom* random_generator_;
- SimpleBufferAllocator buffer_allocator_;
+ quiche::SimpleBufferAllocator buffer_allocator_;
};
class TestConnection : public QuicConnection {
@@ -1068,7 +1068,7 @@
MessageStatus SendMessage(absl::string_view message) {
connection_.SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
- quiche::QuicheMemSlice slice(QuicBuffer::Copy(
+ quiche::QuicheMemSlice slice(quiche::QuicheBuffer::Copy(
connection_.helper()->GetStreamSendBufferAllocator(), message));
return connection_.SendMessage(1, absl::MakeSpan(&slice, 1), false);
}
@@ -1465,7 +1465,7 @@
std::unique_ptr<MockLossAlgorithm> loss_algorithm_;
MockClock clock_;
MockRandom random_generator_;
- SimpleBufferAllocator buffer_allocator_;
+ quiche::SimpleBufferAllocator buffer_allocator_;
std::unique_ptr<TestConnectionHelper> helper_;
std::unique_ptr<TestAlarmFactory> alarm_factory_;
QuicFramer peer_framer_;
diff --git a/quic/core/quic_datagram_queue_test.cc b/quic/core/quic_datagram_queue_test.cc
index 041275c..295e72a 100644
--- a/quic/core/quic_datagram_queue_test.cc
+++ b/quic/core/quic_datagram_queue_test.cc
@@ -9,13 +9,13 @@
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "quic/core/crypto/null_encrypter.h"
-#include "quic/core/quic_buffer_allocator.h"
#include "quic/core/quic_time.h"
#include "quic/core/quic_types.h"
#include "quic/platform/api/quic_reference_counted.h"
#include "quic/platform/api/quic_test.h"
#include "quic/test_tools/quic_test_utils.h"
#include "common/platform/api/quiche_mem_slice.h"
+#include "common/quiche_buffer_allocator.h"
namespace quic {
namespace test {
@@ -71,8 +71,8 @@
~QuicDatagramQueueTestBase() = default;
quiche::QuicheMemSlice CreateMemSlice(absl::string_view data) {
- return quiche::QuicheMemSlice(
- QuicBuffer::Copy(helper_.GetStreamSendBufferAllocator(), data));
+ return quiche::QuicheMemSlice(quiche::QuicheBuffer::Copy(
+ helper_.GetStreamSendBufferAllocator(), data));
}
MockQuicConnectionHelper helper_;
diff --git a/quic/core/quic_dispatcher.cc b/quic/core/quic_dispatcher.cc
index 0da608c..1cc4cf3 100644
--- a/quic/core/quic_dispatcher.cc
+++ b/quic/core/quic_dispatcher.cc
@@ -77,7 +77,7 @@
class PacketCollector : public QuicPacketCreator::DelegateInterface,
public QuicStreamFrameDataProducer {
public:
- explicit PacketCollector(QuicBufferAllocator* allocator)
+ explicit PacketCollector(quiche::QuicheBufferAllocator* allocator)
: send_buffer_(allocator) {}
~PacketCollector() override = default;
diff --git a/quic/core/quic_epoll_connection_helper.cc b/quic/core/quic_epoll_connection_helper.cc
index 42d2e02..980a09f 100644
--- a/quic/core/quic_epoll_connection_helper.cc
+++ b/quic/core/quic_epoll_connection_helper.cc
@@ -27,7 +27,8 @@
return random_generator_;
}
-QuicBufferAllocator* QuicEpollConnectionHelper::GetStreamSendBufferAllocator() {
+quiche::QuicheBufferAllocator*
+QuicEpollConnectionHelper::GetStreamSendBufferAllocator() {
if (allocator_type_ == QuicAllocator::BUFFER_POOL) {
return &stream_buffer_allocator_;
} else {
diff --git a/quic/core/quic_epoll_connection_helper.h b/quic/core/quic_epoll_connection_helper.h
index d363d6b..e433ff5 100644
--- a/quic/core/quic_epoll_connection_helper.h
+++ b/quic/core/quic_epoll_connection_helper.h
@@ -9,17 +9,18 @@
#define QUICHE_QUIC_CORE_QUIC_EPOLL_CONNECTION_HELPER_H_
#include <sys/types.h>
+
#include <set>
#include "quic/core/quic_connection.h"
#include "quic/core/quic_default_packet_writer.h"
#include "quic/core/quic_packet_writer.h"
#include "quic/core/quic_packets.h"
-#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/core/quic_time.h"
#include "quic/platform/api/quic_epoll.h"
#include "quic/platform/api/quic_stream_buffer_allocator.h"
#include "net/quic/platform/impl/quic_epoll_clock.h"
+#include "common/simple_buffer_allocator.h"
namespace quic {
@@ -40,7 +41,7 @@
// QuicConnectionHelperInterface
const QuicClock* GetClock() const override;
QuicRandom* GetRandomGenerator() override;
- QuicBufferAllocator* GetStreamSendBufferAllocator() override;
+ quiche::QuicheBufferAllocator* GetStreamSendBufferAllocator() override;
private:
const QuicEpollClock clock_;
@@ -48,7 +49,7 @@
// Set up allocators. They take up minimal memory before use.
// Allocator for stream send buffers.
QuicStreamBufferAllocator stream_buffer_allocator_;
- SimpleBufferAllocator simple_buffer_allocator_;
+ quiche::SimpleBufferAllocator simple_buffer_allocator_;
QuicAllocator allocator_type_;
};
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index d24664d..150f2b8 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -921,7 +921,7 @@
QuicTime start_;
QuicFramer framer_;
test::TestQuicVisitor visitor_;
- SimpleBufferAllocator allocator_;
+ quiche::SimpleBufferAllocator allocator_;
};
// Multiple test cases of QuicFramerTest use byte arrays to define packets for
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index c7b7dcb..3b56f82 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -21,7 +21,6 @@
#include "quic/core/frames/quic_stream_frame.h"
#include "quic/core/quic_connection_id.h"
#include "quic/core/quic_data_writer.h"
-#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/core/quic_types.h"
#include "quic/core/quic_utils.h"
#include "quic/platform/api/quic_expect_bug.h"
@@ -33,6 +32,7 @@
#include "quic/test_tools/quic_test_utils.h"
#include "quic/test_tools/simple_data_producer.h"
#include "quic/test_tools/simple_quic_framer.h"
+#include "common/simple_buffer_allocator.h"
#include "common/test_tools/quiche_test_utils.h"
using ::testing::_;
@@ -287,7 +287,7 @@
TestPacketCreator creator_;
std::unique_ptr<SerializedPacket> serialized_packet_;
SimpleDataProducer producer_;
- SimpleBufferAllocator allocator_;
+ quiche::SimpleBufferAllocator allocator_;
};
// Run all packet creator tests with all supported versions of QUIC, and with
@@ -2140,7 +2140,7 @@
TEST_P(QuicPacketCreatorTest, SerializeCoalescedPacket) {
QuicCoalescedPacket coalesced;
- SimpleBufferAllocator allocator;
+ quiche::SimpleBufferAllocator allocator;
QuicSocketAddress self_address(QuicIpAddress::Loopback4(), 1);
QuicSocketAddress peer_address(QuicIpAddress::Loopback4(), 2);
for (size_t i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; ++i) {
@@ -2606,7 +2606,7 @@
std::vector<SerializedPacket> packets_;
QuicAckFrame ack_frame_;
struct iovec iov_;
- SimpleBufferAllocator allocator_;
+ quiche::SimpleBufferAllocator allocator_;
private:
std::unique_ptr<char[]> data_array_;
diff --git a/quic/core/quic_packets.cc b/quic/core/quic_packets.cc
index d625b5d..91840f8 100644
--- a/quic/core/quic_packets.cc
+++ b/quic/core/quic_packets.cc
@@ -511,7 +511,7 @@
}
SerializedPacket* CopySerializedPacket(const SerializedPacket& serialized,
- QuicBufferAllocator* allocator,
+ quiche::QuicheBufferAllocator* allocator,
bool copy_buffer) {
SerializedPacket* copy = new SerializedPacket(
serialized.packet_number, serialized.packet_number_length,
diff --git a/quic/core/quic_packets.h b/quic/core/quic_packets.h
index c79e5a5..c373327 100644
--- a/quic/core/quic_packets.h
+++ b/quic/core/quic_packets.h
@@ -410,8 +410,7 @@
// indicates whether the encrypted buffer should be copied.
QUIC_EXPORT_PRIVATE SerializedPacket* CopySerializedPacket(
const SerializedPacket& serialized,
- QuicBufferAllocator* allocator,
- bool copy_buffer);
+ quiche::QuicheBufferAllocator* allocator, bool copy_buffer);
// Allocates a new char[] of size |packet.encrypted_length| and copies in
// |packet.encrypted_buffer|.
diff --git a/quic/core/quic_packets_test.cc b/quic/core/quic_packets_test.cc
index a07e289..ce7cf8e 100644
--- a/quic/core/quic_packets_test.cc
+++ b/quic/core/quic_packets_test.cc
@@ -74,7 +74,7 @@
TEST_F(QuicPacketsTest, CopySerializedPacket) {
std::string buffer(1000, 'a');
- SimpleBufferAllocator allocator;
+ quiche::SimpleBufferAllocator allocator;
SerializedPacket packet(QuicPacketNumber(1), PACKET_1BYTE_PACKET_NUMBER,
buffer.data(), buffer.length(), /*has_ack=*/false,
/*has_stop_waiting=*/false);
diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc
index 565eb96..02ae04c 100644
--- a/quic/core/quic_sent_packet_manager_test.cc
+++ b/quic/core/quic_sent_packet_manager_test.cc
@@ -335,7 +335,7 @@
return 4;
}
- SimpleBufferAllocator allocator_;
+ quiche::SimpleBufferAllocator allocator_;
QuicSentPacketManager manager_;
MockClock clock_;
QuicConnectionStats stats_;
@@ -4495,7 +4495,7 @@
QuicMessageFrame* message_frame = nullptr;
{
- quiche::QuicheMemSlice slice(QuicBuffer(&allocator_, 1024));
+ quiche::QuicheMemSlice slice(quiche::QuicheBuffer(&allocator_, 1024));
message_frame = new QuicMessageFrame(/*message_id=*/1, std::move(slice));
EXPECT_FALSE(message_frame->message_data.empty());
EXPECT_EQ(message_frame->message_length, 1024);
diff --git a/quic/core/quic_stream_send_buffer.cc b/quic/core/quic_stream_send_buffer.cc
index e1e437b..aa58ead 100644
--- a/quic/core/quic_stream_send_buffer.cc
+++ b/quic/core/quic_stream_send_buffer.cc
@@ -47,7 +47,8 @@
return offset == other.offset && length == other.length;
}
-QuicStreamSendBuffer::QuicStreamSendBuffer(QuicBufferAllocator* allocator)
+QuicStreamSendBuffer::QuicStreamSendBuffer(
+ quiche::QuicheBufferAllocator* allocator)
: current_end_offset_(0),
stream_offset_(0),
allocator_(allocator),
@@ -67,7 +68,7 @@
GetQuicFlag(FLAGS_quic_send_buffer_max_data_slice_size);
while (data_length > 0) {
size_t slice_len = std::min(data_length, max_data_slice_size);
- QuicBuffer buffer(allocator_, slice_len);
+ quiche::QuicheBuffer buffer(allocator_, slice_len);
QuicUtils::CopyToBuffer(iov, iov_count, iov_offset, slice_len,
buffer.data());
SaveMemSlice(quiche::QuicheMemSlice(std::move(buffer)));
diff --git a/quic/core/quic_stream_send_buffer.h b/quic/core/quic_stream_send_buffer.h
index 2069e8b..6fe7b75 100644
--- a/quic/core/quic_stream_send_buffer.h
+++ b/quic/core/quic_stream_send_buffer.h
@@ -64,7 +64,7 @@
// across slice boundaries.
class QUIC_EXPORT_PRIVATE QuicStreamSendBuffer {
public:
- explicit QuicStreamSendBuffer(QuicBufferAllocator* allocator);
+ explicit QuicStreamSendBuffer(quiche::QuicheBufferAllocator* allocator);
QuicStreamSendBuffer(const QuicStreamSendBuffer& other) = delete;
QuicStreamSendBuffer(QuicStreamSendBuffer&& other) = delete;
~QuicStreamSendBuffer();
@@ -153,7 +153,7 @@
// Offset of next inserted byte.
QuicStreamOffset stream_offset_;
- QuicBufferAllocator* allocator_;
+ quiche::QuicheBufferAllocator* allocator_;
// Bytes that have been consumed by the stream.
uint64_t stream_bytes_written_;
diff --git a/quic/core/quic_stream_send_buffer_test.cc b/quic/core/quic_stream_send_buffer_test.cc
index 15e0d3f..2e0f9dc 100644
--- a/quic/core/quic_stream_send_buffer_test.cc
+++ b/quic/core/quic_stream_send_buffer_test.cc
@@ -8,13 +8,13 @@
#include "absl/strings/string_view.h"
#include "quic/core/quic_data_writer.h"
-#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/core/quic_utils.h"
#include "quic/platform/api/quic_expect_bug.h"
#include "quic/platform/api/quic_flags.h"
#include "quic/platform/api/quic_test.h"
#include "quic/test_tools/quic_stream_send_buffer_peer.h"
#include "quic/test_tools/quic_test_utils.h"
+#include "common/simple_buffer_allocator.h"
namespace quic {
namespace test {
@@ -38,10 +38,10 @@
iov[0] = MakeIovec(absl::string_view(data1));
iov[1] = MakeIovec(absl::string_view(data2));
- QuicBuffer buffer1(&allocator_, 1024);
+ quiche::QuicheBuffer buffer1(&allocator_, 1024);
memset(buffer1.data(), 'c', buffer1.size());
quiche::QuicheMemSlice slice1(std::move(buffer1));
- QuicBuffer buffer2(&allocator_, 768);
+ quiche::QuicheBuffer buffer2(&allocator_, 768);
memset(buffer2.data(), 'd', buffer2.size());
quiche::QuicheMemSlice slice2(std::move(buffer2));
@@ -73,7 +73,7 @@
EXPECT_EQ(3840u, send_buffer_.stream_bytes_outstanding());
}
- SimpleBufferAllocator allocator_;
+ quiche::SimpleBufferAllocator allocator_;
QuicStreamSendBuffer send_buffer_;
};
@@ -308,7 +308,7 @@
// Last offset is end offset of last slice.
EXPECT_EQ(3840u, QuicStreamSendBufferPeer::EndOffset(&send_buffer_));
- QuicBuffer buffer(&allocator_, 60);
+ quiche::QuicheBuffer buffer(&allocator_, 60);
memset(buffer.data(), 'e', buffer.size());
quiche::QuicheMemSlice slice(std::move(buffer));
send_buffer_.SaveMemSlice(std::move(slice));
@@ -317,7 +317,7 @@
}
TEST_F(QuicStreamSendBufferTest, SaveMemSliceSpan) {
- SimpleBufferAllocator allocator;
+ quiche::SimpleBufferAllocator allocator;
QuicStreamSendBuffer send_buffer(&allocator);
std::string data(1024, 'a');
@@ -331,7 +331,7 @@
}
TEST_F(QuicStreamSendBufferTest, SaveEmptyMemSliceSpan) {
- SimpleBufferAllocator allocator;
+ quiche::SimpleBufferAllocator allocator;
QuicStreamSendBuffer send_buffer(&allocator);
std::string data(1024, 'a');
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index 7c97ce9..a1c0560 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -1249,14 +1249,18 @@
Initialize();
constexpr QuicByteCount kDataSize = 1024;
- QuicBufferAllocator* allocator =
+ quiche::QuicheBufferAllocator* allocator =
connection_->helper()->GetStreamSendBufferAllocator();
std::vector<quiche::QuicheMemSlice> vector1;
- vector1.push_back(quiche::QuicheMemSlice(QuicBuffer(allocator, kDataSize)));
- vector1.push_back(quiche::QuicheMemSlice(QuicBuffer(allocator, kDataSize)));
+ vector1.push_back(
+ quiche::QuicheMemSlice(quiche::QuicheBuffer(allocator, kDataSize)));
+ vector1.push_back(
+ quiche::QuicheMemSlice(quiche::QuicheBuffer(allocator, kDataSize)));
std::vector<quiche::QuicheMemSlice> vector2;
- vector2.push_back(quiche::QuicheMemSlice(QuicBuffer(allocator, kDataSize)));
- vector2.push_back(quiche::QuicheMemSlice(QuicBuffer(allocator, kDataSize)));
+ vector2.push_back(
+ quiche::QuicheMemSlice(quiche::QuicheBuffer(allocator, kDataSize)));
+ vector2.push_back(
+ quiche::QuicheMemSlice(quiche::QuicheBuffer(allocator, kDataSize)));
absl::Span<quiche::QuicheMemSlice> span1(vector1);
absl::Span<quiche::QuicheMemSlice> span2(vector2);
diff --git a/quic/masque/masque_compression_engine.cc b/quic/masque/masque_compression_engine.cc
index ca9ed93..69f75c0 100644
--- a/quic/masque/masque_compression_engine.cc
+++ b/quic/masque/masque_compression_engine.cc
@@ -7,7 +7,6 @@
#include <cstdint>
#include "absl/strings/string_view.h"
-#include "quic/core/quic_buffer_allocator.h"
#include "quic/core/quic_data_reader.h"
#include "quic/core/quic_data_writer.h"
#include "quic/core/quic_framer.h"
@@ -16,6 +15,7 @@
#include "quic/core/quic_versions.h"
#include "quic/platform/api/quic_containers.h"
#include "common/platform/api/quiche_mem_slice.h"
+#include "common/quiche_buffer_allocator.h"
#include "common/quiche_text_utils.h"
namespace quic {
@@ -269,7 +269,7 @@
sizeof(server_address.port()) + sizeof(uint8_t) +
server_address.host().ToPackedString().length();
}
- QuicBuffer buffer(
+ quiche::QuicheBuffer buffer(
masque_session_->connection()->helper()->GetStreamSendBufferAllocator(),
slice_length);
QuicDataWriter writer(buffer.size(), buffer.data());
diff --git a/quic/qbone/qbone_session_base.cc b/quic/qbone/qbone_session_base.cc
index a5e8a2d..c12ec4e 100644
--- a/quic/qbone/qbone_session_base.cc
+++ b/quic/qbone/qbone_session_base.cc
@@ -10,7 +10,6 @@
#include <utility>
#include "absl/strings/string_view.h"
-#include "quic/core/quic_buffer_allocator.h"
#include "quic/core/quic_data_reader.h"
#include "quic/core/quic_types.h"
#include "quic/platform/api/quic_exported_stats.h"
@@ -20,6 +19,7 @@
#include "quic/qbone/qbone_constants.h"
#include "common/platform/api/quiche_command_line_flags.h"
#include "common/platform/api/quiche_mem_slice.h"
+#include "common/quiche_buffer_allocator.h"
DEFINE_QUICHE_COMMAND_LINE_FLAG(
bool, qbone_close_ephemeral_frames, true,
@@ -140,7 +140,7 @@
}
if (send_packets_as_messages_) {
- quiche::QuicheMemSlice slice(QuicBuffer::Copy(
+ quiche::QuicheMemSlice slice(quiche::QuicheBuffer::Copy(
connection()->helper()->GetStreamSendBufferAllocator(), packet));
switch (SendMessage(absl::MakeSpan(&slice, 1), /*flush=*/true).status) {
case MESSAGE_STATUS_SUCCESS:
diff --git a/quic/qbone/qbone_stream_test.cc b/quic/qbone/qbone_stream_test.cc
index 8e724a4..c2c862a 100644
--- a/quic/qbone/qbone_stream_test.cc
+++ b/quic/qbone/qbone_stream_test.cc
@@ -9,7 +9,6 @@
#include "absl/strings/string_view.h"
#include "quic/core/crypto/quic_random.h"
#include "quic/core/quic_session.h"
-#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/core/quic_utils.h"
#include "quic/platform/api/quic_test.h"
#include "quic/platform/api/quic_test_loopback.h"
@@ -17,6 +16,7 @@
#include "quic/qbone/qbone_session_base.h"
#include "quic/test_tools/mock_clock.h"
#include "quic/test_tools/quic_test_utils.h"
+#include "common/simple_buffer_allocator.h"
#include "spdy/core/spdy_protocol.h"
namespace quic {
@@ -159,7 +159,7 @@
return QuicRandom::GetInstance();
}
- QuicBufferAllocator* GetStreamSendBufferAllocator() override {
+ quiche::QuicheBufferAllocator* GetStreamSendBufferAllocator() override {
return &buffer_allocator_;
}
@@ -170,7 +170,7 @@
std::unique_ptr<QuicAlarmFactory> alarm_factory_;
std::unique_ptr<QuicConnection> connection_;
// Used to implement the QuicConnectionHelperInterface.
- SimpleBufferAllocator buffer_allocator_;
+ quiche::SimpleBufferAllocator buffer_allocator_;
MockClock clock_;
const QuicStreamId kStreamId = QuicUtils::GetFirstUnidirectionalStreamId(
CurrentSupportedVersions()[0].transport_version, Perspective::IS_CLIENT);
diff --git a/quic/quic_transport/quic_transport_integration_test.cc b/quic/quic_transport/quic_transport_integration_test.cc
index 7bb8479..742fd46 100644
--- a/quic/quic_transport/quic_transport_integration_test.cc
+++ b/quic/quic_transport/quic_transport_integration_test.cc
@@ -13,7 +13,6 @@
#include "url/origin.h"
#include "quic/core/crypto/quic_crypto_client_config.h"
#include "quic/core/crypto/quic_crypto_server_config.h"
-#include "quic/core/quic_buffer_allocator.h"
#include "quic/core/quic_connection.h"
#include "quic/core/quic_error_codes.h"
#include "quic/core/quic_types.h"
diff --git a/quic/quic_transport/quic_transport_stream.cc b/quic/quic_transport/quic_transport_stream.cc
index 4def1de..a66f24c 100644
--- a/quic/quic_transport/quic_transport_stream.cc
+++ b/quic/quic_transport/quic_transport_stream.cc
@@ -7,7 +7,6 @@
#include <sys/types.h>
#include "absl/strings/string_view.h"
-#include "quic/core/quic_buffer_allocator.h"
#include "quic/core/quic_error_codes.h"
#include "quic/core/quic_types.h"
#include "quic/core/quic_utils.h"
diff --git a/quic/test_tools/quic_test_backend.cc b/quic/test_tools/quic_test_backend.cc
index 12f530a..f84e93e 100644
--- a/quic/test_tools/quic_test_backend.cc
+++ b/quic/test_tools/quic_test_backend.cc
@@ -10,8 +10,6 @@
#include "absl/strings/str_cat.h"
#include "absl/strings/str_split.h"
#include "absl/strings/string_view.h"
-#include "quic/core/quic_buffer_allocator.h"
-#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/core/web_transport_interface.h"
#include "quic/test_tools/web_transport_resets_backend.h"
#include "quic/tools/web_transport_test_visitors.h"
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index 52eafed..9bc950f 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -21,12 +21,10 @@
#include "quic/core/crypto/quic_decrypter.h"
#include "quic/core/crypto/quic_encrypter.h"
#include "quic/core/http/quic_spdy_client_session.h"
-#include "quic/core/quic_buffer_allocator.h"
#include "quic/core/quic_config.h"
#include "quic/core/quic_data_writer.h"
#include "quic/core/quic_framer.h"
#include "quic/core/quic_packet_creator.h"
-#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/core/quic_types.h"
#include "quic/core/quic_utils.h"
#include "quic/core/quic_versions.h"
@@ -36,7 +34,9 @@
#include "quic/test_tools/crypto_test_utils.h"
#include "quic/test_tools/quic_config_peer.h"
#include "quic/test_tools/quic_connection_peer.h"
+#include "common/quiche_buffer_allocator.h"
#include "common/quiche_endian.h"
+#include "common/simple_buffer_allocator.h"
#include "spdy/core/spdy_frame_builder.h"
using testing::_;
@@ -486,7 +486,8 @@
}
}
-QuicBufferAllocator* MockQuicConnectionHelper::GetStreamSendBufferAllocator() {
+quiche::QuicheBufferAllocator*
+MockQuicConnectionHelper::GetStreamSendBufferAllocator() {
return &buffer_allocator_;
}
@@ -1315,8 +1316,9 @@
return quiche::QuicheMemSlice();
}
- static SimpleBufferAllocator* allocator = new SimpleBufferAllocator();
- return quiche::QuicheMemSlice(QuicBuffer::Copy(allocator, data));
+ static quiche::SimpleBufferAllocator* allocator =
+ new quiche::SimpleBufferAllocator();
+ return quiche::QuicheMemSlice(quiche::QuicheBuffer::Copy(allocator, data));
}
bool TaggingEncrypter::EncryptPacket(uint64_t /*packet_number*/,
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 3f6842e..869e416 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -30,7 +30,6 @@
#include "quic/core/quic_path_validator.h"
#include "quic/core/quic_sent_packet_manager.h"
#include "quic/core/quic_server_id.h"
-#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/core/quic_types.h"
#include "quic/core/quic_utils.h"
#include "quic/platform/api/quic_socket_address.h"
@@ -41,6 +40,7 @@
#include "quic/test_tools/quic_framer_peer.h"
#include "quic/test_tools/simple_quic_framer.h"
#include "common/quiche_mem_slice_storage.h"
+#include "common/simple_buffer_allocator.h"
namespace quic {
@@ -517,13 +517,13 @@
~MockQuicConnectionHelper() override;
const QuicClock* GetClock() const override;
QuicRandom* GetRandomGenerator() override;
- QuicBufferAllocator* GetStreamSendBufferAllocator() override;
+ quiche::QuicheBufferAllocator* GetStreamSendBufferAllocator() override;
void AdvanceTime(QuicTime::Delta delta);
private:
MockClock clock_;
MockRandom random_generator_;
- SimpleBufferAllocator buffer_allocator_;
+ quiche::SimpleBufferAllocator buffer_allocator_;
};
class MockAlarmFactory : public QuicAlarmFactory {
diff --git a/quic/test_tools/simple_data_producer.h b/quic/test_tools/simple_data_producer.h
index dc0c076..e8dd4e4 100644
--- a/quic/test_tools/simple_data_producer.h
+++ b/quic/test_tools/simple_data_producer.h
@@ -7,10 +7,10 @@
#include "absl/container/flat_hash_map.h"
#include "absl/strings/string_view.h"
-#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/core/quic_stream_frame_data_producer.h"
#include "quic/core/quic_stream_send_buffer.h"
#include "quic/platform/api/quic_containers.h"
+#include "common/simple_buffer_allocator.h"
namespace quic {
@@ -57,7 +57,7 @@
absl::flat_hash_map<std::pair<EncryptionLevel, QuicStreamOffset>,
std::string>;
- SimpleBufferAllocator allocator_;
+ quiche::SimpleBufferAllocator allocator_;
SendBufferMap send_buffer_map_;
diff --git a/quic/test_tools/simulator/simulator.cc b/quic/test_tools/simulator/simulator.cc
index a9835e8..2cdfe44 100644
--- a/quic/test_tools/simulator/simulator.cc
+++ b/quic/test_tools/simulator/simulator.cc
@@ -113,7 +113,7 @@
return random_generator_;
}
-QuicBufferAllocator* Simulator::GetStreamSendBufferAllocator() {
+quiche::QuicheBufferAllocator* Simulator::GetStreamSendBufferAllocator() {
return &buffer_allocator_;
}
diff --git a/quic/test_tools/simulator/simulator.h b/quic/test_tools/simulator/simulator.h
index b4298f5..225441d 100644
--- a/quic/test_tools/simulator/simulator.h
+++ b/quic/test_tools/simulator/simulator.h
@@ -10,11 +10,11 @@
#include "absl/container/flat_hash_map.h"
#include "absl/container/flat_hash_set.h"
#include "quic/core/quic_connection.h"
-#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/platform/api/quic_bug_tracker.h"
#include "quic/platform/api/quic_containers.h"
#include "quic/test_tools/simulator/actor.h"
#include "quic/test_tools/simulator/alarm_factory.h"
+#include "common/simple_buffer_allocator.h"
namespace quic {
namespace simulator {
@@ -42,7 +42,7 @@
// Begin QuicConnectionHelperInterface implementation.
const QuicClock* GetClock() const override;
QuicRandom* GetRandomGenerator() override;
- QuicBufferAllocator* GetStreamSendBufferAllocator() override;
+ quiche::QuicheBufferAllocator* GetStreamSendBufferAllocator() override;
// End QuicConnectionHelperInterface implementation.
QuicAlarmFactory* GetAlarmFactory();
@@ -110,7 +110,7 @@
Clock clock_;
QuicRandom* random_generator_;
- SimpleBufferAllocator buffer_allocator_;
+ quiche::SimpleBufferAllocator buffer_allocator_;
AlarmFactory alarm_factory_;
// Alarm for RunFor() method.
diff --git a/quic/tools/quic_simple_server_stream_test.cc b/quic/tools/quic_simple_server_stream_test.cc
index b75246f..40b470e 100644
--- a/quic/tools/quic_simple_server_stream_test.cc
+++ b/quic/tools/quic_simple_server_stream_test.cc
@@ -16,7 +16,6 @@
#include "quic/core/http/http_encoder.h"
#include "quic/core/http/spdy_utils.h"
#include "quic/core/quic_error_codes.h"
-#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/core/quic_types.h"
#include "quic/core/quic_utils.h"
#include "quic/platform/api/quic_expect_bug.h"
@@ -32,6 +31,7 @@
#include "quic/tools/quic_backend_response.h"
#include "quic/tools/quic_memory_cache_backend.h"
#include "quic/tools/quic_simple_server_session.h"
+#include "common/simple_buffer_allocator.h"
using testing::_;
using testing::AnyNumber;
@@ -280,8 +280,8 @@
.WillRepeatedly(
Invoke(&session_, &MockQuicSimpleServerSession::ConsumeData));
stream_->OnStreamHeaderList(false, kFakeFrameLen, header_list_);
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- body_.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ body_.length(), quiche::SimpleBufferAllocator::Get());
std::string data =
UsesHttp3() ? absl::StrCat(header.AsStringView(), body_) : body_;
stream_->OnStreamFrame(
@@ -298,8 +298,8 @@
Invoke(&session_, &MockQuicSimpleServerSession::ConsumeData));
stream_->OnStreamHeaderList(false, kFakeFrameLen, header_list_);
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- body_.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ body_.length(), quiche::SimpleBufferAllocator::Get());
std::string data =
UsesHttp3() ? absl::StrCat(header.AsStringView(), body_) : body_;
stream_->OnStreamFrame(
@@ -349,8 +349,8 @@
EXPECT_CALL(session_, WritevData(_, kErrorLength, _, FIN, _, _));
stream_->OnStreamHeaderList(false, kFakeFrameLen, header_list_);
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- body_.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ body_.length(), quiche::SimpleBufferAllocator::Get());
std::string data =
UsesHttp3() ? absl::StrCat(header.AsStringView(), body_) : body_;
@@ -358,8 +358,8 @@
QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, data));
// Content length is still 11. This will register as an error and we won't
// accept the bytes.
- header = HttpEncoder::SerializeDataFrameHeader(large_body.length(),
- SimpleBufferAllocator::Get());
+ header = HttpEncoder::SerializeDataFrameHeader(
+ large_body.length(), quiche::SimpleBufferAllocator::Get());
std::string data2 = UsesHttp3()
? absl::StrCat(header.AsStringView(), large_body)
: large_body;
@@ -381,8 +381,8 @@
response_headers_[":status"] = "200 OK";
response_headers_["content-length"] = "5";
std::string body = "Yummm";
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- body.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ body.length(), quiche::SimpleBufferAllocator::Get());
memory_cache_backend_.AddResponse("www.google.com", "/bar",
std::move(response_headers_), body);
@@ -413,8 +413,8 @@
response_headers_["content-length"] = "5";
std::string body = "Yummm";
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- body.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ body.length(), quiche::SimpleBufferAllocator::Get());
memory_cache_backend_.AddResponse("www.google.com", "/bar",
std::move(response_headers_), body);
@@ -482,8 +482,8 @@
response_headers_["content-length"] = "5";
std::string body = "Yummm";
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- body.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ body.length(), quiche::SimpleBufferAllocator::Get());
memory_cache_backend_.AddResponse("www.google.com", "/bar",
std::move(response_headers_), body);
@@ -512,8 +512,8 @@
(*request_headers)[":authority"] = host;
(*request_headers)[":method"] = "GET";
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- body.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ body.length(), quiche::SimpleBufferAllocator::Get());
std::vector<spdy::Http2HeaderBlock> early_hints;
// Add two Early Hints.
const size_t kNumEarlyHintsResponses = 2;
@@ -581,8 +581,8 @@
response_headers_[":status"] = "200";
response_headers_["content-length"] = "5";
const std::string kBody = "Hello";
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- body_.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ body_.length(), quiche::SimpleBufferAllocator::Get());
memory_cache_backend_.AddResponse(kHost, kPath, std::move(response_headers_),
kBody);
@@ -742,8 +742,8 @@
header_list.OnHeaderBlockEnd(128, 128);
EXPECT_CALL(*stream_, WriteHeadersMock(/*fin=*/false));
stream_->OnStreamHeaderList(/*fin=*/false, kFakeFrameLen, header_list);
- QuicBuffer header = HttpEncoder::SerializeDataFrameHeader(
- body_.length(), SimpleBufferAllocator::Get());
+ quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
+ body_.length(), quiche::SimpleBufferAllocator::Get());
std::string data =
UsesHttp3() ? absl::StrCat(header.AsStringView(), body_) : body_;
stream_->OnStreamFrame(
diff --git a/quic/tools/quic_transport_simple_server_session.cc b/quic/tools/quic_transport_simple_server_session.cc
index 157c16c..b8616d8 100644
--- a/quic/tools/quic_transport_simple_server_session.cc
+++ b/quic/tools/quic_transport_simple_server_session.cc
@@ -8,7 +8,6 @@
#include "url/gurl.h"
#include "url/origin.h"
-#include "quic/core/quic_buffer_allocator.h"
#include "quic/core/quic_types.h"
#include "quic/core/quic_versions.h"
#include "quic/platform/api/quic_flags.h"
@@ -17,6 +16,7 @@
#include "quic/quic_transport/quic_transport_stream.h"
#include "quic/tools/web_transport_test_visitors.h"
#include "common/platform/api/quiche_mem_slice.h"
+#include "common/quiche_buffer_allocator.h"
namespace quic {
@@ -128,8 +128,9 @@
if (mode_ != ECHO) {
return;
}
- datagram_queue()->SendOrQueueDatagram(quiche::QuicheMemSlice(QuicBuffer::Copy(
- connection()->helper()->GetStreamSendBufferAllocator(), message)));
+ datagram_queue()->SendOrQueueDatagram(
+ quiche::QuicheMemSlice(quiche::QuicheBuffer::Copy(
+ connection()->helper()->GetStreamSendBufferAllocator(), message)));
}
void QuicTransportSimpleServerSession::MaybeEchoStreamsBack() {
diff --git a/quic/tools/web_transport_test_visitors.h b/quic/tools/web_transport_test_visitors.h
index 4fdac1c..27605b1 100644
--- a/quic/tools/web_transport_test_visitors.h
+++ b/quic/tools/web_transport_test_visitors.h
@@ -7,11 +7,11 @@
#include <string>
-#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/core/web_transport_interface.h"
#include "quic/platform/api/quic_logging.h"
#include "common/platform/api/quiche_mem_slice.h"
#include "common/quiche_circular_deque.h"
+#include "common/simple_buffer_allocator.h"
namespace quic {
@@ -219,7 +219,8 @@
}
void OnDatagramReceived(absl::string_view datagram) override {
- quiche::QuicheMemSlice slice(QuicBuffer::Copy(&allocator_, datagram));
+ quiche::QuicheMemSlice slice(
+ quiche::QuicheBuffer::Copy(&allocator_, datagram));
session_->SendOrQueueDatagram(std::move(slice));
}
@@ -251,7 +252,7 @@
private:
WebTransportSession* session_;
- SimpleBufferAllocator allocator_;
+ quiche::SimpleBufferAllocator allocator_;
bool echo_stream_opened_ = false;
quiche::QuicheCircularDeque<std::string> streams_to_echo_back_;
