diff --git a/quiche/common/quiche_stream.h b/quiche/common/quiche_stream.h
index 5a8a1f7..c8718bd 100644
--- a/quiche/common/quiche_stream.h
+++ b/quiche/common/quiche_stream.h
@@ -15,6 +15,7 @@
 #include "absl/types/span.h"
 #include "quiche/common/platform/api/quiche_export.h"
 #include "quiche/common/quiche_callbacks.h"
+#include "quiche/common/quiche_mem_slice.h"
 
 namespace quiche {
 
@@ -161,42 +162,51 @@
  public:
   virtual ~WriteStream() {}
 
-  // Writes |data| into the stream.
-  virtual absl::Status Writev(absl::Span<const absl::string_view> data,
+  // Writes `data` into the stream.  If the write succeeds, the ownership is
+  // transferred to the stream; if it does not, the behavior is undefined -- the
+  // users of this API should check `CanWrite()` before calling `Writev()`.
+  virtual absl::Status Writev(absl::Span<QuicheMemSlice> data,
                               const StreamWriteOptions& options) = 0;
 
   // Indicates whether it is possible to write into stream right now.
   virtual bool CanWrite() const = 0;
 
   // Legacy convenience method for writing a single string_view.  New users
-  // should use quiche::WriteIntoStream instead, since this method does not
+  // should use quiche::SendFinOnStream instead, since this method does not
   // return useful failure information.
   [[nodiscard]] bool SendFin() {
     StreamWriteOptions options;
     options.set_send_fin(true);
-    return Writev(absl::Span<const absl::string_view>(), options).ok();
+    return Writev(absl::Span<QuicheMemSlice>(), options).ok();
   }
 
   // Legacy convenience method for writing a single string_view.  New users
   // should use quiche::WriteIntoStream instead, since this method does not
   // return useful failure information.
   [[nodiscard]] bool Write(absl::string_view data) {
-    return Writev(absl::MakeSpan(&data, 1), kDefaultStreamWriteOptions).ok();
+    QuicheMemSlice slice = QuicheMemSlice::Copy(data);
+    return Writev(absl::MakeSpan(&slice, 1), kDefaultStreamWriteOptions).ok();
   }
 };
 
 // Convenience methods to write a single chunk of data into the stream.
 inline absl::Status WriteIntoStream(
+    WriteStream& stream, QuicheMemSlice slice,
+    const StreamWriteOptions& options = kDefaultStreamWriteOptions) {
+  return stream.Writev(absl::MakeSpan(&slice, 1), options);
+}
+inline absl::Status WriteIntoStream(
     WriteStream& stream, absl::string_view data,
     const StreamWriteOptions& options = kDefaultStreamWriteOptions) {
-  return stream.Writev(absl::MakeSpan(&data, 1), options);
+  QuicheMemSlice slice = QuicheMemSlice::Copy(data);
+  return stream.Writev(absl::MakeSpan(&slice, 1), options);
 }
 
 // Convenience methods to send a FIN on the stream.
 inline absl::Status SendFinOnStream(WriteStream& stream) {
   StreamWriteOptions options;
   options.set_send_fin(true);
-  return stream.Writev(absl::Span<const absl::string_view>(), options);
+  return stream.Writev(absl::Span<QuicheMemSlice>(), options);
 }
 
 }  // namespace quiche
diff --git a/quiche/common/test_tools/mock_streams.h b/quiche/common/test_tools/mock_streams.h
index 577a324..7290490 100644
--- a/quiche/common/test_tools/mock_streams.h
+++ b/quiche/common/test_tools/mock_streams.h
@@ -14,6 +14,7 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
 #include "quiche/common/platform/api/quiche_test.h"
