diff --git a/common/quiche_buffer_allocator.cc b/common/quiche_buffer_allocator.cc
new file mode 100644
index 0000000..0801173
--- /dev/null
+++ b/common/quiche_buffer_allocator.cc
@@ -0,0 +1,76 @@
+// Copyright 2022 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_buffer_allocator.h"
+
+#include <cstring>
+
+#include "common/platform/api/quiche_bug_tracker.h"
+#include "common/platform/api/quiche_logging.h"
+#include "common/platform/api/quiche_prefetch.h"
+
+namespace quiche {
+
+QuicheBuffer QuicheBuffer::CopyFromIovec(QuicheBufferAllocator* allocator,
+                                         const struct iovec* iov, int iov_count,
+                                         size_t iov_offset,
+                                         size_t buffer_length) {
+  if (buffer_length == 0) {
+    return {};
+  }
+
+  int iovnum = 0;
+  while (iovnum < iov_count && iov_offset >= iov[iovnum].iov_len) {
+    iov_offset -= iov[iovnum].iov_len;
+    ++iovnum;
+  }
+  QUICHE_DCHECK_LE(iovnum, iov_count);
+  if (iovnum >= iov_count) {
+    QUICHE_BUG(quiche_bug_10839_1)
+        << "iov_offset larger than iovec total size.";
+    return {};
+  }
+  QUICHE_DCHECK_LE(iov_offset, iov[iovnum].iov_len);
+
+  // Unroll the first iteration that handles iov_offset.
+  const size_t iov_available = iov[iovnum].iov_len - iov_offset;
+  size_t copy_len = std::min(buffer_length, iov_available);
+
+  // Try to prefetch the next iov if there is at least one more after the
+  // current. Otherwise, it looks like an irregular access that the hardware
+  // prefetcher won't speculatively prefetch. Only prefetch one iov because
+  // generally, the iov_offset is not 0, input iov consists of 2K buffers and
+  // the output buffer is ~1.4K.
+  if (copy_len == iov_available && iovnum + 1 < iov_count) {
+    char* next_base = static_cast<char*>(iov[iovnum + 1].iov_base);
+    // Prefetch 2 cachelines worth of data to get the prefetcher started; leave
+    // it to the hardware prefetcher after that.
+    quiche::QuichePrefetchT0(next_base);
+    if (iov[iovnum + 1].iov_len >= 64) {
+      quiche::QuichePrefetchT0(next_base + ABSL_CACHELINE_SIZE);
+    }
+  }
+
+  QuicheBuffer buffer(allocator, buffer_length);
+
+  const char* src = static_cast<char*>(iov[iovnum].iov_base) + iov_offset;
+  char* dst = buffer.data();
+  while (true) {
+    memcpy(dst, src, copy_len);
+    buffer_length -= copy_len;
+    dst += copy_len;
+    if (buffer_length == 0 || ++iovnum >= iov_count) {
+      break;
+    }
+    src = static_cast<char*>(iov[iovnum].iov_base);
+    copy_len = std::min(buffer_length, iov[iovnum].iov_len);
+  }
+
+  QUICHE_BUG_IF(quiche_bug_10839_2, buffer_length > 0)
+      << "iov_offset + buffer_length larger than iovec total size.";
+
+  return buffer;
+}
+
+}  // namespace quiche
diff --git a/common/quiche_buffer_allocator.h b/common/quiche_buffer_allocator.h
index 40140ac..b0c233b 100644
--- a/common/quiche_buffer_allocator.h
+++ b/common/quiche_buffer_allocator.h
@@ -10,6 +10,7 @@
 #include <memory>
 
 #include "absl/strings/string_view.h"
