Google Git
Sign in
quiche/quiche/36f2070f71bde774576370ce3b204cdc8bac2a00^!/.
commit
36f2070f71bde774576370ce3b204cdc8bac2a00
[log]
author
bnc <bnc@google.com>
Thu Mar 03 05:51:18 2022 -0800
committer
Copybara-Service <copybara-worker@google.com>
Thu Mar 03 05:52:41 2022 -0800
tree
28addb28b11abd5b23106a74f4a302068f2763fc
parent
90a59ed0578a6e2f20a334e17f5aa495607c5774 [diff]
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_;