diff --git a/common/platform/api/quiche_mem_slice.h b/common/platform/api/quiche_mem_slice.h
new file mode 100644
index 0000000..6c4f81a
--- /dev/null
+++ b/common/platform/api/quiche_mem_slice.h
@@ -0,0 +1,92 @@
+// Copyright 2017 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_PLATFORM_API_QUICHE_MEM_SLICE_H_
+#define QUICHE_COMMON_PLATFORM_API_QUICHE_MEM_SLICE_H_
+
+#include <memory>
+
+#include "absl/strings/string_view.h"
+#include "common/platform/api/quiche_export.h"
+#include "net/quiche/common/platform/impl/quiche_mem_slice_impl.h"
+
+/* API_DESCRIPTION
+ QuicheMemSlice is used to wrap application data and pass to QUIC stream's write
+ interface. It refers to a memory block of data which should be around till
+ QuicheMemSlice::Reset() is called. It's upto each platform, to implement it as
+ reference counted or not.
+ API-DESCRIPTION */
+
+namespace quiche {
+
+// QuicheMemSlice is an internally reference counted data buffer used as the
+// source buffers for write operations. QuicheMemSlice implicitly maintains a
+// reference count and will free the underlying data buffer when the reference
+// count reaches zero.
+class QUICHE_EXPORT_PRIVATE QuicheMemSlice {
+ public:
+  // Constructs a empty QuicheMemSlice with no underlying data and 0 reference
+  // count.
+  QuicheMemSlice() = default;
+
+  // Constructs a QuicheMemSlice that takes ownership of |buffer|.  |length|
+  // must not be zero.  To construct an empty QuicheMemSlice, use the
+  // zero-argument constructor instead.
+  // TODO(vasilvv): switch all users to QuicBuffer version, and make this
+  // private.
+  QuicheMemSlice(quic::QuicUniqueBufferPtr buffer, size_t length)
+      : impl_(std::move(buffer), length) {}
+
+  // 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) : QuicheMemSlice() {
+    // Store the size of the buffer *before* calling buffer.Release().
+    const size_t size = buffer.size();
+    *this = QuicheMemSlice(buffer.Release(), size);
+  }
+
+  // Constructs a QuicheMemSlice that takes ownership of |buffer| allocated on
+  // heap.  |length| must not be zero.
+  QuicheMemSlice(std::unique_ptr<char[]> buffer, size_t length)
+      : impl_(std::move(buffer), length) {}
+
+  // Constructs QuicheMemSlice from |impl|. It takes the reference away from
+  // |impl|.
+  explicit QuicheMemSlice(QuicheMemSliceImpl impl) : impl_(std::move(impl)) {}
+
+  QuicheMemSlice(const QuicheMemSlice& other) = delete;
+  QuicheMemSlice& operator=(const QuicheMemSlice& other) = delete;
+
+  // Move constructors. |other| will not hold a reference to the data buffer
+  // after this call completes.
+  QuicheMemSlice(QuicheMemSlice&& other) = default;
+  QuicheMemSlice& operator=(QuicheMemSlice&& other) = default;
+
+  ~QuicheMemSlice() = default;
+
+  // Release the underlying reference. Further access the memory will result in
+  // undefined behavior.
+  void Reset() { impl_.Reset(); }
+
+  // Returns a const char pointer to underlying data buffer.
+  const char* data() const { return impl_.data(); }
+  // Returns the length of underlying data buffer.
+  size_t length() const { return impl_.length(); }
+  // Returns the representation of the underlying data as a string view.
+  absl::string_view AsStringView() const {
+    return absl::string_view(data(), length());
+  }
+
+  bool empty() const { return impl_.empty(); }
+
+  QuicheMemSliceImpl* impl() { return &impl_; }
+
+ private:
+  QuicheMemSliceImpl impl_;
+};
+
+}  // namespace quiche
+
+#endif  // QUICHE_COMMON_PLATFORM_API_QUICHE_MEM_SLICE_H_
diff --git a/quic/platform/api/quic_mem_slice_test.cc b/common/platform/api/quiche_mem_slice_test.cc
similarity index 63%
rename from quic/platform/api/quic_mem_slice_test.cc
rename to common/platform/api/quiche_mem_slice_test.cc
index 44095df..de6adbe 100644
--- a/quic/platform/api/quic_mem_slice_test.cc
+++ b/common/platform/api/quiche_mem_slice_test.cc
@@ -2,36 +2,36 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quic/platform/api/quic_mem_slice.h"
+#include "common/platform/api/quiche_mem_slice.h"
 
 #include <memory>
 
 #include "absl/strings/string_view.h"
 #include "quic/core/quic_buffer_allocator.h"
 #include "quic/core/quic_simple_buffer_allocator.h"
-#include "quic/platform/api/quic_test.h"
+#include "common/platform/api/quiche_test.h"
 