+#include "quic/platform/api/quic_iovec.h"
 #include "common/platform/api/quiche_export.h"
 
 namespace quiche {
@@ -88,11 +89,19 @@
   // Factory method to create a QuicheBuffer that holds a copy of `data`.
   static QuicheBuffer Copy(QuicheBufferAllocator* allocator,
                            absl::string_view data) {
-    QuicheBuffer result(allocator, data.size());
-    memcpy(result.data(), data.data(), data.size());
-    return result;
+    QuicheBuffer buffer(allocator, data.size());
+    memcpy(buffer.data(), data.data(), data.size());
+    return buffer;
   }
 
+  // Factory method to create a QuicheBuffer of length `buffer_length` that
+  // holds a copy of `buffer_length` bytes from `iov` starting at offset
+  // `iov_offset`.  `iov` must be at least `iov_offset + buffer_length` total
+  // length.
+  static QuicheBuffer CopyFromIovec(QuicheBufferAllocator* allocator,
+                                    const struct iovec* iov, int iov_count,
+                                    size_t iov_offset, size_t buffer_length);
+
   const char* data() const { return buffer_.get(); }
   char* data() { return buffer_.get(); }
   size_t size() const { return size_; }
diff --git a/common/quiche_buffer_allocator_test.cc b/common/quiche_buffer_allocator_test.cc
new file mode 100644
index 0000000..7d08cf1
--- /dev/null
+++ b/common/quiche_buffer_allocator_test.cc
@@ -0,0 +1,141 @@
+// Copyright 2022 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_buffer_allocator.h"
+
+#include "absl/strings/string_view.h"
+#include "common/platform/api/quiche_test.h"
+#include "common/platform/api/quiche_test_helpers.h"
+#include "common/simple_buffer_allocator.h"
+#include "common/test_tools/quiche_test_utils.h"
+
+namespace quiche {
+namespace test {
+namespace {
+
+TEST(QuicheBuffer, CopyFromEmpty) {
+  SimpleBufferAllocator allocator;
+  QuicheBuffer buffer = QuicheBuffer::Copy(&allocator, "");
+  EXPECT_TRUE(buffer.empty());
+}
+
+TEST(QuicheBuffer, Copy) {
+  SimpleBufferAllocator allocator;
+  QuicheBuffer buffer = QuicheBuffer::Copy(&allocator, "foobar");
+  EXPECT_EQ("foobar", buffer.AsStringView());
+}
+
+TEST(QuicheBuffer, CopyFromIovecZeroBytes) {
+  const int buffer_length = 0;
+
+  SimpleBufferAllocator allocator;
+  QuicheBuffer buffer = QuicheBuffer::CopyFromIovec(
+      &allocator, nullptr,
+      /* iov_count = */ 0, /* iov_offset = */ 0, buffer_length);
+  EXPECT_TRUE(buffer.empty());
+
+  constexpr absl::string_view kData("foobar");
+  iovec iov = MakeIOVector(kData);
+
+  buffer = QuicheBuffer::CopyFromIovec(&allocator, &iov,
+                                       /* iov_count = */ 1,
+                                       /* iov_offset = */ 0, buffer_length);
+  EXPECT_TRUE(buffer.empty());
+
+  buffer = QuicheBuffer::CopyFromIovec(&allocator, &iov,
+                                       /* iov_count = */ 1,
+                                       /* iov_offset = */ 3, buffer_length);
+  EXPECT_TRUE(buffer.empty());
+}
+
+TEST(QuicheBuffer, CopyFromIovecSimple) {
+  constexpr absl::string_view kData("foobar");
+  iovec iov = MakeIOVector(kData);
+
+  SimpleBufferAllocator allocator;
+  QuicheBuffer buffer =
+      QuicheBuffer::CopyFromIovec(&allocator, &iov,
+                                  /* iov_count = */ 1, /* iov_offset = */ 0,
+                                  /* buffer_length = */ 6);
+  EXPECT_EQ("foobar", buffer.AsStringView());
+
+  buffer =
+      QuicheBuffer::CopyFromIovec(&allocator, &iov,
+                                  /* iov_count = */ 1, /* iov_offset = */ 0,
+                                  /* buffer_length = */ 3);
+  EXPECT_EQ("foo", buffer.AsStringView());
+
+  buffer =
+      QuicheBuffer::CopyFromIovec(&allocator, &iov,
+                                  /* iov_count = */ 1, /* iov_offset = */ 3,
+                                  /* buffer_length = */ 3);
+  EXPECT_EQ("bar", buffer.AsStringView());
+
+  buffer =
+      QuicheBuffer::CopyFromIovec(&allocator, &iov,
+                                  /* iov_count = */ 1, /* iov_offset = */ 1,
+                                  /* buffer_length = */ 4);
+  EXPECT_EQ("ooba", buffer.AsStringView());
+}
+
+TEST(QuicheBuffer, CopyFromIovecMultiple) {
+  constexpr absl::string_view kData1("foo");
+  constexpr absl::string_view kData2("bar");
+  iovec iov[] = {MakeIOVector(kData1), MakeIOVector(kData2)};
+
+  SimpleBufferAllocator allocator;
+  QuicheBuffer buffer =
+      QuicheBuffer::CopyFromIovec(&allocator, &iov[0],
+                                  /* iov_count = */ 2, /* iov_offset = */ 0,
+                                  /* buffer_length = */ 6);
+  EXPECT_EQ("foobar", buffer.AsStringView());
+
+  buffer =
+      QuicheBuffer::CopyFromIovec(&allocator, &iov[0],
+                                  /* iov_count = */ 2, /* iov_offset = */ 0,
+                                  /* buffer_length = */ 3);
+  EXPECT_EQ("foo", buffer.AsStringView());
+
+  buffer =
+      QuicheBuffer::CopyFromIovec(&allocator, &iov[0],
+                                  /* iov_count = */ 2, /* iov_offset = */ 3,
+                                  /* buffer_length = */ 3);
+  EXPECT_EQ("bar", buffer.AsStringView());
+
+  buffer =
+      QuicheBuffer::CopyFromIovec(&allocator, &iov[0],
+                                  /* iov_count = */ 2, /* iov_offset = */ 1,
+                                  /* buffer_length = */ 4);
+  EXPECT_EQ("ooba", buffer.AsStringView());
+}
+
+TEST(QuicheBuffer, CopyFromIovecOffsetTooLarge) {
+  constexpr absl::string_view kData1("foo");
+  constexpr absl::string_view kData2("bar");
+  iovec iov[] = {MakeIOVector(kData1), MakeIOVector(kData2)};
+
+  SimpleBufferAllocator allocator;
+  EXPECT_QUICHE_BUG(
+      QuicheBuffer::CopyFromIovec(&allocator, &iov[0],
+                                  /* iov_count = */ 2, /* iov_offset = */ 10,
+                                  /* buffer_length = */ 6),
+      "iov_offset larger than iovec total size");
+}
+
+TEST(QuicheBuffer, CopyFromIovecTooManyBytesRequested) {
+  constexpr absl::string_view kData1("foo");
+  constexpr absl::string_view kData2("bar");
+  iovec iov[] = {MakeIOVector(kData1), MakeIOVector(kData2)};
+
+  SimpleBufferAllocator allocator;
+  EXPECT_QUICHE_BUG(
+      QuicheBuffer::CopyFromIovec(&allocator, &iov[0],
+                                  /* iov_count = */ 2, /* iov_offset = */ 2,
+                                  /* buffer_length = */ 10),
+      "iov_offset [+] buffer_length larger than iovec total size");
+}
+
+}  // anonymous namespace
+}  // namespace test
+}  // namespace quiche
diff --git a/common/quiche_mem_slice_storage.cc b/common/quiche_mem_slice_storage.cc
index 2b1b5e1..d57cf76 100644
--- a/common/quiche_mem_slice_storage.cc
+++ b/common/quiche_mem_slice_storage.cc
@@ -23,9 +23,8 @@
   size_t io_offset = 0;
   while (write_len > 0) {
     size_t slice_len = std::min(write_len, max_slice_len);
-    QuicheBuffer buffer(allocator, slice_len);
-    quic::QuicUtils::CopyToBuffer(iov, iov_count, io_offset, slice_len,
-                                  buffer.data());
+    QuicheBuffer buffer = QuicheBuffer::CopyFromIovec(allocator, iov, iov_count,
+                                                      io_offset, slice_len);
     storage_.push_back(QuicheMemSlice(std::move(buffer)));
     write_len -= slice_len;
     io_offset += slice_len;
diff --git a/common/test_tools/quiche_test_utils.cc b/common/test_tools/quiche_test_utils.cc
index 9a3bb21..5ebe527 100644
--- a/common/test_tools/quiche_test_utils.cc
+++ b/common/test_tools/quiche_test_utils.cc
@@ -87,5 +87,9 @@
                 << HexDumpWithMarks(actual, actual_len, marks.get(), max_len);
 }
 
+iovec MakeIOVector(absl::string_view str) {
+  return iovec{const_cast<char*>(str.data()), static_cast<size_t>(str.size())};
+}
+
 }  // namespace test
 }  // namespace quiche