+#include "quiche/common/quiche_mem_slice.h"
 #include "quiche/common/quiche_stream.h"
 
 namespace quiche::test {
@@ -24,22 +25,22 @@
   MockWriteStream() {
     ON_CALL(*this, CanWrite()).WillByDefault(testing::Return(true));
     ON_CALL(*this, Writev(testing::_, testing::_))
-        .WillByDefault([&](absl::Span<const absl::string_view> data,
+        .WillByDefault([&](absl::Span<quiche::QuicheMemSlice> data,
                            const StreamWriteOptions& options) {
           return AppendToData(data, options);
         });
   }
 
   MOCK_METHOD(absl::Status, Writev,
-              (absl::Span<const absl::string_view> data,
+              (absl::Span<quiche::QuicheMemSlice> data,
                const StreamWriteOptions& options),
               (override));
   MOCK_METHOD(bool, CanWrite, (), (const, override));
 
-  absl::Status AppendToData(absl::Span<const absl::string_view> data,
+  absl::Status AppendToData(absl::Span<quiche::QuicheMemSlice> data,
                             const StreamWriteOptions& options) {
-    for (absl::string_view fragment : data) {
-      data_.append(fragment.data(), fragment.size());
+    for (const quiche::QuicheMemSlice& fragment : data) {
+      data_.append(fragment.data(), fragment.length());
     }
     ProcessOptions(options);
     return absl::OkStatus();
diff --git a/quiche/quic/core/http/end_to_end_test.cc b/quiche/quic/core/http/end_to_end_test.cc
index 87420ca..ac7c036 100644
--- a/quiche/quic/core/http/end_to_end_test.cc
+++ b/quiche/quic/core/http/end_to_end_test.cc
@@ -116,6 +116,7 @@
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_reference_counted.h"
 #include "quiche/common/platform/api/quiche_test.h"
+#include "quiche/common/quiche_mem_slice.h"
 #include "quiche/common/quiche_stream.h"
 #include "quiche/common/simple_buffer_allocator.h"
 #include "quiche/common/test_tools/quiche_test_utils.h"
@@ -7651,11 +7652,13 @@
   ASSERT_TRUE(stream != nullptr);
   // Test the full Writev() API.
   const std::string kLongString = std::string(16 * 1024, 'a');
-  std::vector<absl::string_view> write_vector = {"foo", "bar", "test",
-                                                 kLongString};
+  std::array write_vector = {quiche::QuicheMemSlice::Copy("foo"),
+                             quiche::QuicheMemSlice::Copy("bar"),
+                             quiche::QuicheMemSlice::Copy("test"),
+                             quiche::QuicheMemSlice::Copy(kLongString)};
   quiche::StreamWriteOptions options;
   options.set_send_fin(true);
-  QUICHE_EXPECT_OK(stream->Writev(absl::MakeConstSpan(write_vector), options));
+  QUICHE_EXPECT_OK(stream->Writev(absl::MakeSpan(write_vector), options));
 
   std::string received_data = ReadDataFromWebTransportStreamUntilFin(stream);
   EXPECT_EQ(received_data, absl::StrCat("foobartest", kLongString));
diff --git a/quiche/quic/core/http/web_transport_stream_adapter.cc b/quiche/quic/core/http/web_transport_stream_adapter.cc
index 4c26f37..fe68dfa 100644
--- a/quiche/quic/core/http/web_transport_stream_adapter.cc
+++ b/quiche/quic/core/http/web_transport_stream_adapter.cc
@@ -8,10 +8,8 @@
 #include <limits>
 #include <optional>
 #include <string>
-#include <utility>
 
 #include "absl/status/status.h"
-#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
 #include "quiche/quic/core/http/web_transport_http3.h"
@@ -21,15 +19,13 @@
 #include "quiche/quic/core/quic_stream_priority.h"
 #include "quiche/quic/core/quic_stream_sequencer.h"
 #include "quiche/quic/core/quic_types.h"
+#include "quiche/quic/core/quic_utils.h"
 #include "quiche/quic/core/web_transport_interface.h"
 #include "quiche/quic/platform/api/quic_bug_tracker.h"
-#include "quiche/quic/platform/api/quic_flags.h"
 #include "quiche/quic/platform/api/quic_logging.h"
 #include "quiche/common/platform/api/quiche_logging.h"
-#include "quiche/common/quiche_buffer_allocator.h"
 #include "quiche/common/quiche_mem_slice.h"
 #include "quiche/common/quiche_stream.h"
-#include "quiche/common/vectorized_io_utils.h"
 #include "quiche/web_transport/web_transport.h"
 
 namespace quic {
@@ -69,7 +65,7 @@
 }
 
 absl::Status WebTransportStreamAdapter::Writev(
-    absl::Span<const absl::string_view> data,
+    absl::Span<quiche::QuicheMemSlice> data,
     const quiche::StreamWriteOptions& options) {
   if (data.empty() && !options.send_fin()) {
     return absl::InvalidArgumentError(
@@ -82,21 +78,10 @@
     return initial_check_status;
   }
 
-  size_t total_size = quiche::TotalStringViewSpanSize(data);
-  quiche::QuicheMemSlice slice;
-  if (total_size > 0) {
-    quiche::QuicheBuffer buffer(
-        session_->connection()->helper()->GetStreamSendBufferAllocator(),
-        total_size);
-    size_t bytes_copied = quiche::GatherStringViewSpan(data, buffer.AsSpan());
-    QUICHE_DCHECK_EQ(total_size, bytes_copied);
-    slice = quiche::QuicheMemSlice(std::move(buffer));
-  }
+  size_t total_size = MemSliceSpanTotalSize(data);
   QuicConsumedData consumed = stream_->WriteMemSlices(
-      slice.empty() ? absl::Span<quiche::QuicheMemSlice>()
-                    : absl::MakeSpan(&slice, 1),
-      /*fin=*/options.send_fin(),
-      /*buffer_uncondtionally=*/options.buffer_unconditionally());
+      data, /*fin=*/options.send_fin(),
+      /*buffer_unconditionally=*/options.buffer_unconditionally());
 
   if (consumed.bytes_consumed == total_size) {
     return absl::OkStatus();
diff --git a/quiche/quic/core/http/web_transport_stream_adapter.h b/quiche/quic/core/http/web_transport_stream_adapter.h
index 94f3ba4..7107dd9 100644
--- a/quiche/quic/core/http/web_transport_stream_adapter.h
+++ b/quiche/quic/core/http/web_transport_stream_adapter.h
@@ -23,6 +23,7 @@
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/core/web_transport_interface.h"
 #include "quiche/common/platform/api/quiche_export.h"
+#include "quiche/common/quiche_mem_slice.h"
 #include "quiche/common/quiche_stream.h"
 #include "quiche/web_transport/web_transport.h"
 
@@ -39,7 +40,7 @@
   // WebTransportStream implementation.
   ABSL_MUST_USE_RESULT ReadResult Read(absl::Span<char> output) override;
   ABSL_MUST_USE_RESULT ReadResult Read(std::string* output) override;
-  absl::Status Writev(absl::Span<const absl::string_view> data,
+  absl::Status Writev(absl::Span<quiche::QuicheMemSlice> data,
                       const quiche::StreamWriteOptions& options) override;
   bool CanWrite() const override;
   void AbruptlyTerminate(absl::Status error) override;
diff --git a/quiche/quic/moqt/moqt_probe_manager.cc b/quiche/quic/moqt/moqt_probe_manager.cc
index c3745b3..c3d02ff 100644
--- a/quiche/quic/moqt/moqt_probe_manager.cc
+++ b/quiche/quic/moqt/moqt_probe_manager.cc
@@ -18,6 +18,7 @@
 #include "quiche/quic/moqt/moqt_priority.h"
 #include "quiche/common/platform/api/quiche_bug_tracker.h"
 #include "quiche/common/platform/api/quiche_logging.h"
+#include "quiche/common/quiche_mem_slice.h"
 #include "quiche/common/quiche_stream.h"
 #include "quiche/common/wire_serialization.h"
 #include "quiche/web_transport/web_transport.h"
@@ -80,7 +81,8 @@
 
   while (stream_->CanWrite() && data_remaining_ > 0) {
     quic::QuicByteCount chunk_size = std::min(kWriteChunkSize, data_remaining_);
-    absl::string_view chunk(kZeroes, chunk_size);
+    quiche::QuicheMemSlice chunk(
+        kZeroes, chunk_size, +[](absl::string_view) {});
     quiche::StreamWriteOptions options;
     options.set_send_fin(chunk_size == data_remaining_);
     absl::Status status = stream_->Writev(absl::MakeSpan(&chunk, 1), options);
diff --git a/quiche/quic/moqt/moqt_probe_manager_test.cc b/quiche/quic/moqt/moqt_probe_manager_test.cc
index a60cfa2..9e41f9b 100644
--- a/quiche/quic/moqt/moqt_probe_manager_test.cc
+++ b/quiche/quic/moqt/moqt_probe_manager_test.cc
@@ -19,6 +19,7 @@
 #include "quiche/quic/test_tools/quic_test_utils.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
+#include "quiche/common/quiche_mem_slice.h"
 #include "quiche/common/quiche_stream.h"
 #include "quiche/web_transport/test_tools/mock_web_transport.h"
 #include "quiche/web_transport/web_transport.h"
@@ -47,11 +48,11 @@
   MockStream(webtransport::StreamId id) : id_(id) {}
 
   webtransport::StreamId GetStreamId() const override { return id_; }
-  absl::Status Writev(absl::Span<const absl::string_view> data,
+  absl::Status Writev(absl::Span<quiche::QuicheMemSlice> data,
                       const quiche::StreamWriteOptions& options) override {
     QUICHE_CHECK(!fin_) << "FIN written twice.";
-    for (absl::string_view chunk : data) {
-      data_.append(chunk);
+    for (const quiche::QuicheMemSlice& slice : data) {
+      data_.append(slice.AsStringView());
     }
     fin_ = options.send_fin();
     return absl::OkStatus();
diff --git a/quiche/quic/moqt/moqt_session.cc b/quiche/quic/moqt/moqt_session.cc
index 8f9f585..ef1450b 100644
--- a/quiche/quic/moqt/moqt_session.cc
+++ b/quiche/quic/moqt/moqt_session.cc
@@ -598,7 +598,8 @@
           continue;
         }
         if (fetch->session_->WriteObjectToStream(
-                stream_, fetch->fetch_id_, object,
+                stream_, fetch->fetch_id_, object.metadata,
+                std::move(object.payload),
                 MoqtDataStreamType::kStreamHeaderFetch, !stream_header_written_,
                 /*fin=*/false)) {
           stream_header_written_ = true;
@@ -1566,7 +1567,7 @@
   // down the connection if we've buffered too many control messages; otherwise,
   // there is potential for memory exhaustion attacks.
   options.set_buffer_unconditionally(true);
-  std::array<absl::string_view, 1> write_vector = {message.AsStringView()};
+  std::array write_vector = {quiche::QuicheMemSlice(std::move(message))};
   absl::Status success = stream_->Writev(absl::MakeSpan(write_vector), options);
   if (!success.ok()) {
     session_->Error(MoqtError::kInternalError,
@@ -2237,7 +2238,8 @@
     }
 
     if (!session_->WriteObjectToStream(
-            stream_, subscription.track_alias(), *object,
+            stream_, subscription.track_alias(), object->metadata,
+            std::move(object->payload),
             MoqtDataStreamType::kStreamHeaderSubgroup, !stream_header_written_,
             object->fin_after_this)) {
       // WriteObjectToStream() closes the connection on error, meaning that
@@ -2277,28 +2279,30 @@
 }
 
 bool MoqtSession::WriteObjectToStream(webtransport::Stream* stream, uint64_t id,
-                                      const PublishedObject& object,
+                                      const PublishedObjectMetadata& metadata,
+                                      quiche::QuicheMemSlice payload,
                                       MoqtDataStreamType type,
                                       bool is_first_on_stream, bool fin) {
   QUICHE_DCHECK(stream->CanWrite());
   MoqtObject header;
   header.track_alias = id;
-  header.group_id = object.metadata.location.group;
-  header.subgroup_id = object.metadata.subgroup;
-  header.object_id = object.metadata.location.object;
-  header.publisher_priority = object.metadata.publisher_priority;
-  header.object_status = object.metadata.status;
-  header.payload_length = object.payload.length();
+  header.group_id = metadata.location.group;
+  header.subgroup_id = metadata.subgroup;
+  header.object_id = metadata.location.object;
+  header.publisher_priority = metadata.publisher_priority;
+  header.object_status = metadata.status;
+  header.payload_length = payload.length();
 
   quiche::QuicheBuffer serialized_header =
       framer_.SerializeObjectHeader(header, type, is_first_on_stream);
   // TODO(vasilvv): add a version of WebTransport write API that accepts
   // memslices so that we can avoid a copy here.
-  std::array<absl::string_view, 2> write_vector = {
-      serialized_header.AsStringView(), object.payload.AsStringView()};
+  std::array write_vector = {
+      quiche::QuicheMemSlice(std::move(serialized_header)), std::move(payload)};
   quiche::StreamWriteOptions options;
   options.set_send_fin(fin);
-  absl::Status write_status = stream->Writev(write_vector, options);
+  absl::Status write_status =
+      stream->Writev(absl::MakeSpan(write_vector), options);
   if (!write_status.ok()) {
     QUICHE_BUG(MoqtSession_WriteObjectToStream_write_failed)
         << "Writing into MoQT stream failed despite CanWrite() being true "
@@ -2309,7 +2313,7 @@
   }
 
   QUIC_DVLOG(1) << "Stream " << stream->GetStreamId() << " successfully wrote "
-                << object.metadata.location << ", fin = " << fin;
+                << metadata.location << ", fin = " << fin;
   return true;
 }
 
diff --git a/quiche/quic/moqt/moqt_session.h b/quiche/quic/moqt/moqt_session.h
index 63cbab8..356a4eb 100644
--- a/quiche/quic/moqt/moqt_session.h
+++ b/quiche/quic/moqt/moqt_session.h
@@ -36,6 +36,7 @@
 #include "quiche/common/platform/api/quiche_export.h"
 #include "quiche/common/quiche_buffer_allocator.h"
 #include "quiche/common/quiche_callbacks.h"
+#include "quiche/common/quiche_mem_slice.h"
 #include "quiche/common/quiche_weak_ptr.h"
 #include "quiche/web_transport/web_transport.h"
 
@@ -670,7 +671,8 @@
   // and metadata in |object|. Not for use with datagrams. Returns |true| if
   // the write was successful.
   bool WriteObjectToStream(webtransport::Stream* stream, uint64_t id,
-                           const PublishedObject& object,
+                           const PublishedObjectMetadata& metadata,
+                           quiche::QuicheMemSlice payload,
                            MoqtDataStreamType type, bool is_first_on_stream,
                            bool fin);
 
diff --git a/quiche/quic/moqt/moqt_session_test.cc b/quiche/quic/moqt/moqt_session_test.cc
index 8131aa2..80b3520 100644
--- a/quiche/quic/moqt/moqt_session_test.cc
+++ b/quiche/quic/moqt/moqt_session_test.cc
@@ -1272,9 +1272,10 @@
   bool correct_message = false;
   const std::string kExpectedMessage = {0x04, 0x02, 0x05, 0x00, 0x7f};
   EXPECT_CALL(mock_stream_, Writev(_, _))
-      .WillOnce([&](absl::Span<const absl::string_view> data,
+      .WillOnce([&](absl::Span<quiche::QuicheMemSlice> data,
                     const quiche::StreamWriteOptions& options) {
-        correct_message = absl::StartsWith(data[0], kExpectedMessage);
+        correct_message =
+            absl::StartsWith(data[0].AsStringView(), kExpectedMessage);
         fin |= options.send_fin();
         return absl::OkStatus();
       });
@@ -1324,9 +1325,10 @@
   bool correct_message = false;
   const std::string kExpectedMessage = {0x04, 0x02, 0x05, 0x00, 0x7f};
   EXPECT_CALL(mock_stream_, Writev(_, _))
-      .WillOnce([&](absl::Span<const absl::string_view> data,
+      .WillOnce([&](absl::Span<quiche::QuicheMemSlice> data,
                     const quiche::StreamWriteOptions& options) {
-        correct_message = absl::StartsWith(data[0], kExpectedMessage);
+        correct_message =
+            absl::StartsWith(data[0].AsStringView(), kExpectedMessage);
         fin = options.send_fin();
         return absl::OkStatus();
       });
@@ -1374,9 +1376,10 @@
   bool correct_message = false;
   const std::string kExpectedMessage = {0x04, 0x02, 0x05, 0x00, 0x7f};
   EXPECT_CALL(mock_stream_, Writev(_, _))
-      .WillOnce([&](absl::Span<const absl::string_view> data,
+      .WillOnce([&](absl::Span<quiche::QuicheMemSlice> data,
                     const quiche::StreamWriteOptions& options) {
-        correct_message = absl::StartsWith(data[0], kExpectedMessage);
+        correct_message =
+            absl::StartsWith(data[0].AsStringView(), kExpectedMessage);
         fin |= options.send_fin();
         return absl::OkStatus();
       });
@@ -1427,9 +1430,10 @@
   bool correct_message = false;
   const std::string kExpectedMessage = {0x04, 0x02, 0x05, 0x00, 0x7f};
   EXPECT_CALL(mock_stream_, Writev)
-      .WillOnce([&](absl::Span<const absl::string_view> data,
+      .WillOnce([&](absl::Span<quiche::QuicheMemSlice> data,
                     const quiche::StreamWriteOptions& options) {
-        correct_message = absl::StartsWith(data[0], kExpectedMessage);
+        correct_message =
+            absl::StartsWith(data[0].AsStringView(), kExpectedMessage);
         fin = options.send_fin();
         return absl::OkStatus();
       });
@@ -1447,7 +1451,7 @@
   EXPECT_FALSE(fin);
   fin = false;
   EXPECT_CALL(mock_stream_, Writev)
-      .WillOnce([&](absl::Span<const absl::string_view> data,
+      .WillOnce([&](absl::Span<quiche::QuicheMemSlice> data,
                     const quiche::StreamWriteOptions& options) {
         EXPECT_TRUE(data.empty());
         fin = options.send_fin();
@@ -1486,9 +1490,10 @@
   bool correct_message = false;
   const std::string kExpectedMessage = {0x04, 0x02, 0x05, 0x7f, 0x00, 0x00};
   EXPECT_CALL(mock_stream_, Writev(_, _))
-      .WillOnce([&](absl::Span<const absl::string_view> data,
+      .WillOnce([&](absl::Span<quiche::QuicheMemSlice> data,
                     const quiche::StreamWriteOptions& options) {
-        correct_message = absl::StartsWith(data[0], kExpectedMessage);
+        correct_message =
+            absl::StartsWith(data[0].AsStringView(), kExpectedMessage);
         fin = options.send_fin();
         return absl::OkStatus();
       });
@@ -1527,9 +1532,10 @@
     return std::optional<PublishedObject>();
   });
   EXPECT_CALL(mock_stream_, Writev(_, _))
-      .WillOnce([&](absl::Span<const absl::string_view> data,
+      .WillOnce([&](absl::Span<quiche::QuicheMemSlice> data,
                     const quiche::StreamWriteOptions& options) {
-        correct_message = absl::StartsWith(data[0], kExpectedMessage2);
+        correct_message =
+            absl::StartsWith(data[0].AsStringView(), kExpectedMessage2);
         fin = options.send_fin();
         return absl::OkStatus();
       });
@@ -1568,9 +1574,10 @@
   bool correct_message = false;
   const std::string kExpectedMessage = {0x04, 0x02, 0x05, 0x7f, 0x00, 0x00};
   EXPECT_CALL(mock_stream_, Writev(_, _))
-      .WillOnce([&](absl::Span<const absl::string_view> data,
+      .WillOnce([&](absl::Span<quiche::QuicheMemSlice> data,
                     const quiche::StreamWriteOptions& options) {
-        correct_message = absl::StartsWith(data[0], kExpectedMessage);
+        correct_message =
+            absl::StartsWith(data[0].AsStringView(), kExpectedMessage);
         fin = options.send_fin();
         return absl::OkStatus();
       });
@@ -2012,24 +2019,24 @@
   EXPECT_CALL(mock_stream1, CanWrite()).WillRepeatedly(Return(true));
   EXPECT_CALL(mock_stream2, CanWrite()).WillRepeatedly(Return(true));
   EXPECT_CALL(mock_stream0, Writev(_, _))
-      .WillOnce([&](absl::Span<const absl::string_view> data,
+      .WillOnce([&](absl::Span<quiche::QuicheMemSlice> data,
                     const quiche::StreamWriteOptions& options) {
         // The Group ID is the 3rd byte of the stream.
-        EXPECT_EQ(static_cast<const uint8_t>(data[0][2]), 0);
+        EXPECT_EQ(static_cast<const uint8_t>(data[0].AsStringView()[2]), 0);
         return absl::OkStatus();
       });
   EXPECT_CALL(mock_stream1, Writev(_, _))
-      .WillOnce([&](absl::Span<const absl::string_view> data,
+      .WillOnce([&](absl::Span<quiche::QuicheMemSlice> data,
                     const quiche::StreamWriteOptions& options) {
         // The Group ID is the 3rd byte of the stream.
-        EXPECT_EQ(static_cast<const uint8_t>(data[0][2]), 1);
+        EXPECT_EQ(static_cast<const uint8_t>(data[0].AsStringView()[2]), 1);
         return absl::OkStatus();
       });
   EXPECT_CALL(mock_stream2, Writev(_, _))
-      .WillOnce([&](absl::Span<const absl::string_view> data,
+      .WillOnce([&](absl::Span<quiche::QuicheMemSlice> data,
                     const quiche::StreamWriteOptions& options) {
         // The Group ID is the 3rd byte of the stream.
-        EXPECT_EQ(static_cast<const uint8_t>(data[0][2]), 2);
+        EXPECT_EQ(static_cast<const uint8_t>(data[0].AsStringView()[2]), 2);
         return absl::OkStatus();
       });
   session_.OnCanCreateNewOutgoingUnidirectionalStream();
@@ -2114,12 +2121,12 @@
   EXPECT_CALL(*track1, GetCachedObject(0, 0, 1)).WillOnce(Return(std::nullopt));
   EXPECT_CALL(mock_stream0, CanWrite()).WillRepeatedly(Return(true));
   EXPECT_CALL(mock_stream0, Writev)
-      .WillOnce([&](absl::Span<const absl::string_view> data,
+      .WillOnce([&](absl::Span<quiche::QuicheMemSlice> data,
                     const quiche::StreamWriteOptions& options) {
         // Check track alias is 14.
-        EXPECT_EQ(static_cast<const uint8_t>(data[0][1]), 14);
+        EXPECT_EQ(static_cast<const uint8_t>(data[0].AsStringView()[1]), 14);
         // Check Group ID is 0
-        EXPECT_EQ(static_cast<const uint8_t>(data[0][2]), 0);
+        EXPECT_EQ(static_cast<const uint8_t>(data[0].AsStringView()[2]), 0);
         return absl::OkStatus();
       });
   session_.OnCanCreateNewOutgoingUnidirectionalStream();
@@ -2150,12 +2157,12 @@
   EXPECT_CALL(*track2, GetCachedObject(0, 0, 1)).WillOnce(Return(std::nullopt));
   EXPECT_CALL(mock_stream1, CanWrite()).WillRepeatedly(Return(true));
   EXPECT_CALL(mock_stream1, Writev(_, _))
-      .WillOnce([&](absl::Span<const absl::string_view> data,
+      .WillOnce([&](absl::Span<quiche::QuicheMemSlice> data,
                     const quiche::StreamWriteOptions& options) {
         // Check track alias is 15.
-        EXPECT_EQ(static_cast<const uint8_t>(data[0][1]), 15);
+        EXPECT_EQ(static_cast<const uint8_t>(data[0].AsStringView()[1]), 15);
         // Check Group ID is 0
-        EXPECT_EQ(static_cast<const uint8_t>(data[0][2]), 0);
+        EXPECT_EQ(static_cast<const uint8_t>(data[0].AsStringView()[2]), 0);
         return absl::OkStatus();
       });
   session_.OnCanCreateNewOutgoingUnidirectionalStream();
@@ -2207,9 +2214,9 @@
           Invoke([=](PublishedObject& /*output*/) { return second_result; }));
   if (second_result == MoqtFetchTask::GetNextObjectResult::kEof) {
     EXPECT_CALL(data_stream, Writev)
-        .WillOnce(Invoke([](absl::Span<const absl::string_view> data,
+        .WillOnce(Invoke([](absl::Span<quiche::QuicheMemSlice> data,
                             const quiche::StreamWriteOptions& options) {
-          quic::QuicDataReader reader(data[0]);
+          quic::QuicDataReader reader(data[0].AsStringView());
           uint64_t type;
           EXPECT_TRUE(reader.ReadVarInt62(&type));
           EXPECT_EQ(type, static_cast<uint64_t>(
@@ -2217,7 +2224,7 @@
           EXPECT_FALSE(options.send_fin());  // fin_after_this is ignored.
           return absl::OkStatus();
         }))
-        .WillOnce(Invoke([](absl::Span<const absl::string_view> data,
+        .WillOnce(Invoke([](absl::Span<quiche::QuicheMemSlice> data,
                             const quiche::StreamWriteOptions& options) {
           EXPECT_TRUE(data.empty());
           EXPECT_TRUE(options.send_fin());
@@ -2226,9 +2233,9 @@
     return;
   }
   EXPECT_CALL(data_stream, Writev)
-      .WillOnce(Invoke([](absl::Span<const absl::string_view> data,
+      .WillOnce(Invoke([](absl::Span<quiche::QuicheMemSlice> data,
                           const quiche::StreamWriteOptions& options) {
-        quic::QuicDataReader reader(data[0]);
+        quic::QuicDataReader reader(data[0].AsStringView());
         uint64_t type;
         EXPECT_TRUE(reader.ReadVarInt62(&type));
         EXPECT_EQ(type, static_cast<uint64_t>(
@@ -3460,10 +3467,10 @@
   EXPECT_CALL(mock_session_, GetStreamById(4)).WillOnce(Return(&mock_stream_));
   bool correct_message = false;
   EXPECT_CALL(mock_stream_, Writev(_, _))
-      .WillOnce([&](absl::Span<const absl::string_view> data,
+      .WillOnce([&](absl::Span<quiche::QuicheMemSlice> data,
                     const quiche::StreamWriteOptions& options) {
         correct_message = true;
-        EXPECT_EQ(*ExtractMessageType(data[0]),
+        EXPECT_EQ(*ExtractMessageType(data[0].AsStringView()),
                   MoqtMessageType::kSubscribeDone);
         return absl::OkStatus();
       });
diff --git a/quiche/quic/moqt/test_tools/moqt_framer_utils.h b/quiche/quic/moqt/test_tools/moqt_framer_utils.h
index 8e704f0..b008f2e 100644
--- a/quiche/quic/moqt/test_tools/moqt_framer_utils.h
+++ b/quiche/quic/moqt/test_tools/moqt_framer_utils.h
@@ -18,6 +18,7 @@
 #include "quiche/quic/moqt/moqt_messages.h"
 #include "quiche/common/platform/api/quiche_test.h"
 #include "quiche/common/quiche_data_reader.h"
+#include "quiche/common/quiche_mem_slice.h"
 #include "quiche/common/quiche_stream.h"
 
 namespace moqt::test {
@@ -45,13 +46,23 @@
 
 MATCHER_P(SerializedControlMessage, message,
           "Matches against a specific expected MoQT message") {
-  std::string merged_message = absl::StrJoin(arg, "");
+  std::vector<absl::string_view> data_written;
+  data_written.reserve(arg.size());
+  for (const quiche::QuicheMemSlice& slice : arg) {
+    data_written.push_back(slice.AsStringView());
+  }
+  std::string merged_message = absl::StrJoin(data_written, "");
   return merged_message == SerializeGenericMessage(message);
 }
 
 MATCHER_P(ControlMessageOfType, expected_type,
           "Matches against an MoQT message of a specific type") {
-  std::string merged_message = absl::StrJoin(arg, "");
+  std::vector<absl::string_view> data_written;
+  data_written.reserve(arg.size());
+  for (const quiche::QuicheMemSlice& slice : arg) {
+    data_written.push_back(slice.AsStringView());
+  }
+  std::string merged_message = absl::StrJoin(data_written, "");
   quiche::QuicheDataReader reader(merged_message);
   uint64_t type_raw;
   if (!reader.ReadVarInt62(&type_raw)) {
diff --git a/quiche/web_transport/encapsulated/encapsulated_web_transport.cc b/quiche/web_transport/encapsulated/encapsulated_web_transport.cc
index 7371945..5a00803 100644
--- a/quiche/web_transport/encapsulated/encapsulated_web_transport.cc
+++ b/quiche/web_transport/encapsulated/encapsulated_web_transport.cc
@@ -34,6 +34,7 @@
 #include "quiche/common/quiche_buffer_allocator.h"
 #include "quiche/common/quiche_callbacks.h"
 #include "quiche/common/quiche_circular_deque.h"
+#include "quiche/common/quiche_mem_slice.h"
 #include "quiche/common/quiche_status_utils.h"
 #include "quiche/common/quiche_stream.h"
 #include "quiche/common/vectorized_io_utils.h"
@@ -257,9 +258,10 @@
   // allows us to avoid a copy.
   quiche::QuicheBuffer buffer =
       quiche::SerializeDatagramCapsuleHeader(datagram.size(), allocator_);
-  std::array spans = {buffer.AsStringView(), datagram};
+  std::array spans = {quiche::QuicheMemSlice(std::move(buffer)),
+                      quiche::QuicheMemSlice::Copy(datagram)};
   absl::Status write_status =
-      writer_->Writev(absl::MakeConstSpan(spans), quiche::StreamWriteOptions());
+      writer_->Writev(absl::MakeSpan(spans), quiche::StreamWriteOptions());
   if (!write_status.ok()) {
     OnWriteError(write_status);
     return DatagramStatus{
@@ -611,8 +613,15 @@
 }
 
 absl::Status EncapsulatedSession::InnerStream::Writev(
-    const absl::Span<const absl::string_view> data,
+    const absl::Span<quiche::QuicheMemSlice> data,
     const quiche::StreamWriteOptions& options) {
+  // TODO: support zero copy.
+  std::vector<absl::string_view> views;
+  views.reserve(data.size());
+  for (const quiche::QuicheMemSlice& slice : data) {
+    views.push_back(slice.AsStringView());
+  }
+
   if (write_side_closed_) {
     return absl::FailedPreconditionError(
         "Trying to write into an already-closed stream");
@@ -636,7 +645,7 @@
                              !pending_write_.empty();
   if (write_blocked) {
     fin_buffered_ = options.send_fin();
-    for (absl::string_view chunk : data) {
+    for (absl::string_view chunk : views) {
       absl::StrAppend(&pending_write_, chunk);
     }
     absl::Status status = session_->scheduler_.Schedule(id_);
@@ -648,12 +657,12 @@
     return absl::OkStatus();
   }
 
-  size_t bytes_written = WriteInner(data, options.send_fin());
+  size_t bytes_written = WriteInner(views, options.send_fin());
   // TODO: handle partial writes when flow control requires those.
   QUICHE_DCHECK(bytes_written == 0 ||
-                bytes_written == quiche::TotalStringViewSpanSize(data));
+                bytes_written == quiche::TotalStringViewSpanSize(views));
   if (bytes_written == 0) {
-    for (absl::string_view chunk : data) {
+    for (absl::string_view chunk : views) {
       absl::StrAppend(&pending_write_, chunk);
     }
   }
@@ -700,12 +709,15 @@
   quiche::QuicheBuffer header =
       quiche::SerializeWebTransportStreamCapsuleHeader(id_, fin, total_size,
                                                        session_->allocator_);
-  std::vector<absl::string_view> views_to_write;
+  std::vector<quiche::QuicheMemSlice> views_to_write;
   views_to_write.reserve(data.size() + 1);
-  views_to_write.push_back(header.AsStringView());
-  absl::c_copy(data, std::back_inserter(views_to_write));
+  views_to_write.push_back(quiche::QuicheMemSlice(std::move(header)));
+  for (absl::string_view view : data) {
+    // TODO: support zero copy.
+    views_to_write.push_back(quiche::QuicheMemSlice::Copy(view));
+  }
   absl::Status write_status = session_->writer_->Writev(
-      views_to_write, quiche::kDefaultStreamWriteOptions);
+      absl::MakeSpan(views_to_write), quiche::kDefaultStreamWriteOptions);
   if (!write_status.ok()) {
     session_->OnWriteError(write_status);
     return 0;
diff --git a/quiche/web_transport/encapsulated/encapsulated_web_transport.h b/quiche/web_transport/encapsulated/encapsulated_web_transport.h
index e4e7f7a..44f489a 100644
--- a/quiche/web_transport/encapsulated/encapsulated_web_transport.h
+++ b/quiche/web_transport/encapsulated/encapsulated_web_transport.h
@@ -25,6 +25,7 @@
 #include "quiche/common/quiche_buffer_allocator.h"
 #include "quiche/common/quiche_callbacks.h"
 #include "quiche/common/quiche_circular_deque.h"
+#include "quiche/common/quiche_mem_slice.h"
 #include "quiche/common/quiche_stream.h"
 #include "quiche/common/simple_buffer_allocator.h"
 #include "quiche/web_transport/web_transport.h"
@@ -145,7 +146,7 @@
     bool SkipBytes(size_t bytes) override;
 
     // WriteStream implementation.
-    absl::Status Writev(absl::Span<const absl::string_view> data,
+    absl::Status Writev(absl::Span<quiche::QuicheMemSlice> data,
                         const quiche::StreamWriteOptions& options) override;
     bool CanWrite() const override;
 
diff --git a/quiche/web_transport/encapsulated/encapsulated_web_transport_test.cc b/quiche/web_transport/encapsulated/encapsulated_web_transport_test.cc
index 8c0c79f..6f27bc6 100644
--- a/quiche/web_transport/encapsulated/encapsulated_web_transport_test.cc
+++ b/quiche/web_transport/encapsulated/encapsulated_web_transport_test.cc
@@ -17,6 +17,7 @@
 #include "quiche/common/http/http_header_block.h"
 #include "quiche/common/platform/api/quiche_test.h"
 #include "quiche/common/quiche_buffer_allocator.h"
+#include "quiche/common/quiche_mem_slice.h"
 #include "quiche/common/quiche_stream.h"
 #include "quiche/common/simple_buffer_allocator.h"
 #include "quiche/common/test_tools/mock_streams.h"
@@ -46,10 +47,10 @@
           ADD_FAILURE() << "Fatal session error: " << error;
         });
     ON_CALL(writer_, Writev(_, _))
-        .WillByDefault([&](absl::Span<const absl::string_view> data,
+        .WillByDefault([&](absl::Span<quiche::QuicheMemSlice> data,
                            const quiche::StreamWriteOptions& options) {
-          for (absl::string_view fragment : data) {
-            parser_.IngestCapsuleFragment(fragment);
+          for (const quiche::QuicheMemSlice& fragment : data) {
+            parser_.IngestCapsuleFragment(fragment.AsStringView());
           }
           writer_.ProcessOptions(options);
           return absl::OkStatus();
@@ -553,7 +554,7 @@
 
   quiche::StreamWriteOptions options;
   options.set_send_fin(true);
-  EXPECT_THAT(stream->Writev(absl::Span<const absl::string_view>(), options),
+  EXPECT_THAT(stream->Writev(absl::Span<quiche::QuicheMemSlice>(), options),
               StatusIs(absl::StatusCode::kOk));
   session->GarbageCollectStreams();
   EXPECT_TRUE(deleted);
@@ -619,7 +620,7 @@
   options.set_send_fin(true);
   EXPECT_TRUE(stream->CanWrite());
   absl::Status status =
-      stream->Writev(absl::Span<const absl::string_view>(), options);
+      stream->Writev(absl::Span<quiche::QuicheMemSlice>(), options);
   EXPECT_THAT(status, StatusIs(absl::StatusCode::kOk));
   EXPECT_FALSE(stream->CanWrite());
 }
diff --git a/quiche/web_transport/test_tools/in_memory_stream.h b/quiche/web_transport/test_tools/in_memory_stream.h
index 48da99a..078ca94 100644
--- a/quiche/web_transport/test_tools/in_memory_stream.h
+++ b/quiche/web_transport/test_tools/in_memory_stream.h
@@ -15,6 +15,7 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
 #include "quiche/common/platform/api/quiche_logging.h"
+#include "quiche/common/quiche_mem_slice.h"
 #include "quiche/common/quiche_stream.h"
 #include "quiche/web_transport/web_transport.h"
 
@@ -34,7 +35,7 @@
   bool SkipBytes(size_t bytes) override;
 
   // quiche::WriteStream implementation.
-  absl::Status Writev(absl::Span<const absl::string_view> data,
+  absl::Status Writev(absl::Span<quiche::QuicheMemSlice> data,
                       const quiche::StreamWriteOptions& options) override {
     QUICHE_NOTREACHED() << "Writev called on a read-only stream";
     return absl::UnimplementedError("Writev called on a read-only stream");
diff --git a/quiche/web_transport/test_tools/mock_web_transport.h b/quiche/web_transport/test_tools/mock_web_transport.h
index 656c25c..77b1595 100644
--- a/quiche/web_transport/test_tools/mock_web_transport.h
+++ b/quiche/web_transport/test_tools/mock_web_transport.h
@@ -20,6 +20,7 @@
 #include "quiche/common/platform/api/quiche_export.h"
 #include "quiche/common/platform/api/quiche_test.h"
 #include "quiche/common/quiche_callbacks.h"
+#include "quiche/common/quiche_mem_slice.h"
 #include "quiche/common/quiche_stream.h"
 #include "quiche/web_transport/web_transport.h"
 
@@ -40,7 +41,7 @@
   MOCK_METHOD(ReadResult, Read, (absl::Span<char> buffer), (override));
   MOCK_METHOD(ReadResult, Read, (std::string * output), (override));
   MOCK_METHOD(absl::Status, Writev,
-              (absl::Span<const absl::string_view> data,
+              (absl::Span<quiche::QuicheMemSlice> data,
                const quiche::StreamWriteOptions& options),
               (override));
   MOCK_METHOD(PeekResult, PeekNextReadableRegion, (), (const, override));