-namespace quic {
+namespace quiche {
 namespace test {
 namespace {
 
-class QuicMemSliceTest : public QuicTest {
+class QuicheMemSliceTest : public QuicheTest {
  public:
-  QuicMemSliceTest() {
+  QuicheMemSliceTest() {
     size_t length = 1024;
-    slice_ = QuicMemSlice(MakeUniqueBuffer(&allocator_, length), length);
+    slice_ = QuicheMemSlice(MakeUniqueBuffer(&allocator_, length), length);
     orig_data_ = slice_.data();
     orig_length_ = slice_.length();
   }
 
-  SimpleBufferAllocator allocator_;
-  QuicMemSlice slice_;
+  quic::SimpleBufferAllocator allocator_;
+  QuicheMemSlice slice_;
   const char* orig_data_;
   size_t orig_length_;
 };
 
-TEST_F(QuicMemSliceTest, MoveConstruct) {
-  QuicMemSlice moved(std::move(slice_));
+TEST_F(QuicheMemSliceTest, MoveConstruct) {
+  QuicheMemSlice moved(std::move(slice_));
   EXPECT_EQ(moved.data(), orig_data_);
   EXPECT_EQ(moved.length(), orig_length_);
   EXPECT_EQ(nullptr, slice_.data());
@@ -39,8 +39,8 @@
   EXPECT_TRUE(slice_.empty());
 }
 
-TEST_F(QuicMemSliceTest, MoveAssign) {
-  QuicMemSlice moved;
+TEST_F(QuicheMemSliceTest, MoveAssign) {
+  QuicheMemSlice moved;
   moved = std::move(slice_);
   EXPECT_EQ(moved.data(), orig_data_);
   EXPECT_EQ(moved.length(), orig_length_);
@@ -49,21 +49,21 @@
   EXPECT_TRUE(slice_.empty());
 }
 
-TEST_F(QuicMemSliceTest, SliceAllocatedOnHeap) {
+TEST_F(QuicheMemSliceTest, SliceAllocatedOnHeap) {
   auto buffer = std::make_unique<char[]>(128);
   char* orig_data = buffer.get();
   size_t used_length = 105;
-  QuicMemSlice slice = QuicMemSlice(std::move(buffer), used_length);
-  QuicMemSlice moved = std::move(slice);
+  QuicheMemSlice slice = QuicheMemSlice(std::move(buffer), used_length);
+  QuicheMemSlice moved = std::move(slice);
   EXPECT_EQ(moved.data(), orig_data);
   EXPECT_EQ(moved.length(), used_length);
 }
 
-TEST_F(QuicMemSliceTest, SliceFromBuffer) {
+TEST_F(QuicheMemSliceTest, SliceFromBuffer) {
   const absl::string_view kTestString =
       "RFC 9000 Release Celebration Memorial Test String";
-  auto buffer = QuicBuffer::Copy(&allocator_, kTestString);
-  QuicMemSlice slice(std::move(buffer));
+  auto buffer = quic::QuicBuffer::Copy(&allocator_, kTestString);
+  QuicheMemSlice slice(std::move(buffer));
 
   EXPECT_EQ(buffer.data(), nullptr);  // NOLINT(bugprone-use-after-move)
   EXPECT_EQ(buffer.size(), 0u);
@@ -73,4 +73,4 @@
 
 }  // namespace
 }  // namespace test
-}  // namespace quic
+}  // namespace quiche
diff --git a/common/quiche_mem_slice_storage.cc b/common/quiche_mem_slice_storage.cc
new file mode 100644
index 0000000..e3e1c5a
--- /dev/null
+++ b/common/quiche_mem_slice_storage.cc
@@ -0,0 +1,36 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "common/quiche_mem_slice_storage.h"
+
+#include "quic/core/quic_utils.h"
+
+namespace quiche {
+
+QuicheMemSliceStorage::QuicheMemSliceStorage(
+    const struct iovec* iov, int iov_count,
+    quic::QuicBufferAllocator* allocator,
+    const quic::QuicByteCount max_slice_len) {
+  if (iov == nullptr) {
+    return;
+  }
+  quic::QuicByteCount write_len = 0;
+  for (int i = 0; i < iov_count; ++i) {
+    write_len += iov[i].iov_len;
+  }
+  QUICHE_DCHECK_LT(0u, write_len);
+
+  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);
+    quic::QuicUtils::CopyToBuffer(iov, iov_count, io_offset, slice_len,
+                                  buffer.data());
+    storage_.push_back(QuicheMemSlice(std::move(buffer)));
+    write_len -= slice_len;
+    io_offset += slice_len;
+  }
+}
+
+}  // namespace quiche
diff --git a/common/quiche_mem_slice_storage.h b/common/quiche_mem_slice_storage.h
new file mode 100644
index 0000000..6ec68bb
--- /dev/null
+++ b/common/quiche_mem_slice_storage.h
@@ -0,0 +1,44 @@
+// Copyright 2017 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_MEM_SLICE_STORAGE_H_
+#define QUICHE_COMMON_QUICHE_MEM_SLICE_STORAGE_H_
+
+#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"
+
+namespace quiche {
+
+// QuicheMemSliceStorage is a container class that store QuicheMemSlices for
+// further use cases such as turning into QuicheMemSliceSpan.
+class QUICHE_EXPORT_PRIVATE QuicheMemSliceStorage {
+ public:
+  QuicheMemSliceStorage(const struct iovec* iov, int iov_count,
+                        quic::QuicBufferAllocator* allocator,
+                        const quic::QuicByteCount max_slice_len);
+
+  QuicheMemSliceStorage(const QuicheMemSliceStorage& other) = default;
+  QuicheMemSliceStorage& operator=(const QuicheMemSliceStorage& other) =
+      default;
+  QuicheMemSliceStorage(QuicheMemSliceStorage&& other) = default;
+  QuicheMemSliceStorage& operator=(QuicheMemSliceStorage&& other) = default;
+
+  ~QuicheMemSliceStorage() = default;
+
+  // Return a QuicheMemSliceSpan form of the storage.
+  absl::Span<QuicheMemSlice> ToSpan() { return absl::MakeSpan(storage_); }
+
+ private:
+  std::vector<QuicheMemSlice> storage_;
+};
+
+}  // namespace quiche
+
+#endif  // QUICHE_COMMON_QUICHE_MEM_SLICE_STORAGE_H_
diff --git a/common/quiche_mem_slice_storage_test.cc b/common/quiche_mem_slice_storage_test.cc
new file mode 100644
index 0000000..a07c71d
--- /dev/null
+++ b/common/quiche_mem_slice_storage_test.cc
@@ -0,0 +1,61 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "common/quiche_mem_slice_storage.h"
+
+#include "quic/core/quic_simple_buffer_allocator.h"
+#include "common/platform/api/quiche_test.h"
+
+namespace quiche {
+namespace test {
+namespace {
+
+class QuicheMemSliceStorageImplTest : public QuicheTest {
+ public:
+  QuicheMemSliceStorageImplTest() = default;
+};
+
+TEST_F(QuicheMemSliceStorageImplTest, EmptyIov) {
+  QuicheMemSliceStorage storage(nullptr, 0, nullptr, 1024);
+  EXPECT_TRUE(storage.ToSpan().empty());
+}
+
+TEST_F(QuicheMemSliceStorageImplTest, SingleIov) {
+  quic::SimpleBufferAllocator allocator;
+  std::string body(3, 'c');
+  struct iovec iov = {const_cast<char*>(body.data()), body.length()};
+  QuicheMemSliceStorage storage(&iov, 1, &allocator, 1024);
+  auto span = storage.ToSpan();
+  EXPECT_EQ("ccc", span[0].AsStringView());
+  EXPECT_NE(static_cast<const void*>(span[0].data()), body.data());
+}
+
+TEST_F(QuicheMemSliceStorageImplTest, MultipleIovInSingleSlice) {
+  quic::SimpleBufferAllocator allocator;
+  std::string body1(3, 'a');
+  std::string body2(4, 'b');
+  struct iovec iov[] = {{const_cast<char*>(body1.data()), body1.length()},
+                        {const_cast<char*>(body2.data()), body2.length()}};
+
+  QuicheMemSliceStorage storage(iov, 2, &allocator, 1024);
+  auto span = storage.ToSpan();
+  EXPECT_EQ("aaabbbb", span[0].AsStringView());
+}
+
+TEST_F(QuicheMemSliceStorageImplTest, MultipleIovInMultipleSlice) {
+  quic::SimpleBufferAllocator allocator;
+  std::string body1(4, 'a');
+  std::string body2(4, 'b');
+  struct iovec iov[] = {{const_cast<char*>(body1.data()), body1.length()},
+                        {const_cast<char*>(body2.data()), body2.length()}};
+
+  QuicheMemSliceStorage storage(iov, 2, &allocator, 4);
+  auto span = storage.ToSpan();
+  EXPECT_EQ("aaaa", span[0].AsStringView());
+  EXPECT_EQ("bbbb", span[1].AsStringView());
+}
+
+}  // namespace
+}  // namespace test
+}  // namespace quiche
diff --git a/quic/core/frames/quic_frame.cc b/quic/core/frames/quic_frame.cc
index c31b45e..e83e422 100644
--- a/quic/core/frames/quic_frame.cc
+++ b/quic/core/frames/quic_frame.cc
@@ -11,6 +11,7 @@
 #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"
 
 namespace quic {
 
@@ -393,7 +394,7 @@
       for (const auto& slice : frame.message_frame->message_data) {
         QuicBuffer buffer = QuicBuffer::Copy(allocator, slice.AsStringView());
         copy.message_frame->message_data.push_back(
-            QuicMemSlice(std::move(buffer)));
+            quiche::QuicheMemSlice(std::move(buffer)));
       }
       break;
     case NEW_TOKEN_FRAME:
diff --git a/quic/core/frames/quic_message_frame.cc b/quic/core/frames/quic_message_frame.cc
index 1ac0de6..429a3bf 100644
--- a/quic/core/frames/quic_message_frame.cc
+++ b/quic/core/frames/quic_message_frame.cc
@@ -6,7 +6,7 @@
 
 #include "quic/core/quic_constants.h"
 #include "quic/platform/api/quic_logging.h"
-#include "quic/platform/api/quic_mem_slice.h"
+#include "common/platform/api/quiche_mem_slice.h"
 
 namespace quic {
 
@@ -14,9 +14,9 @@
     : message_id(message_id), data(nullptr), message_length(0) {}
 
 QuicMessageFrame::QuicMessageFrame(QuicMessageId message_id,
-                                   absl::Span<QuicMemSlice> span)
+                                   absl::Span<quiche::QuicheMemSlice> span)
     : message_id(message_id), data(nullptr), message_length(0) {
-  for (QuicMemSlice& slice : span) {
+  for (quiche::QuicheMemSlice& slice : span) {
     if (slice.empty()) {
       continue;
     }
@@ -24,7 +24,8 @@
     message_data.push_back(std::move(slice));
   }
 }
-QuicMessageFrame::QuicMessageFrame(QuicMessageId message_id, QuicMemSlice slice)
+QuicMessageFrame::QuicMessageFrame(QuicMessageId message_id,
+                                   quiche::QuicheMemSlice slice)
     : QuicMessageFrame(message_id, absl::MakeSpan(&slice, 1)) {}
 
 QuicMessageFrame::QuicMessageFrame(const char* data, QuicPacketLength length)
diff --git a/quic/core/frames/quic_message_frame.h b/quic/core/frames/quic_message_frame.h
index 1d090c9..008a7d9 100644
--- a/quic/core/frames/quic_message_frame.h
+++ b/quic/core/frames/quic_message_frame.h
@@ -10,17 +10,18 @@
 #include "quic/core/quic_types.h"
 #include "quic/platform/api/quic_containers.h"
 #include "quic/platform/api/quic_export.h"
-#include "quic/platform/api/quic_mem_slice.h"
+#include "common/platform/api/quiche_mem_slice.h"
 
 namespace quic {
 
-using QuicMessageData = absl::InlinedVector<QuicMemSlice, 1>;
+using QuicMessageData = absl::InlinedVector<quiche::QuicheMemSlice, 1>;
 
 struct QUIC_EXPORT_PRIVATE QuicMessageFrame {
   QuicMessageFrame() = default;
   explicit QuicMessageFrame(QuicMessageId message_id);
-  QuicMessageFrame(QuicMessageId message_id, absl::Span<QuicMemSlice> span);
-  QuicMessageFrame(QuicMessageId message_id, QuicMemSlice slice);
+  QuicMessageFrame(QuicMessageId message_id,
+                   absl::Span<quiche::QuicheMemSlice> span);
+  QuicMessageFrame(QuicMessageId message_id, quiche::QuicheMemSlice slice);
   QuicMessageFrame(const char* data, QuicPacketLength length);
 
   QuicMessageFrame(const QuicMessageFrame& other) = delete;
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index cfc4729..7b63328 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -30,6 +30,7 @@
 #include "quic/platform/api/quic_flags.h"
 #include "quic/platform/api/quic_logging.h"
 #include "quic/platform/api/quic_stack_trace.h"
+#include "common/platform/api/quiche_mem_slice.h"
 #include "spdy/core/http2_frame_decoder_adapter.h"
 
 using http2::Http2DecoderAdapter;
@@ -1690,7 +1691,7 @@
     return MESSAGE_STATUS_INTERNAL_ERROR;
   }
 
-  QuicMemSlice slice(std::move(buffer));
+  quiche::QuicheMemSlice slice(std::move(buffer));
   return datagram_queue()->SendOrQueueDatagram(std::move(slice));
 }
 
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 67f2e44..b91292d 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -46,6 +46,7 @@
 #include "quic/test_tools/quic_stream_peer.h"
 #include "quic/test_tools/quic_stream_send_buffer_peer.h"
 #include "quic/test_tools/quic_test_utils.h"
+#include "common/platform/api/quiche_mem_slice.h"
 #include "common/quiche_endian.h"
 #include "common/test_tools/quiche_test_utils.h"
 #include "spdy/core/spdy_framer.h"
@@ -2040,7 +2041,7 @@
   SpdyFramer spdy_framer(SpdyFramer::ENABLE_COMPRESSION);
   SpdySerializedFrame frame = spdy_framer.SerializeFrame(priority_frame);
 
-  const QuicMemSlice& slice =
+  const quiche::QuicheMemSlice& slice =
       QuicStreamSendBufferPeer::CurrentWriteSlice(&send_buffer)->slice;
   EXPECT_EQ(absl::string_view(frame.data(), frame.size()),
             absl::string_view(slice.data(), slice.length()));
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index 5317137..2fcece7 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -32,7 +32,7 @@
 #include "quic/platform/api/quic_flag_utils.h"
 #include "quic/platform/api/quic_flags.h"
 #include "quic/platform/api/quic_logging.h"
-#include "quic/platform/api/quic_mem_slice_storage.h"
+#include "common/quiche_mem_slice_storage.h"
 #include "common/quiche_text_utils.h"
 #include "spdy/core/spdy_protocol.h"
 
@@ -390,7 +390,7 @@
 
 QuicConsumedData QuicSpdyStream::WritevBody(const struct iovec* iov, int count,
                                             bool fin) {
-  QuicMemSliceStorage storage(
+  quiche::QuicheMemSliceStorage storage(
       iov, count,
       session()->connection()->helper()->GetStreamSendBufferAllocator(),
       GetQuicFlag(FLAGS_quic_send_buffer_max_data_slice_size));
@@ -421,7 +421,7 @@
                   << header.size();
   if (can_write) {
     // Save one copy and allocation if send buffer can accomodate the header.
-    QuicMemSlice header_slice(std::move(header));
+    quiche::QuicheMemSlice header_slice(std::move(header));
     WriteMemSlices(absl::MakeSpan(&header_slice, 1), false);
   } else {
     QUICHE_DCHECK(force_write);
@@ -431,7 +431,7 @@
 }
 
 QuicConsumedData QuicSpdyStream::WriteBodySlices(
-    absl::Span<QuicMemSlice> slices, bool fin) {
+    absl::Span<quiche::QuicheMemSlice> slices, bool fin) {
   if (!VersionUsesHttp3(transport_version()) || slices.empty()) {
     return WriteMemSlices(slices, fin);
   }
diff --git a/quic/core/http/quic_spdy_stream.h b/quic/core/http/quic_spdy_stream.h
index 14ac2f2..1df1485 100644
--- a/quic/core/http/quic_spdy_stream.h
+++ b/quic/core/http/quic_spdy_stream.h
@@ -35,6 +35,7 @@
 #include "quic/platform/api/quic_export.h"
 #include "quic/platform/api/quic_flags.h"
 #include "quic/platform/api/quic_socket_address.h"
+#include "common/platform/api/quiche_mem_slice.h"
 #include "spdy/core/spdy_framer.h"
 #include "spdy/core/spdy_header_block.h"
 
@@ -154,7 +155,8 @@
 
   // Does the same thing as WriteOrBufferBody except this method takes
   // memslicespan as the data input. Right now it only calls WriteMemSlices.
-  QuicConsumedData WriteBodySlices(absl::Span<QuicMemSlice> slices, bool fin);
+  QuicConsumedData WriteBodySlices(absl::Span<quiche::QuicheMemSlice> slices,
+                                   bool fin);
 
   // Marks the trailers as consumed. This applies to the case where this object
   // receives headers and trailers as QuicHeaderLists via calls to
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index c8146e1..cb00c2a 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -37,6 +37,7 @@
 #include "quic/test_tools/quic_spdy_stream_peer.h"
 #include "quic/test_tools/quic_stream_peer.h"
 #include "quic/test_tools/quic_test_utils.h"
+#include "common/quiche_mem_slice_storage.h"
 
 using spdy::kV3HighestPriority;
 using spdy::kV3LowestPriority;
@@ -1980,10 +1981,10 @@
   std::string body2(100, 'x');
   struct iovec body1_iov = {const_cast<char*>(body1.data()), body1.length()};
   struct iovec body2_iov = {const_cast<char*>(body2.data()), body2.length()};
-  QuicMemSliceStorage storage(&body1_iov, 1,
-                              helper_.GetStreamSendBufferAllocator(), 1024);
-  QuicMemSliceStorage storage2(&body2_iov, 1,
-                               helper_.GetStreamSendBufferAllocator(), 1024);
+  quiche::QuicheMemSliceStorage storage(
+      &body1_iov, 1, helper_.GetStreamSendBufferAllocator(), 1024);
+  quiche::QuicheMemSliceStorage storage2(
+      &body2_iov, 1, helper_.GetStreamSendBufferAllocator(), 1024);
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).Times(AtLeast(1));
   stream_->WriteBodySlices(storage.ToSpan(), false);
   stream_->WriteBodySlices(storage2.ToSpan(), true);
diff --git a/quic/core/http/web_transport_http3.cc b/quic/core/http/web_transport_http3.cc
index c2d02f0..f4e8040 100644
--- a/quic/core/http/web_transport_http3.cc
+++ b/quic/core/http/web_transport_http3.cc
@@ -280,7 +280,8 @@
   return stream->interface();
 }
 
-MessageStatus WebTransportHttp3::SendOrQueueDatagram(QuicMemSlice datagram) {
+MessageStatus WebTransportHttp3::SendOrQueueDatagram(
+    quiche::QuicheMemSlice datagram) {
   return connect_stream_->SendHttp3Datagram(
       context_id_, absl::string_view(datagram.data(), datagram.length()));
 }
diff --git a/quic/core/http/web_transport_http3.h b/quic/core/http/web_transport_http3.h
index 542b941..f6f94cd 100644
--- a/quic/core/http/web_transport_http3.h
+++ b/quic/core/http/web_transport_http3.h
@@ -16,6 +16,7 @@
 #include "quic/core/quic_stream.h"
 #include "quic/core/quic_types.h"
 #include "quic/core/web_transport_interface.h"
+#include "common/platform/api/quiche_mem_slice.h"
 #include "spdy/core/spdy_header_block.h"
 
 namespace quic {
@@ -84,7 +85,7 @@
   WebTransportStream* OpenOutgoingBidirectionalStream() override;
   WebTransportStream* OpenOutgoingUnidirectionalStream() override;
 
-  MessageStatus SendOrQueueDatagram(QuicMemSlice datagram) override;
+  MessageStatus SendOrQueueDatagram(quiche::QuicheMemSlice datagram) override;
   QuicByteCount GetMaxDatagramSize() const override;
   void SetDatagramMaxTimeInQueue(QuicTime::Delta max_time_in_queue) override;
 
diff --git a/quic/core/http/web_transport_stream_adapter.cc b/quic/core/http/web_transport_stream_adapter.cc
index bea1377..eb42fd8 100644
--- a/quic/core/http/web_transport_stream_adapter.cc
+++ b/quic/core/http/web_transport_stream_adapter.cc
@@ -6,6 +6,7 @@
 
 #include "quic/core/http/web_transport_http3.h"
 #include "quic/core/quic_error_codes.h"
+#include "common/platform/api/quiche_mem_slice.h"
 
 namespace quic {
 
@@ -45,7 +46,7 @@
     return false;
   }
 
-  QuicMemSlice memslice(QuicBuffer::Copy(
+  quiche::QuicheMemSlice memslice(QuicBuffer::Copy(
       session_->connection()->helper()->GetStreamSendBufferAllocator(), data));
   QuicConsumedData consumed =
       stream_->WriteMemSlices(absl::MakeSpan(&memslice, 1), /*fin=*/false);
@@ -76,7 +77,7 @@
     return false;
   }
 
-  QuicMemSlice empty;
+  quiche::QuicheMemSlice empty;
   QuicConsumedData consumed =
       stream_->WriteMemSlices(absl::MakeSpan(&empty, 1), /*fin=*/true);
   QUICHE_DCHECK_EQ(consumed.bytes_consumed, 0u);
diff --git a/quic/core/quic_buffer_allocator.h b/quic/core/quic_buffer_allocator.h
index d3905e7..de69ca2 100644
--- a/quic/core/quic_buffer_allocator.h
+++ b/quic/core/quic_buffer_allocator.h
@@ -57,9 +57,9 @@
                              QuicBufferDeleter(allocator));
 }
 
-// QuicUniqueBufferPtr with a length attached to it.  Similar to QuicMemSlice,
-// except unlike QuicMemSlice, QuicBuffer is mutable and is not
-// platform-specific.  Also unlike QuicMemSlice, QuicBuffer can be empty.
+// 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) {}
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 9db7965..58daa88 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -5705,9 +5705,9 @@
   uber_received_packet_manager_.ResetAckStates(encryption_level_);
 }
 
-MessageStatus QuicConnection::SendMessage(QuicMessageId message_id,
-                                          absl::Span<QuicMemSlice> message,
-                                          bool flush) {
+MessageStatus QuicConnection::SendMessage(
+    QuicMessageId message_id, absl::Span<quiche::QuicheMemSlice> message,
+    bool flush) {
   if (!VersionSupportsMessageFrames(transport_version())) {
     QUIC_BUG(quic_bug_10511_38)
         << "MESSAGE frame is not supported for version " << transport_version();
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index 129d8bf..42b4358 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -58,6 +58,7 @@
 #include "quic/platform/api/quic_export.h"
 #include "quic/platform/api/quic_flags.h"
 #include "quic/platform/api/quic_socket_address.h"
+#include "common/platform/api/quiche_mem_slice.h"
 #include "common/quiche_circular_deque.h"
 
 namespace quic {
@@ -985,7 +986,7 @@
   // If |flush| is false, this will return a MESSAGE_STATUS_BLOCKED
   // when the connection is deemed unwritable.
   virtual MessageStatus SendMessage(QuicMessageId message_id,
-                                    absl::Span<QuicMemSlice> message,
+                                    absl::Span<quiche::QuicheMemSlice> message,
                                     bool flush);
 
   // Returns the largest payload that will fit into a single MESSAGE frame.
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 5845769..f563fde 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -1069,7 +1069,7 @@
 
   MessageStatus SendMessage(absl::string_view message) {
     connection_.SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
-    QuicMemSlice slice(QuicBuffer::Copy(
+    quiche::QuicheMemSlice slice(QuicBuffer::Copy(
         connection_.helper()->GetStreamSendBufferAllocator(), message));
     return connection_.SendMessage(1, absl::MakeSpan(&slice, 1), false);
   }
@@ -8705,7 +8705,7 @@
     connection_.SetFromConfig(config);
   }
   std::string message(connection_.GetCurrentLargestMessagePayload() * 2, 'a');
-  QuicMemSlice slice;
+  quiche::QuicheMemSlice slice;
   {
     QuicConnection::ScopedPacketFlusher flusher(&connection_);
     connection_.SendStreamData3();
diff --git a/quic/core/quic_datagram_queue.cc b/quic/core/quic_datagram_queue.cc
index ebd7483..0851878 100644
--- a/quic/core/quic_datagram_queue.cc
+++ b/quic/core/quic_datagram_queue.cc
@@ -25,7 +25,8 @@
       clock_(session->connection()->clock()),
       observer_(std::move(observer)) {}
 
-MessageStatus QuicDatagramQueue::SendOrQueueDatagram(QuicMemSlice datagram) {
+MessageStatus QuicDatagramQueue::SendOrQueueDatagram(
+    quiche::QuicheMemSlice datagram) {
   // If the queue is non-empty, always queue the daragram.  This ensures that
   // the datagrams are sent in the same order that they were sent by the
   // application.
diff --git a/quic/core/quic_datagram_queue.h b/quic/core/quic_datagram_queue.h
index 4d3aa2f..6374a64 100644
--- a/quic/core/quic_datagram_queue.h
+++ b/quic/core/quic_datagram_queue.h
@@ -10,7 +10,7 @@
 #include "absl/types/optional.h"
 #include "quic/core/quic_time.h"
 #include "quic/core/quic_types.h"
-#include "quic/platform/api/quic_mem_slice.h"
+#include "common/platform/api/quiche_mem_slice.h"
 #include "common/quiche_circular_deque.h"
 
 namespace quic {
@@ -44,7 +44,7 @@
 
   // Adds the datagram to the end of the queue.  May send it immediately; if
   // not, MESSAGE_STATUS_BLOCKED is returned.
-  MessageStatus SendOrQueueDatagram(QuicMemSlice datagram);
+  MessageStatus SendOrQueueDatagram(quiche::QuicheMemSlice datagram);
 
   // Attempts to send a single datagram from the queue.  Returns the result of
   // SendMessage(), or nullopt if there were no unexpired datagrams to send.
@@ -69,7 +69,7 @@
 
  private:
   struct QUIC_EXPORT_PRIVATE Datagram {
-    QuicMemSlice datagram;
+    quiche::QuicheMemSlice datagram;
     QuicTime expiry;
   };
 
diff --git a/quic/core/quic_datagram_queue_test.cc b/quic/core/quic_datagram_queue_test.cc
index 68a876b..8449e15 100644
--- a/quic/core/quic_datagram_queue_test.cc
+++ b/quic/core/quic_datagram_queue_test.cc
@@ -12,10 +12,10 @@
 #include "quic/core/quic_buffer_allocator.h"
 #include "quic/core/quic_time.h"
 #include "quic/core/quic_types.h"
-#include "quic/platform/api/quic_mem_slice.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"
 
 namespace quic {
 namespace test {
@@ -70,11 +70,11 @@
 
   ~QuicDatagramQueueTestBase() = default;
 
-  QuicMemSlice CreateMemSlice(absl::string_view data) {
+  quiche::QuicheMemSlice CreateMemSlice(absl::string_view data) {
     QuicUniqueBufferPtr buffer =
         MakeUniqueBuffer(helper_.GetStreamSendBufferAllocator(), data.size());
     memcpy(buffer.get(), data.data(), data.size());
-    return QuicMemSlice(std::move(buffer), data.size());
+    return quiche::QuicheMemSlice(std::move(buffer), data.size());
   }
 
   MockQuicConnectionHelper helper_;
@@ -176,7 +176,7 @@
   std::vector<std::string> messages;
   EXPECT_CALL(*connection_, SendMessage(_, _, _))
       .WillRepeatedly([&messages](QuicMessageId /*id*/,
-                                  absl::Span<QuicMemSlice> message,
+                                  absl::Span<quiche::QuicheMemSlice> message,
                                   bool /*flush*/) {
         messages.push_back(std::string(message[0].AsStringView()));
         return MESSAGE_STATUS_SUCCESS;
diff --git a/quic/core/quic_packet_creator.cc b/quic/core/quic_packet_creator.cc
index 5042d66..d34d1e6 100644
--- a/quic/core/quic_packet_creator.cc
+++ b/quic/core/quic_packet_creator.cc
@@ -1605,7 +1605,7 @@
 }
 
 MessageStatus QuicPacketCreator::AddMessageFrame(
-    QuicMessageId message_id, absl::Span<QuicMemSlice> message) {
+    QuicMessageId message_id, absl::Span<quiche::QuicheMemSlice> message) {
   QUIC_BUG_IF(quic_bug_10752_33, !flusher_attached_)
       << ENDPOINT
       << "Packet flusher is not attached when "
diff --git a/quic/core/quic_packet_creator.h b/quic/core/quic_packet_creator.h
index 9cc4bca..b32be86 100644
--- a/quic/core/quic_packet_creator.h
+++ b/quic/core/quic_packet_creator.h
@@ -30,6 +30,7 @@
 #include "quic/core/quic_packets.h"
 #include "quic/core/quic_types.h"
 #include "quic/platform/api/quic_export.h"
+#include "common/platform/api/quiche_mem_slice.h"
 #include "common/quiche_circular_deque.h"
 
 namespace quic {
@@ -421,7 +422,7 @@
 
   // Tries to add a message frame containing |message| and returns the status.
   MessageStatus AddMessageFrame(QuicMessageId message_id,
-                                absl::Span<QuicMemSlice> message);
+                                absl::Span<quiche::QuicheMemSlice> message);
 
   // Returns the largest payload that will fit into a single MESSAGE frame.
   QuicPacketLength GetCurrentLargestMessagePayload() const;
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index 5538564..c7b7dcb 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -2448,7 +2448,7 @@
   }
 
   MessageStatus AddMessageFrame(QuicMessageId message_id,
-                                QuicMemSlice message) {
+                                quiche::QuicheMemSlice message) {
     if (!has_ack() && delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA,
                                                       NOT_HANDSHAKE)) {
       EXPECT_CALL(*delegate_, MaybeBundleAckOpportunistically()).Times(1);
diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc
index 8b4ceac..cceceb7 100644
--- a/quic/core/quic_sent_packet_manager_test.cc
+++ b/quic/core/quic_sent_packet_manager_test.cc
@@ -18,6 +18,7 @@
 #include "quic/test_tools/quic_config_peer.h"
 #include "quic/test_tools/quic_sent_packet_manager_peer.h"
 #include "quic/test_tools/quic_test_utils.h"
+#include "common/platform/api/quiche_mem_slice.h"
 
 using testing::_;
 using testing::AnyNumber;
@@ -4440,7 +4441,7 @@
 
   QuicMessageFrame* message_frame = nullptr;
   {
-    QuicMemSlice slice(MakeUniqueBuffer(&allocator_, 1024), 1024);
+    quiche::QuicheMemSlice slice(MakeUniqueBuffer(&allocator_, 1024), 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_session.cc b/quic/core/quic_session.cc
index fe2955b..89fa564 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -2464,16 +2464,17 @@
   connection_->SetTransmissionType(type);
 }
 
-MessageResult QuicSession::SendMessage(absl::Span<QuicMemSlice> message) {
+MessageResult QuicSession::SendMessage(
+    absl::Span<quiche::QuicheMemSlice> message) {
   return SendMessage(message, /*flush=*/false);
 }
 
-MessageResult QuicSession::SendMessage(QuicMemSlice message) {
+MessageResult QuicSession::SendMessage(quiche::QuicheMemSlice message) {
   return SendMessage(absl::MakeSpan(&message, 1), /*flush=*/false);
 }
 
-MessageResult QuicSession::SendMessage(absl::Span<QuicMemSlice> message,
-                                       bool flush) {
+MessageResult QuicSession::SendMessage(
+    absl::Span<quiche::QuicheMemSlice> message, bool flush) {
   QUICHE_DCHECK(connection_->connected())
       << ENDPOINT << "Try to write messages when connection is closed.";
   if (!IsEncryptionEstablished()) {
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 88ae992..2734c6e 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -42,8 +42,8 @@
 #include "quic/core/uber_quic_stream_id_manager.h"
 #include "quic/platform/api/quic_export.h"
 #include "quic/platform/api/quic_flags.h"
-#include "quic/platform/api/quic_mem_slice.h"
 #include "quic/platform/api/quic_socket_address.h"
+#include "common/platform/api/quiche_mem_slice.h"
 #include "common/quiche_linked_hash_map.h"
 
 namespace quic {
@@ -234,15 +234,16 @@
   // SendMessage flushes the current packet even it is not full; if the
   // application needs to bundle other data in the same packet, consider using
   // QuicConnection::ScopedPacketFlusher around the relevant write operations.
-  MessageResult SendMessage(absl::Span<QuicMemSlice> message);
+  MessageResult SendMessage(absl::Span<quiche::QuicheMemSlice> message);
 
   // Same as above SendMessage, except caller can specify if the given |message|
   // should be flushed even if the underlying connection is deemed unwritable.
-  MessageResult SendMessage(absl::Span<QuicMemSlice> message, bool flush);
+  MessageResult SendMessage(absl::Span<quiche::QuicheMemSlice> message,
+                            bool flush);
 
   // Single-slice version of SendMessage().  Unlike the version above, this
   // version always takes ownership of the slice.
-  MessageResult SendMessage(QuicMemSlice message);
+  MessageResult SendMessage(quiche::QuicheMemSlice message);
 
   // Called when message with |message_id| gets acked.
   virtual void OnMessageAcked(QuicMessageId message_id,
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index b62f2a9..68ae9f9 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -28,7 +28,6 @@
 #include "quic/core/quic_versions.h"
 #include "quic/platform/api/quic_expect_bug.h"
 #include "quic/platform/api/quic_flags.h"
-#include "quic/platform/api/quic_mem_slice_storage.h"
 #include "quic/platform/api/quic_test.h"
 #include "quic/test_tools/mock_quic_session_visitor.h"
 #include "quic/test_tools/quic_config_peer.h"
@@ -39,6 +38,7 @@
 #include "quic/test_tools/quic_stream_peer.h"
 #include "quic/test_tools/quic_stream_send_buffer_peer.h"
 #include "quic/test_tools/quic_test_utils.h"
+#include "common/quiche_mem_slice_storage.h"
 
 using spdy::kV3HighestPriority;
 using spdy::SpdyPriority;
@@ -2700,7 +2700,7 @@
       .Times(1);
   std::string body(100, '.');
   struct iovec iov = {const_cast<char*>(body.data()), body.length()};
-  QuicMemSliceStorage storage(
+  quiche::QuicheMemSliceStorage storage(
       &iov, 1, session_.connection()->helper()->GetStreamSendBufferAllocator(),
       1024);
   stream4->WriteMemSlices(storage.ToSpan(), false);
@@ -2716,7 +2716,7 @@
                   QUIC_TRY_TO_WRITE_DATA_ON_READ_UNIDIRECTIONAL_STREAM, _, _))
       .Times(1);
   std::string data(1024, 'a');
-  std::vector<QuicMemSlice> buffers;
+  std::vector<quiche::QuicheMemSlice> buffers;
   buffers.push_back(MemSliceFromString(data));
   buffers.push_back(MemSliceFromString(data));
   stream4->WriteMemSlices(absl::MakeSpan(buffers), false);
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index 6237dae..f8e00b4 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -20,8 +20,8 @@
 #include "quic/platform/api/quic_flag_utils.h"
 #include "quic/platform/api/quic_flags.h"
 #include "quic/platform/api/quic_logging.h"
-#include "quic/platform/api/quic_mem_slice.h"
 #include "common/platform/api/quiche_logging.h"
+#include "common/platform/api/quiche_mem_slice.h"
 
 using spdy::SpdyPriority;
 
@@ -759,12 +759,13 @@
   }
 }
 
-QuicConsumedData QuicStream::WriteMemSlice(QuicMemSlice span, bool fin) {
+QuicConsumedData QuicStream::WriteMemSlice(quiche::QuicheMemSlice span,
+                                           bool fin) {
   return WriteMemSlices(absl::MakeSpan(&span, 1), fin);
 }
 
-QuicConsumedData QuicStream::WriteMemSlices(absl::Span<QuicMemSlice> span,
-                                            bool fin) {
+QuicConsumedData QuicStream::WriteMemSlices(
+    absl::Span<quiche::QuicheMemSlice> span, bool fin) {
   QuicConsumedData consumed_data(0, false);
   if (span.empty() && !fin) {
     QUIC_BUG(quic_bug_10586_6) << "span.empty() && !fin";
diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h
index dc129a2..4a6acca 100644
--- a/quic/core/quic_stream.h
+++ b/quic/core/quic_stream.h
@@ -35,8 +35,8 @@
 #include "quic/core/session_notifier_interface.h"
 #include "quic/core/stream_delegate_interface.h"
 #include "quic/platform/api/quic_export.h"
-#include "quic/platform/api/quic_mem_slice.h"
 #include "quic/platform/api/quic_reference_counted.h"
+#include "common/platform/api/quiche_mem_slice.h"
 #include "spdy/core/spdy_protocol.h"
 
 namespace quic {
@@ -365,8 +365,9 @@
   // the wire.  This method has all-or-nothing semantics: if the write buffer is
   // not full, all of the memslices in |span| are moved into it; otherwise,
   // nothing happens.
-  QuicConsumedData WriteMemSlices(absl::Span<QuicMemSlice> span, bool fin);
-  QuicConsumedData WriteMemSlice(QuicMemSlice span, bool fin);
+  QuicConsumedData WriteMemSlices(absl::Span<quiche::QuicheMemSlice> span,
+                                  bool fin);
+  QuicConsumedData WriteMemSlice(quiche::QuicheMemSlice span, bool fin);
 
   // Returns true if any stream data is lost (including fin) and needs to be
   // retransmitted.
diff --git a/quic/core/quic_stream_send_buffer.cc b/quic/core/quic_stream_send_buffer.cc
index b2ac6bf..2c68dc1 100644
--- a/quic/core/quic_stream_send_buffer.cc
+++ b/quic/core/quic_stream_send_buffer.cc
@@ -2,17 +2,18 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "quic/core/quic_stream_send_buffer.h"
+
 #include <algorithm>
 
 #include "quic/core/quic_data_writer.h"
 #include "quic/core/quic_interval.h"
-#include "quic/core/quic_stream_send_buffer.h"
 #include "quic/core/quic_utils.h"
 #include "quic/platform/api/quic_bug_tracker.h"
 #include "quic/platform/api/quic_flag_utils.h"
 #include "quic/platform/api/quic_flags.h"
 #include "quic/platform/api/quic_logging.h"
-#include "quic/platform/api/quic_mem_slice.h"
+#include "common/platform/api/quiche_mem_slice.h"
 
 namespace quic {
 
@@ -26,7 +27,8 @@
 
 }  // namespace
 
-BufferedSlice::BufferedSlice(QuicMemSlice mem_slice, QuicStreamOffset offset)
+BufferedSlice::BufferedSlice(quiche::QuicheMemSlice mem_slice,
+                             QuicStreamOffset offset)
     : slice(std::move(mem_slice)), offset(offset) {}
 
 BufferedSlice::BufferedSlice(BufferedSlice&& other) = default;
@@ -68,13 +70,13 @@
     QuicUniqueBufferPtr buffer = MakeUniqueBuffer(allocator_, slice_len);
     QuicUtils::CopyToBuffer(iov, iov_count, iov_offset, slice_len,
                             buffer.get());
-    SaveMemSlice(QuicMemSlice(std::move(buffer), slice_len));
+    SaveMemSlice(quiche::QuicheMemSlice(std::move(buffer), slice_len));
     data_length -= slice_len;
     iov_offset += slice_len;
   }
 }
 
-void QuicStreamSendBuffer::SaveMemSlice(QuicMemSlice slice) {
+void QuicStreamSendBuffer::SaveMemSlice(quiche::QuicheMemSlice slice) {
   QUIC_DVLOG(2) << "Save slice offset " << stream_offset_ << " length "
                 << slice.length();
   if (slice.empty()) {
@@ -93,9 +95,9 @@
 }
 
 QuicByteCount QuicStreamSendBuffer::SaveMemSliceSpan(
-    absl::Span<QuicMemSlice> span) {
+    absl::Span<quiche::QuicheMemSlice> span) {
   QuicByteCount total = 0;
-  for (QuicMemSlice& slice : span) {
+  for (quiche::QuicheMemSlice& slice : span) {
     if (slice.length() == 0) {
       // Skip empty slices.
       continue;
diff --git a/quic/core/quic_stream_send_buffer.h b/quic/core/quic_stream_send_buffer.h
index bf50217..2069e8b 100644
--- a/quic/core/quic_stream_send_buffer.h
+++ b/quic/core/quic_stream_send_buffer.h
@@ -11,7 +11,7 @@
 #include "quic/core/quic_interval_set.h"
 #include "quic/core/quic_types.h"
 #include "quic/platform/api/quic_iovec.h"
-#include "quic/platform/api/quic_mem_slice.h"
+#include "common/platform/api/quiche_mem_slice.h"
 #include "common/quiche_circular_deque.h"
 
 namespace quic {
@@ -28,7 +28,7 @@
 // stream data is saved in send buffer and is removed when stream data is fully
 // acked. It is move-only.
 struct QUIC_EXPORT_PRIVATE BufferedSlice {
-  BufferedSlice(QuicMemSlice mem_slice, QuicStreamOffset offset);
+  BufferedSlice(quiche::QuicheMemSlice mem_slice, QuicStreamOffset offset);
   BufferedSlice(BufferedSlice&& other);
   BufferedSlice& operator=(BufferedSlice&& other);
 
@@ -40,7 +40,7 @@
   QuicInterval<std::size_t> interval() const;
 
   // Stream data of this data slice.
-  QuicMemSlice slice;
+  quiche::QuicheMemSlice slice;
   // Location of this data slice in the stream.
   QuicStreamOffset offset;
 };
@@ -76,10 +76,10 @@
                       QuicByteCount data_length);
 
   // Save |slice| to send buffer.
-  void SaveMemSlice(QuicMemSlice slice);
+  void SaveMemSlice(quiche::QuicheMemSlice slice);
 
   // Save all slices in |span| to send buffer. Return total bytes saved.
-  QuicByteCount SaveMemSliceSpan(absl::Span<QuicMemSlice> span);
+  QuicByteCount SaveMemSliceSpan(absl::Span<quiche::QuicheMemSlice> span);
 
   // Called when |bytes_consumed| bytes has been consumed by the stream.
   void OnStreamDataConsumed(size_t bytes_consumed);
diff --git a/quic/core/quic_stream_send_buffer_test.cc b/quic/core/quic_stream_send_buffer_test.cc
index 9aaec4d..15e0d3f 100644
--- a/quic/core/quic_stream_send_buffer_test.cc
+++ b/quic/core/quic_stream_send_buffer_test.cc
@@ -40,10 +40,10 @@
 
     QuicBuffer buffer1(&allocator_, 1024);
     memset(buffer1.data(), 'c', buffer1.size());
-    QuicMemSlice slice1(std::move(buffer1));
+    quiche::QuicheMemSlice slice1(std::move(buffer1));
     QuicBuffer buffer2(&allocator_, 768);
     memset(buffer2.data(), 'd', buffer2.size());
-    QuicMemSlice slice2(std::move(buffer2));
+    quiche::QuicheMemSlice slice2(std::move(buffer2));
 
     // The stream offset should be 0 since nothing is written.
     EXPECT_EQ(0u, QuicStreamSendBufferPeer::EndOffset(&send_buffer_));
@@ -310,7 +310,7 @@
   EXPECT_EQ(3840u, QuicStreamSendBufferPeer::EndOffset(&send_buffer_));
   QuicBuffer buffer(&allocator_, 60);
   memset(buffer.data(), 'e', buffer.size());
-  QuicMemSlice slice(std::move(buffer));
+  quiche::QuicheMemSlice slice(std::move(buffer));
   send_buffer_.SaveMemSlice(std::move(slice));
 
   EXPECT_EQ(3840u, QuicStreamSendBufferPeer::EndOffset(&send_buffer_));
@@ -321,7 +321,7 @@
   QuicStreamSendBuffer send_buffer(&allocator);
 
   std::string data(1024, 'a');
-  std::vector<QuicMemSlice> buffers;
+  std::vector<quiche::QuicheMemSlice> buffers;
   for (size_t i = 0; i < 10; ++i) {
     buffers.push_back(MemSliceFromString(data));
   }
@@ -335,7 +335,7 @@
   QuicStreamSendBuffer send_buffer(&allocator);
 
   std::string data(1024, 'a');
-  std::vector<QuicMemSlice> buffers;
+  std::vector<quiche::QuicheMemSlice> buffers;
   for (size_t i = 0; i < 10; ++i) {
     buffers.push_back(MemSliceFromString(data));
   }
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index 9d48b1f..7c97ce9 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -24,7 +24,6 @@
 #include "quic/platform/api/quic_expect_bug.h"
 #include "quic/platform/api/quic_flags.h"
 #include "quic/platform/api/quic_logging.h"
-#include "quic/platform/api/quic_mem_slice_storage.h"
 #include "quic/platform/api/quic_test.h"
 #include "quic/test_tools/quic_config_peer.h"
 #include "quic/test_tools/quic_connection_peer.h"
@@ -33,6 +32,7 @@
 #include "quic/test_tools/quic_stream_peer.h"
 #include "quic/test_tools/quic_stream_sequencer_peer.h"
 #include "quic/test_tools/quic_test_utils.h"
+#include "common/quiche_mem_slice_storage.h"
 
 using testing::_;
 using testing::AnyNumber;
@@ -1171,7 +1171,7 @@
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
       .WillOnce(Return(QuicConsumedData(0, false)));
   struct iovec iov = {const_cast<char*>(data.data()), data.length()};
-  QuicMemSliceStorage storage(
+  quiche::QuicheMemSliceStorage storage(
       &iov, 1, session_->connection()->helper()->GetStreamSendBufferAllocator(),
       1024);
   QuicConsumedData consumed = stream_->WriteMemSlices(storage.ToSpan(), false);
@@ -1184,7 +1184,7 @@
   EXPECT_FALSE(stream_->CanWriteNewData());
 
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).Times(0);
-  QuicMemSliceStorage storage2(
+  quiche::QuicheMemSliceStorage storage2(
       &iov, 1, session_->connection()->helper()->GetStreamSendBufferAllocator(),
       1024);
   consumed = stream_->WriteMemSlices(storage2.ToSpan(), false);
@@ -1210,7 +1210,7 @@
 
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).Times(0);
   // All data can be consumed as buffered data is below upper limit.
-  QuicMemSliceStorage storage3(
+  quiche::QuicheMemSliceStorage storage3(
       &iov, 1, session_->connection()->helper()->GetStreamSendBufferAllocator(),
       1024);
   consumed = stream_->WriteMemSlices(storage3.ToSpan(), false);
@@ -1229,13 +1229,13 @@
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
       .WillOnce(Invoke(session_.get(), &MockQuicSession::ConsumeData));
   struct iovec iov = {const_cast<char*>(data.data()), 5u};
-  QuicMemSliceStorage storage(
+  quiche::QuicheMemSliceStorage storage(
       &iov, 1, session_->connection()->helper()->GetStreamSendBufferAllocator(),
       1024);
   QuicConsumedData consumed = stream_->WriteMemSlices(storage.ToSpan(), false);
   EXPECT_EQ(data.length(), consumed.bytes_consumed);
   struct iovec iov2 = {const_cast<char*>(data.data()), 1u};
-  QuicMemSliceStorage storage2(
+  quiche::QuicheMemSliceStorage storage2(
       &iov2, 1,
       session_->connection()->helper()->GetStreamSendBufferAllocator(), 1024);
   EXPECT_CALL(*connection_, CloseConnection(QUIC_STREAM_LENGTH_OVERFLOW, _, _));
@@ -1251,14 +1251,14 @@
   constexpr QuicByteCount kDataSize = 1024;
   QuicBufferAllocator* allocator =
       connection_->helper()->GetStreamSendBufferAllocator();
-  std::vector<QuicMemSlice> vector1;
-  vector1.push_back(QuicMemSlice(QuicBuffer(allocator, kDataSize)));
-  vector1.push_back(QuicMemSlice(QuicBuffer(allocator, kDataSize)));
-  std::vector<QuicMemSlice> vector2;
-  vector2.push_back(QuicMemSlice(QuicBuffer(allocator, kDataSize)));
-  vector2.push_back(QuicMemSlice(QuicBuffer(allocator, kDataSize)));
-  absl::Span<QuicMemSlice> span1(vector1);
-  absl::Span<QuicMemSlice> span2(vector2);
+  std::vector<quiche::QuicheMemSlice> vector1;
+  vector1.push_back(quiche::QuicheMemSlice(QuicBuffer(allocator, kDataSize)));
+  vector1.push_back(quiche::QuicheMemSlice(QuicBuffer(allocator, kDataSize)));
+  std::vector<quiche::QuicheMemSlice> vector2;
+  vector2.push_back(quiche::QuicheMemSlice(QuicBuffer(allocator, kDataSize)));
+  vector2.push_back(quiche::QuicheMemSlice(QuicBuffer(allocator, kDataSize)));
+  absl::Span<quiche::QuicheMemSlice> span1(vector1);
+  absl::Span<quiche::QuicheMemSlice> span2(vector2);
 
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
       .WillOnce(InvokeWithoutArgs([this]() {
@@ -1314,7 +1314,7 @@
   Initialize();
   QuicStreamPeer::SetStreamBytesWritten(kMaxStreamLength - 5u, stream_);
   std::vector<std::pair<char*, size_t>> buffers;
-  QuicMemSlice slice1 = MemSliceFromString("12345");
+  quiche::QuicheMemSlice slice1 = MemSliceFromString("12345");
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
       .WillOnce(InvokeWithoutArgs([this]() {
         return session_->ConsumeData(stream_->id(), 5u, 0u, NO_FIN,
@@ -1324,7 +1324,7 @@
   QuicConsumedData consumed = stream_->WriteMemSlice(std::move(slice1), false);
   EXPECT_EQ(5u, consumed.bytes_consumed);
 
-  QuicMemSlice slice2 = MemSliceFromString("6");
+  quiche::QuicheMemSlice slice2 = MemSliceFromString("6");
   EXPECT_CALL(*connection_, CloseConnection(QUIC_STREAM_LENGTH_OVERFLOW, _, _));
   EXPECT_QUIC_BUG(stream_->WriteMemSlice(std::move(slice2), false),
                   "Write too many data via stream");
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc
index 021fe24..caffd7f 100644
--- a/quic/core/quic_utils.cc
+++ b/quic/core/quic_utils.cc
@@ -22,8 +22,8 @@
 #include "quic/platform/api/quic_bug_tracker.h"
 #include "quic/platform/api/quic_flag_utils.h"
 #include "quic/platform/api/quic_flags.h"
-#include "quic/platform/api/quic_mem_slice.h"
 #include "common/platform/api/quiche_logging.h"
+#include "common/platform/api/quiche_mem_slice.h"
 #include "common/platform/api/quiche_prefetch.h"
 #include "common/quiche_endian.h"
 
@@ -729,9 +729,9 @@
          QuicUtils::IsClientInitiatedStreamId(version.transport_version, id);
 }
 
-QuicByteCount MemSliceSpanTotalSize(absl::Span<QuicMemSlice> span) {
+QuicByteCount MemSliceSpanTotalSize(absl::Span<quiche::QuicheMemSlice> span) {
   QuicByteCount total = 0;
-  for (const QuicMemSlice& slice : span) {
+  for (const quiche::QuicheMemSlice& slice : span) {
     total += slice.length();
   }
   return total;
diff --git a/quic/core/quic_utils.h b/quic/core/quic_utils.h
index 9b5c6ff..43e6470 100644
--- a/quic/core/quic_utils.h
+++ b/quic/core/quic_utils.h
@@ -22,8 +22,8 @@
 #include "quic/core/quic_versions.h"
 #include "quic/platform/api/quic_export.h"
 #include "quic/platform/api/quic_iovec.h"
-#include "quic/platform/api/quic_mem_slice.h"
 #include "quic/platform/api/quic_socket_address.h"
+#include "common/platform/api/quiche_mem_slice.h"
 
 namespace quic {
 
@@ -254,7 +254,7 @@
 bool IsValidWebTransportSessionId(WebTransportSessionId id,
                                   ParsedQuicVersion transport_version);
 
-QuicByteCount MemSliceSpanTotalSize(absl::Span<QuicMemSlice> span);
+QuicByteCount MemSliceSpanTotalSize(absl::Span<quiche::QuicheMemSlice> span);
 
 // Computes a SHA-256 hash and returns the raw bytes of the hash.
 QUIC_EXPORT_PRIVATE std::string RawSha256(absl::string_view input);
diff --git a/quic/core/web_transport_interface.h b/quic/core/web_transport_interface.h
index 102fd1f..6f2941e 100644
--- a/quic/core/web_transport_interface.h
+++ b/quic/core/web_transport_interface.h
@@ -16,6 +16,7 @@
 #include "quic/core/quic_datagram_queue.h"
 #include "quic/core/quic_types.h"
 #include "quic/platform/api/quic_export.h"
+#include "common/platform/api/quiche_mem_slice.h"
 #include "spdy/core/spdy_header_block.h"
 
 namespace quic {
@@ -137,7 +138,8 @@
   virtual WebTransportStream* OpenOutgoingBidirectionalStream() = 0;
   virtual WebTransportStream* OpenOutgoingUnidirectionalStream() = 0;
 
-  virtual MessageStatus SendOrQueueDatagram(QuicMemSlice datagram) = 0;
+  virtual MessageStatus SendOrQueueDatagram(
+      quiche::QuicheMemSlice datagram) = 0;
   // Returns a conservative estimate of the largest datagram size that the
   // session would be able to send.
   virtual QuicByteCount GetMaxDatagramSize() const = 0;
diff --git a/quic/masque/masque_compression_engine.cc b/quic/masque/masque_compression_engine.cc
index 035b9f9..ca9ed93 100644
--- a/quic/masque/masque_compression_engine.cc
+++ b/quic/masque/masque_compression_engine.cc
@@ -15,6 +15,7 @@
 #include "quic/core/quic_types.h"
 #include "quic/core/quic_versions.h"
 #include "quic/platform/api/quic_containers.h"
+#include "common/platform/api/quiche_mem_slice.h"
 #include "common/quiche_text_utils.h"
 
 namespace quic {
@@ -281,7 +282,7 @@
   }
 
   MessageResult message_result =
-      masque_session_->SendMessage(QuicMemSlice(std::move(buffer)));
+      masque_session_->SendMessage(quiche::QuicheMemSlice(std::move(buffer)));
 
   QUIC_DVLOG(1) << "Sent packet compressed with flow ID " << flow_id
                 << " and got message result " << message_result;
diff --git a/quic/platform/api/quic_mem_slice.h b/quic/platform/api/quic_mem_slice.h
deleted file mode 100644
index adc03d4..0000000
--- a/quic/platform/api/quic_mem_slice.h
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_H_
-#define QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_H_
-
-#include <memory>
-
-#include "absl/strings/string_view.h"
-#include "quic/platform/api/quic_export.h"
-#include "net/quic/platform/impl/quic_mem_slice_impl.h"
-
-/* API_DESCRIPTION
- QuicMemSlice is used to wrap application data and pass to QUIC stream's write
- interface. It refers to a memory block of data which should be around till
- QuicMemSlice::Reset() is called. It's upto each platform, to implement it as
- reference counted or not.
- API-DESCRIPTION */
-
-namespace quic {
-
-// QuicMemSlice is an internally reference counted data buffer used as the
-// source buffers for write operations. QuicMemSlice implicitly maintains a
-// reference count and will free the underlying data buffer when the reference
-// count reaches zero.
-class QUIC_EXPORT_PRIVATE QuicMemSlice {
- public:
-  // Constructs a empty QuicMemSlice with no underlying data and 0 reference
-  // count.
-  QuicMemSlice() = default;
-
-  // Constructs a QuicMemSlice that takes ownership of |buffer|.  |length| must
-  // not be zero.  To construct an empty QuicMemSlice, use the zero-argument
-  // constructor instead.
-  // TODO(vasilvv): switch all users to QuicBuffer version, and make this
-  // private.
-  QuicMemSlice(QuicUniqueBufferPtr buffer, size_t length)
-      : impl_(std::move(buffer), length) {}
-
-  // Constructs a QuicMemSlice that takes ownership of |buffer|.  The length of
-  // the |buffer| must not be zero.  To construct an empty QuicMemSlice, use the
-  // zero-argument constructor instead.
-  explicit QuicMemSlice(QuicBuffer buffer) : QuicMemSlice() {
-    // Store the size of the buffer *before* calling buffer.Release().
-    const size_t size = buffer.size();
-    *this = QuicMemSlice(buffer.Release(), size);
-  }
-
-  // Constructs a QuicMemSlice that takes ownership of |buffer| allocated on
-  // heap.  |length| must not be zero.
-  QuicMemSlice(std::unique_ptr<char[]> buffer, size_t length)
-      : impl_(std::move(buffer), length) {}
-
-  // Constructs QuicMemSlice from |impl|. It takes the reference away from
-  // |impl|.
-  explicit QuicMemSlice(QuicMemSliceImpl impl) : impl_(std::move(impl)) {}
-
-  QuicMemSlice(const QuicMemSlice& other) = delete;
-  QuicMemSlice& operator=(const QuicMemSlice& other) = delete;
-
-  // Move constructors. |other| will not hold a reference to the data buffer
-  // after this call completes.
-  QuicMemSlice(QuicMemSlice&& other) = default;
-  QuicMemSlice& operator=(QuicMemSlice&& other) = default;
-
-  ~QuicMemSlice() = default;
-
-  // Release the underlying reference. Further access the memory will result in
-  // undefined behavior.
-  void Reset() { impl_.Reset(); }
-
-  // Returns a const char pointer to underlying data buffer.
-  const char* data() const { return impl_.data(); }
-  // Returns the length of underlying data buffer.
-  size_t length() const { return impl_.length(); }
-  // Returns the representation of the underlying data as a string view.
-  absl::string_view AsStringView() const {
-    return absl::string_view(data(), length());
-  }
-
-  bool empty() const { return impl_.empty(); }
-
-  QuicMemSliceImpl* impl() { return &impl_; }
-
- private:
-  QuicMemSliceImpl impl_;
-};
-
-}  // namespace quic
-
-#endif  // QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_H_
diff --git a/quic/platform/api/quic_mem_slice_storage.cc b/quic/platform/api/quic_mem_slice_storage.cc
deleted file mode 100644
index 87bce7f..0000000
--- a/quic/platform/api/quic_mem_slice_storage.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright 2021 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "quic/platform/api/quic_mem_slice_storage.h"
-
-#include "quic/core/quic_utils.h"
-
-namespace quic {
-
-QuicMemSliceStorage::QuicMemSliceStorage(const struct iovec* iov, int iov_count,
-                                         QuicBufferAllocator* allocator,
-                                         const QuicByteCount max_slice_len) {
-  if (iov == nullptr) {
-    return;
-  }
-  QuicByteCount write_len = 0;
-  for (int i = 0; i < iov_count; ++i) {
-    write_len += iov[i].iov_len;
-  }
-  QUICHE_DCHECK_LT(0u, write_len);
-
-  size_t io_offset = 0;
-  while (write_len > 0) {
-    size_t slice_len = std::min(write_len, max_slice_len);
-    QuicBuffer buffer(allocator, slice_len);
-    QuicUtils::CopyToBuffer(iov, iov_count, io_offset, slice_len,
-                            buffer.data());
-    storage_.push_back(QuicMemSlice(std::move(buffer)));
-    write_len -= slice_len;
-    io_offset += slice_len;
-  }
-}
-
-}  // namespace quic
diff --git a/quic/platform/api/quic_mem_slice_storage.h b/quic/platform/api/quic_mem_slice_storage.h
deleted file mode 100644
index 4cccee3..0000000
--- a/quic/platform/api/quic_mem_slice_storage.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_STORAGE_H_
-#define QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_STORAGE_H_
-
-#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_export.h"
-#include "quic/platform/api/quic_iovec.h"
-#include "quic/platform/api/quic_mem_slice.h"
-
-namespace quic {
-
-// QuicMemSliceStorage is a container class that store QuicMemSlices for further
-// use cases such as turning into QuicMemSliceSpan.
-class QUIC_EXPORT_PRIVATE QuicMemSliceStorage {
- public:
-  QuicMemSliceStorage(const struct iovec* iov, int iov_count,
-                      QuicBufferAllocator* allocator,
-                      const QuicByteCount max_slice_len);
-
-  QuicMemSliceStorage(const QuicMemSliceStorage& other) = default;
-  QuicMemSliceStorage& operator=(const QuicMemSliceStorage& other) = default;
-  QuicMemSliceStorage(QuicMemSliceStorage&& other) = default;
-  QuicMemSliceStorage& operator=(QuicMemSliceStorage&& other) = default;
-
-  ~QuicMemSliceStorage() = default;
-
-  // Return a QuicMemSliceSpan form of the storage.
-  absl::Span<QuicMemSlice> ToSpan() { return absl::MakeSpan(storage_); }
-
- private:
-  std::vector<QuicMemSlice> storage_;
-};
-
-}  // namespace quic
-
-#endif  // QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_STORAGE_H_
diff --git a/quic/platform/api/quic_mem_slice_storage_test.cc b/quic/platform/api/quic_mem_slice_storage_test.cc
deleted file mode 100644
index 4bef774..0000000
--- a/quic/platform/api/quic_mem_slice_storage_test.cc
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "quic/platform/api/quic_mem_slice_storage.h"
-
-#include "quic/core/quic_simple_buffer_allocator.h"
-#include "quic/platform/api/quic_test.h"
-
-namespace quic {
-namespace test {
-namespace {
-
-class QuicMemSliceStorageImplTest : public QuicTest {
- public:
-  QuicMemSliceStorageImplTest() = default;
-};
-
-TEST_F(QuicMemSliceStorageImplTest, EmptyIov) {
-  QuicMemSliceStorage storage(nullptr, 0, nullptr, 1024);
-  EXPECT_TRUE(storage.ToSpan().empty());
-}
-
-TEST_F(QuicMemSliceStorageImplTest, SingleIov) {
-  SimpleBufferAllocator allocator;
-  std::string body(3, 'c');
-  struct iovec iov = {const_cast<char*>(body.data()), body.length()};
-  QuicMemSliceStorage storage(&iov, 1, &allocator, 1024);
-  auto span = storage.ToSpan();
-  EXPECT_EQ("ccc", span[0].AsStringView());
-  EXPECT_NE(static_cast<const void*>(span[0].data()), body.data());
-}
-
-TEST_F(QuicMemSliceStorageImplTest, MultipleIovInSingleSlice) {
-  SimpleBufferAllocator allocator;
-  std::string body1(3, 'a');
-  std::string body2(4, 'b');
-  struct iovec iov[] = {{const_cast<char*>(body1.data()), body1.length()},
-                        {const_cast<char*>(body2.data()), body2.length()}};
-
-  QuicMemSliceStorage storage(iov, 2, &allocator, 1024);
-  auto span = storage.ToSpan();
-  EXPECT_EQ("aaabbbb", span[0].AsStringView());
-}
-
-TEST_F(QuicMemSliceStorageImplTest, MultipleIovInMultipleSlice) {
-  SimpleBufferAllocator allocator;
-  std::string body1(4, 'a');
-  std::string body2(4, 'b');
-  struct iovec iov[] = {{const_cast<char*>(body1.data()), body1.length()},
-                        {const_cast<char*>(body2.data()), body2.length()}};
-
-  QuicMemSliceStorage storage(iov, 2, &allocator, 4);
-  auto span = storage.ToSpan();
-  EXPECT_EQ("aaaa", span[0].AsStringView());
-  EXPECT_EQ("bbbb", span[1].AsStringView());
-}
-
-}  // namespace
-}  // namespace test
-}  // namespace quic
diff --git a/quic/qbone/qbone_session_base.cc b/quic/qbone/qbone_session_base.cc
index 702f185..a5e8a2d 100644
--- a/quic/qbone/qbone_session_base.cc
+++ b/quic/qbone/qbone_session_base.cc
@@ -19,6 +19,7 @@
 #include "quic/qbone/platform/icmp_packet.h"
 #include "quic/qbone/qbone_constants.h"
 #include "common/platform/api/quiche_command_line_flags.h"
+#include "common/platform/api/quiche_mem_slice.h"
 
 DEFINE_QUICHE_COMMAND_LINE_FLAG(
     bool, qbone_close_ephemeral_frames, true,
@@ -139,7 +140,7 @@
   }
 
   if (send_packets_as_messages_) {
-    QuicMemSlice slice(QuicBuffer::Copy(
+    quiche::QuicheMemSlice slice(QuicBuffer::Copy(
         connection()->helper()->GetStreamSendBufferAllocator(), packet));
     switch (SendMessage(absl::MakeSpan(&slice, 1), /*flush=*/true).status) {
       case MESSAGE_STATUS_SUCCESS:
diff --git a/quic/quic_transport/quic_transport_client_session.h b/quic/quic_transport/quic_transport_client_session.h
index 8785457..f5374de 100644
--- a/quic/quic_transport/quic_transport_client_session.h
+++ b/quic/quic_transport/quic_transport_client_session.h
@@ -28,6 +28,7 @@
 #include "quic/quic_transport/quic_transport_protocol.h"
 #include "quic/quic_transport/quic_transport_session_interface.h"
 #include "quic/quic_transport/quic_transport_stream.h"
+#include "common/platform/api/quiche_mem_slice.h"
 
 namespace quic {
 
@@ -99,7 +100,7 @@
   QuicTransportStream* OpenOutgoingBidirectionalStream() override;
   QuicTransportStream* OpenOutgoingUnidirectionalStream() override;
 
-  MessageStatus SendOrQueueDatagram(QuicMemSlice datagram) override {
+  MessageStatus SendOrQueueDatagram(quiche::QuicheMemSlice datagram) override {
     return datagram_queue()->SendOrQueueDatagram(std::move(datagram));
   }
   void SetDatagramMaxTimeInQueue(QuicTime::Delta max_time_in_queue) override {
diff --git a/quic/test_tools/quic_test_backend.cc b/quic/test_tools/quic_test_backend.cc
index 3cfe927..12f530a 100644
--- a/quic/test_tools/quic_test_backend.cc
+++ b/quic/test_tools/quic_test_backend.cc
@@ -13,7 +13,6 @@
 #include "quic/core/quic_buffer_allocator.h"
 #include "quic/core/quic_simple_buffer_allocator.h"
 #include "quic/core/web_transport_interface.h"
-#include "quic/platform/api/quic_mem_slice.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 1149721..52eafed 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -1310,13 +1310,13 @@
              : default_type;
 }
 
-QuicMemSlice MemSliceFromString(absl::string_view data) {
+quiche::QuicheMemSlice MemSliceFromString(absl::string_view data) {
   if (data.empty()) {
-    return QuicMemSlice();
+    return quiche::QuicheMemSlice();
   }
 
   static SimpleBufferAllocator* allocator = new SimpleBufferAllocator();
-  return QuicMemSlice(QuicBuffer::Copy(allocator, data));
+  return quiche::QuicheMemSlice(QuicBuffer::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 8d12d16..705f951 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -33,7 +33,6 @@
 #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_mem_slice_storage.h"
 #include "quic/platform/api/quic_socket_address.h"
 #include "quic/platform/api/quic_test.h"
 #include "quic/test_tools/mock_clock.h"
@@ -41,6 +40,7 @@
 #include "quic/test_tools/mock_random.h"
 #include "quic/test_tools/quic_framer_peer.h"
 #include "quic/test_tools/simple_quic_framer.h"
+#include "common/quiche_mem_slice_storage.h"
 
 namespace quic {
 
@@ -645,7 +645,8 @@
               (override));
   MOCK_METHOD(bool, SendControlFrame, (const QuicFrame& frame), (override));
   MOCK_METHOD(MessageStatus, SendMessage,
-              (QuicMessageId, absl::Span<QuicMemSlice>, bool), (override));
+              (QuicMessageId, absl::Span<quiche::QuicheMemSlice>, bool),
+              (override));
   MOCK_METHOD(bool, SendPathChallenge,
               (const QuicPathFrameBuffer&, const QuicSocketAddress&,
                const QuicSocketAddress&, const QuicSocketAddress&,
@@ -1534,7 +1535,7 @@
 
 // Creates a MemSlice using a singleton trivial buffer allocator.  Performs a
 // copy.
-QuicMemSlice MemSliceFromString(absl::string_view data);
+quiche::QuicheMemSlice MemSliceFromString(absl::string_view data);
 
 // Used to compare ReceivedPacketInfo.
 MATCHER_P(ReceivedPacketInfoEquals, info, "") {
diff --git a/quic/tools/quic_transport_simple_server_session.cc b/quic/tools/quic_transport_simple_server_session.cc
index bc7ef19..f4496fa 100644
--- a/quic/tools/quic_transport_simple_server_session.cc
+++ b/quic/tools/quic_transport_simple_server_session.cc
@@ -16,6 +16,7 @@
 #include "quic/quic_transport/quic_transport_protocol.h"
 #include "quic/quic_transport/quic_transport_stream.h"
 #include "quic/tools/web_transport_test_visitors.h"
+#include "common/platform/api/quiche_mem_slice.h"
 
 namespace quic {
 
@@ -131,7 +132,7 @@
       connection()->helper()->GetStreamSendBufferAllocator(), message.size());
   memcpy(buffer.get(), message.data(), message.size());
   datagram_queue()->SendOrQueueDatagram(
-      QuicMemSlice(std::move(buffer), message.size()));
+      quiche::QuicheMemSlice(std::move(buffer), message.size()));
 }
 
 void QuicTransportSimpleServerSession::MaybeEchoStreamsBack() {
diff --git a/quic/tools/web_transport_test_visitors.h b/quic/tools/web_transport_test_visitors.h
index b1f2246..9451ba7 100644
--- a/quic/tools/web_transport_test_visitors.h
+++ b/quic/tools/web_transport_test_visitors.h
@@ -10,6 +10,7 @@
 #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"
 
 namespace quic {
@@ -220,7 +221,7 @@
   void OnDatagramReceived(absl::string_view datagram) override {
     auto buffer = MakeUniqueBuffer(&allocator_, datagram.size());
     memcpy(buffer.get(), datagram.data(), datagram.size());
-    QuicMemSlice slice(std::move(buffer), datagram.size());
+    quiche::QuicheMemSlice slice(std::move(buffer), datagram.size());
     session_->SendOrQueueDatagram(std::move(slice));
   }