diff --git a/common/test_tools/quiche_test_utils.h b/common/test_tools/quiche_test_utils.h
index 45a526b..becfea0 100644
--- a/common/test_tools/quiche_test_utils.h
+++ b/common/test_tools/quiche_test_utils.h
@@ -7,6 +7,9 @@
 
 #include <string>
 
+#include "absl/strings/string_view.h"
+#include "quic/platform/api/quic_iovec.h"
+
 namespace quiche {
 namespace test {
 
@@ -16,6 +19,9 @@
                                    const char* expected,
                                    const int expected_len);
 
+// Create iovec that points to that data that `str` points to.
+iovec MakeIOVector(absl::string_view str);
+
 }  // namespace test
 }  // namespace quiche
 
diff --git a/quic/core/quic_stream_send_buffer.h b/quic/core/quic_stream_send_buffer.h
index cf3fa13..e972ac0 100644
--- a/quic/core/quic_stream_send_buffer.h
+++ b/quic/core/quic_stream_send_buffer.h
@@ -10,7 +10,6 @@
 #include "quic/core/quic_interval_deque.h"
 #include "quic/core/quic_interval_set.h"
 #include "quic/core/quic_types.h"
-#include "quic/platform/api/quic_iovec.h"
 #include "common/platform/api/quiche_mem_slice.h"
 #include "common/quiche_circular_deque.h"
 
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc
index aa8f59e..94d35eb 100644
--- a/quic/core/quic_utils.cc
+++ b/quic/core/quic_utils.cc
@@ -24,7 +24,6 @@
 #include "quic/platform/api/quic_flags.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"
 
 namespace quic {
@@ -239,57 +238,6 @@
 }
 
 // static
-void QuicUtils::CopyToBuffer(const struct iovec* iov,
-                             int iov_count,
-                             size_t iov_offset,
-                             size_t buffer_length,
-                             char* buffer) {
-  int iovnum = 0;
-  while (iovnum < iov_count && iov_offset >= iov[iovnum].iov_len) {
-    iov_offset -= iov[iovnum].iov_len;
-    ++iovnum;
-  }
-  QUICHE_DCHECK_LE(iovnum, iov_count);
-  QUICHE_DCHECK_LE(iov_offset, iov[iovnum].iov_len);
-  if (iovnum >= iov_count || buffer_length == 0) {
-    return;
-  }
-
-  // Unroll the first iteration that handles iov_offset.
-  const size_t iov_available = iov[iovnum].iov_len - iov_offset;
-  size_t copy_len = std::min(buffer_length, iov_available);
-
-  // Try to prefetch the next iov if there is at least one more after the
-  // current. Otherwise, it looks like an irregular access that the hardware
-  // prefetcher won't speculatively prefetch. Only prefetch one iov because
-  // generally, the iov_offset is not 0, input iov consists of 2K buffers and
-  // the output buffer is ~1.4K.
-  if (copy_len == iov_available && iovnum + 1 < iov_count) {
-    char* next_base = static_cast<char*>(iov[iovnum + 1].iov_base);
-    // Prefetch 2 cachelines worth of data to get the prefetcher started; leave
-    // it to the hardware prefetcher after that.
-    quiche::QuichePrefetchT0(next_base);
-    if (iov[iovnum + 1].iov_len >= 64) {
-      quiche::QuichePrefetchT0(next_base + ABSL_CACHELINE_SIZE);
-    }
-  }
-
-  const char* src = static_cast<char*>(iov[iovnum].iov_base) + iov_offset;
-  while (true) {
-    memcpy(buffer, src, copy_len);
-    buffer_length -= copy_len;
-    buffer += copy_len;
-    if (buffer_length == 0 || ++iovnum >= iov_count) {
-      break;
-    }
-    src = static_cast<char*>(iov[iovnum].iov_base);
-    copy_len = std::min(buffer_length, iov[iovnum].iov_len);
-  }
-  QUIC_BUG_IF(quic_bug_10839_1, buffer_length > 0)
-      << "Failed to copy entire length to buffer.";
-}
-
-// static
 bool QuicUtils::IsAckable(SentPacketState state) {
   return state != NEVER_SENT && state != ACKED && state != UNACKABLE;
 }
diff --git a/quic/core/quic_utils.h b/quic/core/quic_utils.h
index 085f532..ea03236 100644
--- a/quic/core/quic_utils.h
+++ b/quic/core/quic_utils.h
@@ -21,7 +21,6 @@
 #include "quic/core/quic_types.h"
 #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_socket_address.h"
 #include "common/platform/api/quiche_mem_slice.h"
 
@@ -72,15 +71,6 @@
       const QuicSocketAddress& old_address,
       const QuicSocketAddress& new_address);
 
-  // Copies |buffer_length| bytes from iov starting at offset |iov_offset| into
-  // buffer. |iov| must be at least iov_offset+length total length and buffer
-  // must be at least |length| long.
-  static void CopyToBuffer(const struct iovec* iov,
-                           int iov_count,
-                           size_t iov_offset,
-                           size_t buffer_length,
-                           char* buffer);
-
   // Returns the opposite Perspective of the |perspective| passed in.
   static constexpr Perspective InvertPerspective(Perspective perspective) {
     return perspective == Perspective::IS_CLIENT ? Perspective::IS_SERVER
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 869e416..d9bc541 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -1510,12 +1510,6 @@
   return l;
 }
 
-// Utility function that stores |str|'s data in |iov|.
-inline void MakeIOVector(absl::string_view str, struct iovec* iov) {
-  iov->iov_base = const_cast<char*>(str.data());
-  iov->iov_len = static_cast<size_t>(str.size());
-}
-
 // Helper functions for stream ids, to allow test logic to abstract over the
 // HTTP stream numbering scheme (i.e. whether one or two QUIC streams are used
 // per HTTP transaction).