diff --git a/build/source_list.bzl b/build/source_list.bzl
index fac6ffe..5a8ee78 100644
--- a/build/source_list.bzl
+++ b/build/source_list.bzl
@@ -364,6 +364,7 @@
     "quic/core/quic_stream_priority.h",
     "quic/core/quic_stream_send_buffer.h",
     "quic/core/quic_stream_send_buffer_base.h",
+    "quic/core/quic_stream_send_buffer_inlining.h",
     "quic/core/quic_stream_sequencer.h",
     "quic/core/quic_stream_sequencer_buffer.h",
     "quic/core/quic_sustained_bandwidth_recorder.h",
@@ -687,6 +688,7 @@
     "quic/core/quic_stream_priority.cc",
     "quic/core/quic_stream_send_buffer.cc",
     "quic/core/quic_stream_send_buffer_base.cc",
+    "quic/core/quic_stream_send_buffer_inlining.cc",
     "quic/core/quic_stream_sequencer.cc",
     "quic/core/quic_stream_sequencer_buffer.cc",
     "quic/core/quic_sustained_bandwidth_recorder.cc",
diff --git a/build/source_list.gni b/build/source_list.gni
index 93a4c55..89c4626 100644
--- a/build/source_list.gni
+++ b/build/source_list.gni
@@ -364,6 +364,7 @@
     "src/quiche/quic/core/quic_stream_priority.h",
     "src/quiche/quic/core/quic_stream_send_buffer.h",
     "src/quiche/quic/core/quic_stream_send_buffer_base.h",
+    "src/quiche/quic/core/quic_stream_send_buffer_inlining.h",
     "src/quiche/quic/core/quic_stream_sequencer.h",
     "src/quiche/quic/core/quic_stream_sequencer_buffer.h",
     "src/quiche/quic/core/quic_sustained_bandwidth_recorder.h",
@@ -687,6 +688,7 @@
     "src/quiche/quic/core/quic_stream_priority.cc",
     "src/quiche/quic/core/quic_stream_send_buffer.cc",
     "src/quiche/quic/core/quic_stream_send_buffer_base.cc",
+    "src/quiche/quic/core/quic_stream_send_buffer_inlining.cc",
     "src/quiche/quic/core/quic_stream_sequencer.cc",
     "src/quiche/quic/core/quic_stream_sequencer_buffer.cc",
     "src/quiche/quic/core/quic_sustained_bandwidth_recorder.cc",
diff --git a/build/source_list.json b/build/source_list.json
index 1cabec8..3a262e2 100644
--- a/build/source_list.json
+++ b/build/source_list.json
@@ -363,6 +363,7 @@
     "quiche/quic/core/quic_stream_priority.h",
     "quiche/quic/core/quic_stream_send_buffer.h",
     "quiche/quic/core/quic_stream_send_buffer_base.h",
+    "quiche/quic/core/quic_stream_send_buffer_inlining.h",
     "quiche/quic/core/quic_stream_sequencer.h",
     "quiche/quic/core/quic_stream_sequencer_buffer.h",
     "quiche/quic/core/quic_sustained_bandwidth_recorder.h",
@@ -686,6 +687,7 @@
     "quiche/quic/core/quic_stream_priority.cc",
     "quiche/quic/core/quic_stream_send_buffer.cc",
     "quiche/quic/core/quic_stream_send_buffer_base.cc",
+    "quiche/quic/core/quic_stream_send_buffer_inlining.cc",
     "quiche/quic/core/quic_stream_sequencer.cc",
     "quiche/quic/core/quic_stream_sequencer_buffer.cc",
     "quiche/quic/core/quic_sustained_bandwidth_recorder.cc",
diff --git a/quiche/common/quiche_feature_flags_list.h b/quiche/common/quiche_feature_flags_list.h
index 6bb4791..09e6b2a 100755
--- a/quiche/common/quiche_feature_flags_list.h
+++ b/quiche/common/quiche_feature_flags_list.h
@@ -57,6 +57,7 @@
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_test_peer_addr_change_after_normalize, false, false, "If true, QuicConnection::ProcessValidatedPacket will use normalized address to test peer address changes.")
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_testonly_default_false, false, false, "A testonly reloadable flag that will always default to false.")
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_testonly_default_true, true, true, "A testonly reloadable flag that will always default to true.")
+QUICHE_FLAG(bool, quiche_reloadable_flag_quic_use_inlining_send_buffer2, false, false, "Uses an inlining version of QuicSendStreamBuffer.")
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_use_received_client_addresses_cache, true, true, "If true, use a LRU cache to record client addresses of packets received on server's original address.")
 QUICHE_FLAG(bool, quiche_restart_flag_quic_support_release_time_for_gso, false, false, "If true, QuicGsoBatchWriter will support release time if it is available and the process has the permission to do so.")
 QUICHE_FLAG(bool, quiche_restart_flag_quic_testonly_default_false, false, false, "A testonly restart flag that will always default to false.")
diff --git a/quiche/quic/core/http/quic_spdy_stream.cc b/quiche/quic/core/http/quic_spdy_stream.cc
index 70a6b2e..bc00e87 100644
--- a/quiche/quic/core/http/quic_spdy_stream.cc
+++ b/quiche/quic/core/http/quic_spdy_stream.cc
@@ -430,6 +430,8 @@
       send_buffer().stream_offset() + header.size());
   QUIC_DVLOG(1) << ENDPOINT << "Stream " << id()
                 << " is writing DATA frame header of length " << header.size();
+  // TODO: b/417402601 - once we always use inlining send buffer, the code below
+  // should always use WriteOrBufferData.
   if (can_write) {
     // Save one copy and allocation if send buffer can accomodate the header.
     quiche::QuicheMemSlice header_slice(std::move(header));
diff --git a/quiche/quic/core/quic_stream.cc b/quiche/quic/core/quic_stream.cc
index 2d28091..63e4253 100644
--- a/quiche/quic/core/quic_stream.cc
+++ b/quiche/quic/core/quic_stream.cc
@@ -5,17 +5,35 @@
 #include "quiche/quic/core/quic_stream.h"
 
 #include <algorithm>
+#include <cstdint>
 #include <limits>
+#include <memory>
 #include <optional>
 #include <string>
 #include <utility>
 
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "quiche/http2/core/spdy_protocol.h"
+#include "quiche/quic/core/frames/quic_connection_close_frame.h"
 #include "quiche/quic/core/frames/quic_reset_stream_at_frame.h"
+#include "quiche/quic/core/frames/quic_rst_stream_frame.h"
+#include "quiche/quic/core/frames/quic_stream_frame.h"
+#include "quiche/quic/core/frames/quic_window_update_frame.h"
+#include "quiche/quic/core/quic_ack_listener_interface.h"
+#include "quiche/quic/core/quic_constants.h"
+#include "quiche/quic/core/quic_data_writer.h"
 #include "quiche/quic/core/quic_error_codes.h"
 #include "quiche/quic/core/quic_flow_controller.h"
+#include "quiche/quic/core/quic_interval_set.h"
 #include "quiche/quic/core/quic_session.h"
+#include "quiche/quic/core/quic_stream_priority.h"
+#include "quiche/quic/core/quic_stream_send_buffer.h"
+#include "quiche/quic/core/quic_stream_send_buffer_base.h"
+#include "quiche/quic/core/quic_stream_send_buffer_inlining.h"
+#include "quiche/quic/core/quic_stream_sequencer.h"
+#include "quiche/quic/core/quic_time.h"
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/core/quic_utils.h"
 #include "quiche/quic/core/quic_versions.h"
@@ -24,6 +42,8 @@
 #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/platform/api/quiche_reference_counted.h"
+#include "quiche/common/quiche_buffer_allocator.h"
 #include "quiche/common/quiche_mem_slice.h"
 
 using spdy::SpdyPriority;
@@ -109,6 +129,17 @@
   return DefaultFlowControlWindow(version);
 }
 
+std::unique_ptr<QuicStreamSendBufferBase> CreateSendBuffer(
+    QuicSession* session) {
+  quiche::QuicheBufferAllocator* allocator =
+      session->connection()->helper()->GetStreamSendBufferAllocator();
+  if (GetQuicReloadableFlag(quic_use_inlining_send_buffer2)) {
+    QUIC_RELOADABLE_FLAG_COUNT(quic_use_inlining_send_buffer2);
+    return std::make_unique<QuicStreamSendBufferInlining>(allocator);
+  }
+  return std::make_unique<QuicStreamSendBuffer>(allocator);
+}
+
 }  // namespace
 
 PendingStream::PendingStream(QuicStreamId id, QuicSession* session)
@@ -387,8 +418,7 @@
       stream_contributes_to_connection_flow_control_(true),
       busy_counter_(0),
       add_random_padding_after_fin_(false),
-      send_buffer_(std::make_unique<QuicStreamSendBuffer>(
-          session->connection()->helper()->GetStreamSendBufferAllocator())),
+      send_buffer_(CreateSendBuffer(session)),
       buffered_data_threshold_(GetQuicFlag(quic_buffered_data_threshold)),
       is_static_(is_static),
       deadline_(QuicTime::Zero()),
diff --git a/quiche/quic/core/quic_stream_send_buffer.cc b/quiche/quic/core/quic_stream_send_buffer.cc
index f2b9f51..ad78782 100644
--- a/quiche/quic/core/quic_stream_send_buffer.cc
+++ b/quiche/quic/core/quic_stream_send_buffer.cc
@@ -184,4 +184,13 @@
   return last_slice;
 }
 
+QuicByteCount QuicStreamSendBuffer::TotalDataBufferedForTest() {
+  QuicByteCount length = 0;
+  for (auto slice = interval_deque_.DataBegin();
+       slice != interval_deque_.DataEnd(); ++slice) {
+    length += slice->slice.length();
+  }
+  return length;
+}
+
 }  // namespace quic
diff --git a/quiche/quic/core/quic_stream_send_buffer.h b/quiche/quic/core/quic_stream_send_buffer.h
index fa88e6d..d9b25c3 100644
--- a/quiche/quic/core/quic_stream_send_buffer.h
+++ b/quiche/quic/core/quic_stream_send_buffer.h
@@ -83,6 +83,7 @@
 
   void SetStreamOffsetForTest(QuicStreamOffset new_offset) override;
   absl::string_view LatestWriteForTest() override;
+  QuicByteCount TotalDataBufferedForTest() override;
 
  private:
   friend class test::QuicStreamSendBufferPeer;
diff --git a/quiche/quic/core/quic_stream_send_buffer_base.h b/quiche/quic/core/quic_stream_send_buffer_base.h
index b2d32ff..9a14b34 100644
--- a/quiche/quic/core/quic_stream_send_buffer_base.h
+++ b/quiche/quic/core/quic_stream_send_buffer_base.h
@@ -114,6 +114,7 @@
 
   virtual void SetStreamOffsetForTest(QuicStreamOffset new_offset);
   virtual absl::string_view LatestWriteForTest() = 0;
+  virtual QuicByteCount TotalDataBufferedForTest() = 0;
 
  private:
   friend class test::QuicStreamSendBufferPeer;
diff --git a/quiche/quic/core/quic_stream_send_buffer_inlining.cc b/quiche/quic/core/quic_stream_send_buffer_inlining.cc
new file mode 100644
index 0000000..bd4924e
--- /dev/null
+++ b/quiche/quic/core/quic_stream_send_buffer_inlining.cc
@@ -0,0 +1,232 @@
+// Copyright (c) 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 "quiche/quic/core/quic_stream_send_buffer_inlining.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <utility>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "quiche/quic/core/quic_data_writer.h"
+#include "quiche/quic/core/quic_interval.h"
+#include "quiche/quic/core/quic_interval_set.h"
+#include "quiche/quic/core/quic_stream_send_buffer_base.h"
+#include "quiche/quic/core/quic_types.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"
+
+namespace quic {
+
+namespace {
+
+struct CompareOffset {
+  bool operator()(const BufferedSliceInlining& slice,
+                  QuicStreamOffset offset) const {
+    return slice.offset + slice.slice.size() < offset;
+  }
+};
+
+constexpr bool WillInline(absl::string_view data) {
+  return data.size() <= kSendBufferMaxInlinedSize;
+}
+
+}  // namespace
+
+BufferedSliceInlining::BufferedSliceInlining(absl::string_view slice,
+                                             QuicStreamOffset offset)
+    : slice(slice), offset(offset) {}
+
+BufferedSliceInlining::BufferedSliceInlining(BufferedSliceInlining&& other) =
+    default;
+
+BufferedSliceInlining& BufferedSliceInlining::operator=(
+    BufferedSliceInlining&& other) = default;
+
+BufferedSliceInlining::~BufferedSliceInlining() {}
+
+QuicInterval<std::size_t> BufferedSliceInlining::interval() const {
+  const std::size_t length = slice.size();
+  return QuicInterval<std::size_t>(offset, offset + length);
+}
+
+QuicStreamSendBufferInlining::QuicStreamSendBufferInlining(
+    quiche::QuicheBufferAllocator* allocator)
+    : allocator_(allocator) {}
+
+void QuicStreamSendBufferInlining::SaveStreamData(absl::string_view data) {
+  QUIC_DVLOG(2) << "Save stream data offset " << stream_offset_ << " length "
+                << data.length();
+  QUICHE_DCHECK(!data.empty());
+
+  if (WillInline(data)) {
+    // Skip memory allocation for inlined writes.
+    SaveMemSlice(quiche::QuicheMemSlice(
+        data.data(), data.size(), +[](absl::string_view) {}));
+    return;
+  }
+
+  // Latch the maximum data slice size.
+  const QuicByteCount max_data_slice_size =
+      GetQuicFlag(quic_send_buffer_max_data_slice_size);
+  while (!data.empty()) {
+    auto slice_len = std::min<absl::string_view::size_type>(
+        data.length(), max_data_slice_size);
+    auto buffer =
+        quiche::QuicheBuffer::Copy(allocator_, data.substr(0, slice_len));
+    SaveMemSlice(quiche::QuicheMemSlice(std::move(buffer)));
+
+    data = data.substr(slice_len);
+  }
+}
+
+void QuicStreamSendBufferInlining::SaveMemSlice(quiche::QuicheMemSlice slice) {
+  QUIC_DVLOG(2) << "Save slice offset " << stream_offset_ << " length "
+                << slice.length();
+  if (slice.empty()) {
+    QUIC_BUG(quic_bug_10853_1) << "Try to save empty MemSlice to send buffer.";
+    return;
+  }
+  const absl::string_view data = slice.AsStringView();
+  const bool is_inlined = WillInline(data);
+  interval_deque_.PushBack(BufferedSliceInlining(data, stream_offset_));
+  QUICHE_DCHECK_EQ(interval_deque_.DataAt(stream_offset_)->slice.IsInlined(),
+                   is_inlined);
+  if (!is_inlined) {
+    auto [it, success] =
+        owned_slices_.emplace(stream_offset_, std::move(slice));
+    QUICHE_DCHECK(success);
+  }
+  stream_offset_ += data.size();
+}
+
+QuicByteCount QuicStreamSendBufferInlining::SaveMemSliceSpan(
+    absl::Span<quiche::QuicheMemSlice> span) {
+  QuicByteCount total = 0;
+  for (quiche::QuicheMemSlice& slice : span) {
+    if (slice.empty()) {
+      // Skip empty slices.
+      continue;
+    }
+    total += slice.length();
+    SaveMemSlice(std::move(slice));
+  }
+  return total;
+}
+
+bool QuicStreamSendBufferInlining::WriteStreamData(QuicStreamOffset offset,
+                                                   QuicByteCount data_length,
+                                                   QuicDataWriter* writer) {
+  // The iterator returned from |interval_deque_| will automatically advance
+  // the internal write index for the QuicIntervalDeque. The incrementing is
+  // done in operator++.
+  for (auto slice_it = interval_deque_.DataAt(offset);
+       slice_it != interval_deque_.DataEnd(); ++slice_it) {
+    if (data_length == 0 || offset < slice_it->offset) {
+      break;
+    }
+
+    QuicByteCount slice_offset = offset - slice_it->offset;
+    QuicByteCount available_bytes_in_slice =
+        slice_it->slice.size() - slice_offset;
+    QuicByteCount copy_length = std::min(data_length, available_bytes_in_slice);
+    if (!writer->WriteBytes(slice_it->slice.data() + slice_offset,
+                            copy_length)) {
+      QUIC_BUG(quic_bug_10853_2) << "Writer fails to write.";
+      return false;
+    }
+    offset += copy_length;
+    data_length -= copy_length;
+  }
+  return data_length == 0;
+}
+
+bool QuicStreamSendBufferInlining::FreeMemSlices(QuicStreamOffset start,
+                                                 QuicStreamOffset end) {
+  auto it = interval_deque_.DataBegin();
+  if (it == interval_deque_.DataEnd() || it->slice.empty()) {
+    QUIC_BUG(quic_bug_10853_4)
+        << "Trying to ack stream data [" << start << ", " << end << "), "
+        << (it == interval_deque_.DataEnd()
+                ? "and there is no outstanding data."
+                : "and the first slice is empty.");
+    return false;
+  }
+  if (!it->interval().Contains(start)) {
+    // Slow path that not the earliest outstanding data gets acked.
+    it = std::lower_bound(interval_deque_.DataBegin(),
+                          interval_deque_.DataEnd(), start, CompareOffset());
+  }
+  if (it == interval_deque_.DataEnd() || it->slice.empty()) {
+    QUIC_BUG(quic_bug_10853_5)
+        << "Offset " << start << " with iterator offset: " << it->offset
+        << (it == interval_deque_.DataEnd() ? " does not exist."
+                                            : " has already been acked.");
+    return false;
+  }
+  for (; it != interval_deque_.DataEnd(); ++it) {
+    if (it->offset >= end) {
+      break;
+    }
+    if (!it->slice.empty() &&
+        bytes_acked().Contains(it->offset, it->offset + it->slice.size())) {
+      ClearSlice(*it);
+    }
+  }
+  return true;
+}
+
+void QuicStreamSendBufferInlining::CleanUpBufferedSlices() {
+  while (!interval_deque_.Empty() &&
+         interval_deque_.DataBegin()->slice.empty()) {
+    interval_deque_.PopFront();
+  }
+}
+
+size_t QuicStreamSendBufferInlining::size() const {
+  return interval_deque_.Size();
+}
+
+void QuicStreamSendBufferInlining::SetStreamOffsetForTest(
+    QuicStreamOffset new_offset) {
+  QuicStreamSendBufferBase::SetStreamOffsetForTest(new_offset);
+  stream_offset_ = new_offset;
+}
+
+absl::string_view QuicStreamSendBufferInlining::LatestWriteForTest() {
+  absl::string_view last_slice = "";
+  for (auto it = interval_deque_.DataBegin(); it != interval_deque_.DataEnd();
+       ++it) {
+    last_slice = it->slice.view();
+  }
+  return last_slice;
+}
+
+void QuicStreamSendBufferInlining::ClearSlice(BufferedSliceInlining& slice) {
+  if (slice.slice.empty()) {
+    return;
+  }
+  const bool was_inlined = slice.slice.IsInlined();
+  slice.slice.clear();
+  if (!was_inlined) {
+    bool deleted = owned_slices_.erase(slice.offset);
+    QUICHE_DCHECK(deleted);
+  }
+}
+
+QuicByteCount QuicStreamSendBufferInlining::TotalDataBufferedForTest() {
+  QuicByteCount length = 0;
+  for (auto slice = interval_deque_.DataBegin();
+       slice != interval_deque_.DataEnd(); ++slice) {
+    length += slice->slice.size();
+  }
+  return length;
+}
+
+}  // namespace quic
diff --git a/quiche/quic/core/quic_stream_send_buffer_inlining.h b/quiche/quic/core/quic_stream_send_buffer_inlining.h
new file mode 100644
index 0000000..6cb0f95
--- /dev/null
+++ b/quiche/quic/core/quic_stream_send_buffer_inlining.h
@@ -0,0 +1,126 @@
+// Copyright (c) 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_CORE_QUIC_STREAM_SEND_BUFFER_INLINING_H_
+#define QUICHE_QUIC_CORE_QUIC_STREAM_SEND_BUFFER_INLINING_H_
+
+#include <cstddef>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "quiche/quic/core/quic_inlined_string_view.h"
+#include "quiche/quic/core/quic_interval.h"
+#include "quiche/quic/core/quic_interval_deque.h"
+#include "quiche/quic/core/quic_stream_send_buffer_base.h"
+#include "quiche/quic/core/quic_types.h"
+#include "quiche/common/platform/api/quiche_export.h"
+#include "quiche/common/quiche_buffer_allocator.h"
+#include "quiche/common/quiche_mem_slice.h"
+
+namespace quic {
+
+namespace test {
+class QuicStreamSendBufferPeer;
+}
+
+class QuicDataWriter;
+
+constexpr size_t kSendBufferMaxInlinedSize = 15;
+
+// BufferedSliceInlining is an entry in the send buffer.  It contains a pointer
+// to the buffered data (or data itself, if it is inlined), the size of the data
+// and the offset in the buffer.
+//
+// BufferedSliceInlining does not own contents of the slice; those are freed
+// separately. Since we perform a search over an array of BufferedSliceInlining,
+// it is important for this data structure to be compact.
+struct QUICHE_EXPORT BufferedSliceInlining {
+  BufferedSliceInlining(absl::string_view slice, QuicStreamOffset offset);
+  BufferedSliceInlining(BufferedSliceInlining&& other);
+  BufferedSliceInlining& operator=(BufferedSliceInlining&& other);
+
+  BufferedSliceInlining(const BufferedSliceInlining& other) = delete;
+  BufferedSliceInlining& operator=(const BufferedSliceInlining& other) = delete;
+  ~BufferedSliceInlining();
+
+  // Return an interval representing the offset and length.
+  QuicInterval<std::size_t> interval() const;
+
+  // Stream data of this data slice.
+  QuicInlinedStringView<kSendBufferMaxInlinedSize + 1> slice;
+
+  // Location of this data slice in the stream.
+  QuicStreamOffset offset;
+};
+
+// QuicStreamSendBuffer contains all of the outstanding (provided by the
+// application and not yet acknowledged by the peer) stream data.  Internally it
+// is a circular deque of (potentially inlined) QuicheMemSlices, indexed by the
+// offset in the stream.  The stream can be accessed randomly in O(log(n)) time,
+// though if the offsets are accessed sequentially, the access will be O(1).
+class QUICHE_EXPORT QuicStreamSendBufferInlining
+    : public QuicStreamSendBufferBase {
+ public:
+  explicit QuicStreamSendBufferInlining(
+      quiche::QuicheBufferAllocator* allocator);
+
+  // Save |data| to send buffer.
+  void SaveStreamData(absl::string_view data) override;
+
+  // Save |slice| to send buffer.
+  void SaveMemSlice(quiche::QuicheMemSlice slice) override;
+
+  // Save all slices in |span| to send buffer. Return total bytes saved.
+  QuicByteCount SaveMemSliceSpan(
+      absl::Span<quiche::QuicheMemSlice> span) override;
+
+  // Write |data_length| of data starts at |offset|. Returns true if all data
+  // was successfully written. Returns false if the writer fails to write, or if
+  // the data was already marked as acked, or if the data was never saved in the
+  // first place.
+  bool WriteStreamData(QuicStreamOffset offset, QuicByteCount data_length,
+                       QuicDataWriter* writer) override;
+
+  // Number of data slices in send buffer.
+  size_t size() const override;
+
+  QuicStreamOffset stream_offset() const override { return stream_offset_; }
+
+  void SetStreamOffsetForTest(QuicStreamOffset new_offset) override;
+  absl::string_view LatestWriteForTest() override;
+  QuicByteCount TotalDataBufferedForTest() override;
+
+ private:
+  friend class test::QuicStreamSendBufferPeer;
+
+  // Called when data within offset [start, end) gets acked. Frees fully
+  // acked buffered slices if any. Returns false if the corresponding data does
+  // not exist or has been acked.
+  bool FreeMemSlices(QuicStreamOffset start, QuicStreamOffset end) override;
+
+  // Cleanup acked data from the start of the interval.
+  void CleanUpBufferedSlices() override;
+
+  // Frees an individual buffered slice.
+  void ClearSlice(BufferedSliceInlining& slice);
+
+  // Contains actual stream data.
+  QuicIntervalDeque<BufferedSliceInlining> interval_deque_;
+
+  // Offset of next inserted byte.
+  QuicStreamOffset stream_offset_ = 0;
+
+  // For slices that are not inlined, contains a map from the offset of the
+  // slice in the buffer to the slice release callback.  Those are stored
+  // separately from `interval_deque_`, since the callbacks themselves can be
+  // quite large, and for many slices, those would not be present.
+  absl::flat_hash_map<QuicStreamOffset, quiche::QuicheMemSlice> owned_slices_;
+
+  quiche::QuicheBufferAllocator* allocator_;
+};
+
+}  // namespace quic
+
+#endif  // QUICHE_QUIC_CORE_QUIC_STREAM_SEND_BUFFER_INLINING_H_
diff --git a/quiche/quic/core/quic_stream_send_buffer_test.cc b/quiche/quic/core/quic_stream_send_buffer_test.cc
index d74a757..312f502 100644
--- a/quiche/quic/core/quic_stream_send_buffer_test.cc
+++ b/quiche/quic/core/quic_stream_send_buffer_test.cc
@@ -4,29 +4,58 @@
 
 #include "quiche/quic/core/quic_stream_send_buffer.h"
 
+#include <cstddef>
+#include <cstring>
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/span.h"
 #include "quiche/quic/core/quic_data_writer.h"
+#include "quiche/quic/core/quic_stream_send_buffer_base.h"
+#include "quiche/quic/core/quic_stream_send_buffer_inlining.h"
+#include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/platform/api/quic_expect_bug.h"
 #include "quiche/quic/platform/api/quic_flags.h"
-#include "quiche/quic/platform/api/quic_test.h"
 #include "quiche/quic/test_tools/quic_stream_send_buffer_peer.h"
 #include "quiche/quic/test_tools/quic_test_utils.h"
+#include "quiche/common/platform/api/quiche_test.h"
+#include "quiche/common/quiche_buffer_allocator.h"
+#include "quiche/common/quiche_endian.h"
+#include "quiche/common/quiche_mem_slice.h"
 #include "quiche/common/simple_buffer_allocator.h"
 
 namespace quic {
 namespace test {
 namespace {
 
-class QuicStreamSendBufferTest : public QuicTest {
+enum class SendBufferType {
+  kDefault,
+  kInlining,
+};
+
+std::string SendBufferTypeName(
+    const testing::TestParamInfo<SendBufferType>& type) {
+  switch (type.param) {
+    case SendBufferType::kDefault:
+      return "Default";
+    case SendBufferType::kInlining:
+      return "Inlining";
+  }
+  return "<invalid>";
+}
+
+class QuicStreamSendBufferTest
+    : public quiche::test::QuicheTestWithParam<SendBufferType> {
  public:
-  QuicStreamSendBufferTest() : send_buffer_(&allocator_) {
-    EXPECT_EQ(0u, send_buffer_.size());
-    EXPECT_EQ(0u, send_buffer_.stream_bytes_written());
-    EXPECT_EQ(0u, send_buffer_.stream_bytes_outstanding());
+  QuicStreamSendBufferTest() {
+    send_buffer_ = CreateBuffer();
+    EXPECT_EQ(0u, send_buffer_->size());
+    EXPECT_EQ(0u, send_buffer_->stream_bytes_written());
+    EXPECT_EQ(0u, send_buffer_->stream_bytes_outstanding());
 
     std::string data1 = absl::StrCat(
         std::string(1536, 'a'), std::string(256, 'b'), std::string(256, 'c'));
@@ -41,37 +70,52 @@
 
     // `data` will be split into two BufferedSlices.
     SetQuicFlag(quic_send_buffer_max_data_slice_size, 1024);
-    send_buffer_.SaveStreamData(data1);
+    send_buffer_->SaveStreamData(data1);
 
-    send_buffer_.SaveMemSlice(std::move(slice1));
+    send_buffer_->SaveMemSlice(std::move(slice1));
     EXPECT_TRUE(slice1.empty());
-    send_buffer_.SaveMemSlice(std::move(slice2));
+    send_buffer_->SaveMemSlice(std::move(slice2));
     EXPECT_TRUE(slice2.empty());
 
-    EXPECT_EQ(4u, send_buffer_.size());
-    // At this point, `send_buffer_.interval_deque_` looks like this:
+    EXPECT_EQ(4u, send_buffer_->size());
+    // At this point, `send_buffer_->interval_deque_` looks like this:
     // BufferedSlice1: 'a' * 1024
     // BufferedSlice2: 'a' * 512 + 'b' * 256 + 'c' * 256
     // BufferedSlice3: 'c' * 1024
     // BufferedSlice4: 'd' * 768
   }
 
+  std::unique_ptr<QuicStreamSendBufferBase> CreateBuffer() {
+    switch (GetParam()) {
+      case SendBufferType::kDefault:
+        return std::make_unique<QuicStreamSendBuffer>(&allocator_);
+      case SendBufferType::kInlining:
+        return std::make_unique<QuicStreamSendBufferInlining>(&allocator_);
+    }
+    return nullptr;
+  }
+
   void WriteAllData() {
     // Write all data.
     char buf[4000];
     QuicDataWriter writer(4000, buf, quiche::HOST_BYTE_ORDER);
-    EXPECT_TRUE(send_buffer_.WriteStreamData(0, 3840u, &writer));
+    EXPECT_TRUE(send_buffer_->WriteStreamData(0, 3840u, &writer));
 
-    send_buffer_.OnStreamDataConsumed(3840u);
-    EXPECT_EQ(3840u, send_buffer_.stream_bytes_written());
-    EXPECT_EQ(3840u, send_buffer_.stream_bytes_outstanding());
+    send_buffer_->OnStreamDataConsumed(3840u);
+    EXPECT_EQ(3840u, send_buffer_->stream_bytes_written());
+    EXPECT_EQ(3840u, send_buffer_->stream_bytes_outstanding());
   }
 
   quiche::SimpleBufferAllocator allocator_;
-  QuicStreamSendBuffer send_buffer_;
+  std::unique_ptr<QuicStreamSendBufferBase> send_buffer_;
 };
 
-TEST_F(QuicStreamSendBufferTest, CopyDataToBuffer) {
+INSTANTIATE_TEST_SUITE_P(QuicStreamSendBufferTests, QuicStreamSendBufferTest,
+                         testing::Values(SendBufferType::kDefault,
+                                         SendBufferType::kInlining),
+                         SendBufferTypeName);
+
+TEST_P(QuicStreamSendBufferTest, CopyDataToBuffer) {
   char buf[4000];
   QuicDataWriter writer(4000, buf, quiche::HOST_BYTE_ORDER);
   std::string copy1(1024, 'a');
@@ -80,38 +124,38 @@
   std::string copy3(1024, 'c');
   std::string copy4(768, 'd');
 
-  ASSERT_TRUE(send_buffer_.WriteStreamData(0, 1024, &writer));
+  ASSERT_TRUE(send_buffer_->WriteStreamData(0, 1024, &writer));
   EXPECT_EQ(copy1, absl::string_view(buf, 1024));
-  ASSERT_TRUE(send_buffer_.WriteStreamData(1024, 1024, &writer));
+  ASSERT_TRUE(send_buffer_->WriteStreamData(1024, 1024, &writer));
   EXPECT_EQ(copy2, absl::string_view(buf + 1024, 1024));
-  ASSERT_TRUE(send_buffer_.WriteStreamData(2048, 1024, &writer));
+  ASSERT_TRUE(send_buffer_->WriteStreamData(2048, 1024, &writer));
   EXPECT_EQ(copy3, absl::string_view(buf + 2048, 1024));
-  ASSERT_TRUE(send_buffer_.WriteStreamData(3072, 768, &writer));
+  ASSERT_TRUE(send_buffer_->WriteStreamData(3072, 768, &writer));
   EXPECT_EQ(copy4, absl::string_view(buf + 3072, 768));
 
   // Test data piece across boundries.
   QuicDataWriter writer2(4000, buf, quiche::HOST_BYTE_ORDER);
   std::string copy5 =
       std::string(536, 'a') + std::string(256, 'b') + std::string(232, 'c');
-  ASSERT_TRUE(send_buffer_.WriteStreamData(1000, 1024, &writer2));
+  ASSERT_TRUE(send_buffer_->WriteStreamData(1000, 1024, &writer2));
   EXPECT_EQ(copy5, absl::string_view(buf, 1024));
-  ASSERT_TRUE(send_buffer_.WriteStreamData(2500, 1024, &writer2));
+  ASSERT_TRUE(send_buffer_->WriteStreamData(2500, 1024, &writer2));
   std::string copy6 = std::string(572, 'c') + std::string(452, 'd');
   EXPECT_EQ(copy6, absl::string_view(buf + 1024, 1024));
 
   // Invalid data copy.
   QuicDataWriter writer3(4000, buf, quiche::HOST_BYTE_ORDER);
-  EXPECT_FALSE(send_buffer_.WriteStreamData(3000, 1024, &writer3));
-  EXPECT_QUIC_BUG(send_buffer_.WriteStreamData(0, 4000, &writer3),
+  EXPECT_FALSE(send_buffer_->WriteStreamData(3000, 1024, &writer3));
+  EXPECT_QUIC_BUG(send_buffer_->WriteStreamData(0, 4000, &writer3),
                   "Writer fails to write.");
 
-  send_buffer_.OnStreamDataConsumed(3840);
-  EXPECT_EQ(3840u, send_buffer_.stream_bytes_written());
-  EXPECT_EQ(3840u, send_buffer_.stream_bytes_outstanding());
+  send_buffer_->OnStreamDataConsumed(3840);
+  EXPECT_EQ(3840u, send_buffer_->stream_bytes_written());
+  EXPECT_EQ(3840u, send_buffer_->stream_bytes_outstanding());
 }
 
 // Regression test for b/143491027.
-TEST_F(QuicStreamSendBufferTest,
+TEST_P(QuicStreamSendBufferTest,
        WriteStreamDataContainsBothRetransmissionAndNewData) {
   std::string copy1(1024, 'a');
   std::string copy2 =
@@ -120,180 +164,185 @@
   char buf[6000];
   QuicDataWriter writer(6000, buf, quiche::HOST_BYTE_ORDER);
   // Write more than one slice.
-  EXPECT_EQ(0, QuicStreamSendBufferPeer::write_index(&send_buffer_));
-  ASSERT_TRUE(send_buffer_.WriteStreamData(0, 1024, &writer));
+  if (GetParam() == SendBufferType::kDefault) {
+    EXPECT_EQ(0, QuicStreamSendBufferPeer::write_index(
+                     static_cast<QuicStreamSendBuffer*>(send_buffer_.get())));
+  }
+  ASSERT_TRUE(send_buffer_->WriteStreamData(0, 1024, &writer));
   EXPECT_EQ(copy1, absl::string_view(buf, 1024));
-  EXPECT_EQ(1, QuicStreamSendBufferPeer::write_index(&send_buffer_));
+  if (GetParam() == SendBufferType::kDefault) {
+    EXPECT_EQ(1, QuicStreamSendBufferPeer::write_index(
+                     static_cast<QuicStreamSendBuffer*>(send_buffer_.get())));
+  }
 
   // Retransmit the first frame and also send new data.
-  ASSERT_TRUE(send_buffer_.WriteStreamData(0, 2048, &writer));
+  ASSERT_TRUE(send_buffer_->WriteStreamData(0, 2048, &writer));
   EXPECT_EQ(copy1 + copy2, absl::string_view(buf + 1024, 2048));
 
   // Write new data.
-  ASSERT_TRUE(send_buffer_.WriteStreamData(2048, 50, &writer));
+  ASSERT_TRUE(send_buffer_->WriteStreamData(2048, 50, &writer));
   EXPECT_EQ(std::string(50, 'c'), absl::string_view(buf + 1024 + 2048, 50));
-  ASSERT_TRUE(send_buffer_.WriteStreamData(2048, 1124, &writer));
+  ASSERT_TRUE(send_buffer_->WriteStreamData(2048, 1124, &writer));
   EXPECT_EQ(copy3, absl::string_view(buf + 1024 + 2048 + 50, 1124));
 }
 
-TEST_F(QuicStreamSendBufferTest, RemoveStreamFrame) {
+TEST_P(QuicStreamSendBufferTest, RemoveStreamFrame) {
   WriteAllData();
 
   QuicByteCount newly_acked_length;
-  EXPECT_TRUE(send_buffer_.OnStreamDataAcked(1024, 1024, &newly_acked_length));
+  EXPECT_TRUE(send_buffer_->OnStreamDataAcked(1024, 1024, &newly_acked_length));
   EXPECT_EQ(1024u, newly_acked_length);
-  EXPECT_EQ(4u, send_buffer_.size());
+  EXPECT_EQ(4u, send_buffer_->size());
 
-  EXPECT_TRUE(send_buffer_.OnStreamDataAcked(2048, 1024, &newly_acked_length));
+  EXPECT_TRUE(send_buffer_->OnStreamDataAcked(2048, 1024, &newly_acked_length));
   EXPECT_EQ(1024u, newly_acked_length);
-  EXPECT_EQ(4u, send_buffer_.size());
+  EXPECT_EQ(4u, send_buffer_->size());
 
-  EXPECT_TRUE(send_buffer_.OnStreamDataAcked(0, 1024, &newly_acked_length));
+  EXPECT_TRUE(send_buffer_->OnStreamDataAcked(0, 1024, &newly_acked_length));
   EXPECT_EQ(1024u, newly_acked_length);
 
   // Send buffer is cleaned up in order.
-  EXPECT_EQ(1u, send_buffer_.size());
-  EXPECT_TRUE(send_buffer_.OnStreamDataAcked(3072, 768, &newly_acked_length));
+  EXPECT_EQ(1u, send_buffer_->size());
+  EXPECT_TRUE(send_buffer_->OnStreamDataAcked(3072, 768, &newly_acked_length));
   EXPECT_EQ(768u, newly_acked_length);
-  EXPECT_EQ(0u, send_buffer_.size());
+  EXPECT_EQ(0u, send_buffer_->size());
 }
 
-TEST_F(QuicStreamSendBufferTest, RemoveStreamFrameAcrossBoundaries) {
+TEST_P(QuicStreamSendBufferTest, RemoveStreamFrameAcrossBoundaries) {
   WriteAllData();
 
   QuicByteCount newly_acked_length;
-  EXPECT_TRUE(send_buffer_.OnStreamDataAcked(2024, 576, &newly_acked_length));
+  EXPECT_TRUE(send_buffer_->OnStreamDataAcked(2024, 576, &newly_acked_length));
   EXPECT_EQ(576u, newly_acked_length);
-  EXPECT_EQ(4u, send_buffer_.size());
+  EXPECT_EQ(4u, send_buffer_->size());
 
-  EXPECT_TRUE(send_buffer_.OnStreamDataAcked(0, 1000, &newly_acked_length));
+  EXPECT_TRUE(send_buffer_->OnStreamDataAcked(0, 1000, &newly_acked_length));
   EXPECT_EQ(1000u, newly_acked_length);
-  EXPECT_EQ(4u, send_buffer_.size());
+  EXPECT_EQ(4u, send_buffer_->size());
 
-  EXPECT_TRUE(send_buffer_.OnStreamDataAcked(1000, 1024, &newly_acked_length));
+  EXPECT_TRUE(send_buffer_->OnStreamDataAcked(1000, 1024, &newly_acked_length));
   EXPECT_EQ(1024u, newly_acked_length);
   // Send buffer is cleaned up in order.
-  EXPECT_EQ(2u, send_buffer_.size());
+  EXPECT_EQ(2u, send_buffer_->size());
 
-  EXPECT_TRUE(send_buffer_.OnStreamDataAcked(2600, 1024, &newly_acked_length));
+  EXPECT_TRUE(send_buffer_->OnStreamDataAcked(2600, 1024, &newly_acked_length));
   EXPECT_EQ(1024u, newly_acked_length);
-  EXPECT_EQ(1u, send_buffer_.size());
+  EXPECT_EQ(1u, send_buffer_->size());
 
-  EXPECT_TRUE(send_buffer_.OnStreamDataAcked(3624, 216, &newly_acked_length));
+  EXPECT_TRUE(send_buffer_->OnStreamDataAcked(3624, 216, &newly_acked_length));
   EXPECT_EQ(216u, newly_acked_length);
-  EXPECT_EQ(0u, send_buffer_.size());
+  EXPECT_EQ(0u, send_buffer_->size());
 }
 
-TEST_F(QuicStreamSendBufferTest, AckStreamDataMultipleTimes) {
+TEST_P(QuicStreamSendBufferTest, AckStreamDataMultipleTimes) {
   WriteAllData();
   QuicByteCount newly_acked_length;
-  EXPECT_TRUE(send_buffer_.OnStreamDataAcked(100, 1500, &newly_acked_length));
+  EXPECT_TRUE(send_buffer_->OnStreamDataAcked(100, 1500, &newly_acked_length));
   EXPECT_EQ(1500u, newly_acked_length);
-  EXPECT_EQ(4u, send_buffer_.size());
+  EXPECT_EQ(4u, send_buffer_->size());
 
-  EXPECT_TRUE(send_buffer_.OnStreamDataAcked(2000, 500, &newly_acked_length));
+  EXPECT_TRUE(send_buffer_->OnStreamDataAcked(2000, 500, &newly_acked_length));
   EXPECT_EQ(500u, newly_acked_length);
-  EXPECT_EQ(4u, send_buffer_.size());
+  EXPECT_EQ(4u, send_buffer_->size());
 
-  EXPECT_TRUE(send_buffer_.OnStreamDataAcked(0, 2600, &newly_acked_length));
+  EXPECT_TRUE(send_buffer_->OnStreamDataAcked(0, 2600, &newly_acked_length));
   EXPECT_EQ(600u, newly_acked_length);
   // Send buffer is cleaned up in order.
-  EXPECT_EQ(2u, send_buffer_.size());
+  EXPECT_EQ(2u, send_buffer_->size());
 
-  EXPECT_TRUE(send_buffer_.OnStreamDataAcked(2200, 1640, &newly_acked_length));
+  EXPECT_TRUE(send_buffer_->OnStreamDataAcked(2200, 1640, &newly_acked_length));
   EXPECT_EQ(1240u, newly_acked_length);
-  EXPECT_EQ(0u, send_buffer_.size());
+  EXPECT_EQ(0u, send_buffer_->size());
 
-  EXPECT_FALSE(send_buffer_.OnStreamDataAcked(4000, 100, &newly_acked_length));
+  EXPECT_FALSE(send_buffer_->OnStreamDataAcked(4000, 100, &newly_acked_length));
 }
 
-TEST_F(QuicStreamSendBufferTest, AckStreamDataOutOfOrder) {
+TEST_P(QuicStreamSendBufferTest, AckStreamDataOutOfOrder) {
   WriteAllData();
   QuicByteCount newly_acked_length;
-  EXPECT_TRUE(send_buffer_.OnStreamDataAcked(500, 1000, &newly_acked_length));
+  EXPECT_TRUE(send_buffer_->OnStreamDataAcked(500, 1000, &newly_acked_length));
   EXPECT_EQ(1000u, newly_acked_length);
-  EXPECT_EQ(4u, send_buffer_.size());
-  EXPECT_EQ(3840u, QuicStreamSendBufferPeer::TotalLength(&send_buffer_));
+  EXPECT_EQ(4u, send_buffer_->size());
+  EXPECT_EQ(3840u, QuicStreamSendBufferPeer::TotalLength(send_buffer_.get()));
 
-  EXPECT_TRUE(send_buffer_.OnStreamDataAcked(1200, 1000, &newly_acked_length));
+  EXPECT_TRUE(send_buffer_->OnStreamDataAcked(1200, 1000, &newly_acked_length));
   EXPECT_EQ(700u, newly_acked_length);
-  EXPECT_EQ(4u, send_buffer_.size());
+  EXPECT_EQ(4u, send_buffer_->size());
   // Slice 2 gets fully acked.
-  EXPECT_EQ(2816u, QuicStreamSendBufferPeer::TotalLength(&send_buffer_));
+  EXPECT_EQ(2816u, QuicStreamSendBufferPeer::TotalLength(send_buffer_.get()));
 
-  EXPECT_TRUE(send_buffer_.OnStreamDataAcked(2000, 1840, &newly_acked_length));
+  EXPECT_TRUE(send_buffer_->OnStreamDataAcked(2000, 1840, &newly_acked_length));
   EXPECT_EQ(1640u, newly_acked_length);
-  EXPECT_EQ(4u, send_buffer_.size());
+  EXPECT_EQ(4u, send_buffer_->size());
   // Slices 3 and 4 get fully acked.
-  EXPECT_EQ(1024u, QuicStreamSendBufferPeer::TotalLength(&send_buffer_));
+  EXPECT_EQ(1024u, QuicStreamSendBufferPeer::TotalLength(send_buffer_.get()));
 
-  EXPECT_TRUE(send_buffer_.OnStreamDataAcked(0, 1000, &newly_acked_length));
+  EXPECT_TRUE(send_buffer_->OnStreamDataAcked(0, 1000, &newly_acked_length));
   EXPECT_EQ(500u, newly_acked_length);
-  EXPECT_EQ(0u, send_buffer_.size());
-  EXPECT_EQ(0u, QuicStreamSendBufferPeer::TotalLength(&send_buffer_));
+  EXPECT_EQ(0u, send_buffer_->size());
+  EXPECT_EQ(0u, QuicStreamSendBufferPeer::TotalLength(send_buffer_.get()));
 }
 
-TEST_F(QuicStreamSendBufferTest, PendingRetransmission) {
+TEST_P(QuicStreamSendBufferTest, PendingRetransmission) {
   WriteAllData();
-  EXPECT_TRUE(send_buffer_.IsStreamDataOutstanding(0, 3840));
-  EXPECT_FALSE(send_buffer_.HasPendingRetransmission());
+  EXPECT_TRUE(send_buffer_->IsStreamDataOutstanding(0, 3840));
+  EXPECT_FALSE(send_buffer_->HasPendingRetransmission());
   // Lost data [0, 1200).
-  send_buffer_.OnStreamDataLost(0, 1200);
+  send_buffer_->OnStreamDataLost(0, 1200);
   // Lost data [1500, 2000).
-  send_buffer_.OnStreamDataLost(1500, 500);
-  EXPECT_TRUE(send_buffer_.HasPendingRetransmission());
+  send_buffer_->OnStreamDataLost(1500, 500);
+  EXPECT_TRUE(send_buffer_->HasPendingRetransmission());
 
   EXPECT_EQ(StreamPendingRetransmission(0, 1200),
-            send_buffer_.NextPendingRetransmission());
+            send_buffer_->NextPendingRetransmission());
   // Retransmit data [0, 500).
-  send_buffer_.OnStreamDataRetransmitted(0, 500);
-  EXPECT_TRUE(send_buffer_.IsStreamDataOutstanding(0, 500));
+  send_buffer_->OnStreamDataRetransmitted(0, 500);
+  EXPECT_TRUE(send_buffer_->IsStreamDataOutstanding(0, 500));
   EXPECT_EQ(StreamPendingRetransmission(500, 700),
-            send_buffer_.NextPendingRetransmission());
+            send_buffer_->NextPendingRetransmission());
   // Ack data [500, 1200).
   QuicByteCount newly_acked_length = 0;
-  EXPECT_TRUE(send_buffer_.OnStreamDataAcked(500, 700, &newly_acked_length));
-  EXPECT_FALSE(send_buffer_.IsStreamDataOutstanding(500, 700));
-  EXPECT_TRUE(send_buffer_.HasPendingRetransmission());
+  EXPECT_TRUE(send_buffer_->OnStreamDataAcked(500, 700, &newly_acked_length));
+  EXPECT_FALSE(send_buffer_->IsStreamDataOutstanding(500, 700));
+  EXPECT_TRUE(send_buffer_->HasPendingRetransmission());
   EXPECT_EQ(StreamPendingRetransmission(1500, 500),
-            send_buffer_.NextPendingRetransmission());
+            send_buffer_->NextPendingRetransmission());
   // Retransmit data [1500, 2000).
-  send_buffer_.OnStreamDataRetransmitted(1500, 500);
-  EXPECT_FALSE(send_buffer_.HasPendingRetransmission());
+  send_buffer_->OnStreamDataRetransmitted(1500, 500);
+  EXPECT_FALSE(send_buffer_->HasPendingRetransmission());
 
   // Lost [200, 800).
-  send_buffer_.OnStreamDataLost(200, 600);
-  EXPECT_TRUE(send_buffer_.HasPendingRetransmission());
+  send_buffer_->OnStreamDataLost(200, 600);
+  EXPECT_TRUE(send_buffer_->HasPendingRetransmission());
   // Verify [200, 500) is considered as lost, as [500, 800) has been acked.
   EXPECT_EQ(StreamPendingRetransmission(200, 300),
-            send_buffer_.NextPendingRetransmission());
+            send_buffer_->NextPendingRetransmission());
 
   // Verify 0 length data is not outstanding.
-  EXPECT_FALSE(send_buffer_.IsStreamDataOutstanding(100, 0));
+  EXPECT_FALSE(send_buffer_->IsStreamDataOutstanding(100, 0));
   // Verify partially acked data is outstanding.
-  EXPECT_TRUE(send_buffer_.IsStreamDataOutstanding(400, 800));
+  EXPECT_TRUE(send_buffer_->IsStreamDataOutstanding(400, 800));
 }
 
-TEST_F(QuicStreamSendBufferTest, OutOfOrderWrites) {
+TEST_P(QuicStreamSendBufferTest, OutOfOrderWrites) {
   char buf[3840] = {};
   // Write data out of order.
   QuicDataWriter writer2(sizeof(buf) - 1000, buf + 1000);
-  EXPECT_TRUE(send_buffer_.WriteStreamData(1000u, 1000u, &writer2));
+  EXPECT_TRUE(send_buffer_->WriteStreamData(1000u, 1000u, &writer2));
   QuicDataWriter writer4(sizeof(buf) - 3000, buf + 3000);
-  EXPECT_TRUE(send_buffer_.WriteStreamData(3000u, 840u, &writer4));
+  EXPECT_TRUE(send_buffer_->WriteStreamData(3000u, 840u, &writer4));
   QuicDataWriter writer3(sizeof(buf) - 2000, buf + 2000);
-  EXPECT_TRUE(send_buffer_.WriteStreamData(2000u, 1000u, &writer3));
+  EXPECT_TRUE(send_buffer_->WriteStreamData(2000u, 1000u, &writer3));
   QuicDataWriter writer1(sizeof(buf), buf);
-  EXPECT_TRUE(send_buffer_.WriteStreamData(0u, 1000u, &writer1));
+  EXPECT_TRUE(send_buffer_->WriteStreamData(0u, 1000u, &writer1));
   // Make sure it is correct.
   EXPECT_EQ(absl::string_view(buf, sizeof(buf)),
             absl::StrCat(std::string(1536, 'a'), std::string(256, 'b'),
                          std::string(1280, 'c'), std::string(768, 'd')));
 }
 
-TEST_F(QuicStreamSendBufferTest, SaveMemSliceSpan) {
-  quiche::SimpleBufferAllocator allocator;
-  QuicStreamSendBuffer send_buffer(&allocator);
+TEST_P(QuicStreamSendBufferTest, SaveMemSliceSpan) {
+  std::unique_ptr<QuicStreamSendBufferBase> send_buffer = CreateBuffer();
 
   std::string data(1024, 'a');
   std::vector<quiche::QuicheMemSlice> buffers;
@@ -301,13 +350,12 @@
     buffers.push_back(MemSliceFromString(data));
   }
 
-  EXPECT_EQ(10 * 1024u, send_buffer.SaveMemSliceSpan(absl::MakeSpan(buffers)));
-  EXPECT_EQ(10u, send_buffer.size());
+  EXPECT_EQ(10 * 1024u, send_buffer->SaveMemSliceSpan(absl::MakeSpan(buffers)));
+  EXPECT_EQ(10u, send_buffer->size());
 }
 
-TEST_F(QuicStreamSendBufferTest, SaveEmptyMemSliceSpan) {
-  quiche::SimpleBufferAllocator allocator;
-  QuicStreamSendBuffer send_buffer(&allocator);
+TEST_P(QuicStreamSendBufferTest, SaveEmptyMemSliceSpan) {
+  std::unique_ptr<QuicStreamSendBufferBase> send_buffer = CreateBuffer();
 
   std::string data(1024, 'a');
   std::vector<quiche::QuicheMemSlice> buffers;
@@ -315,9 +363,23 @@
     buffers.push_back(MemSliceFromString(data));
   }
 
-  EXPECT_EQ(10 * 1024u, send_buffer.SaveMemSliceSpan(absl::MakeSpan(buffers)));
+  EXPECT_EQ(10 * 1024u, send_buffer->SaveMemSliceSpan(absl::MakeSpan(buffers)));
   // Verify the empty slice does not get saved.
-  EXPECT_EQ(10u, send_buffer.size());
+  EXPECT_EQ(10u, send_buffer->size());
+}
+
+TEST_P(QuicStreamSendBufferTest, SmallWrite) {
+  std::unique_ptr<QuicStreamSendBufferBase> send_buffer = CreateBuffer();
+
+  constexpr absl::string_view kData = "abcd";
+  send_buffer->SaveStreamData(kData);
+  EXPECT_EQ(1u, send_buffer->size());
+  EXPECT_EQ(4u, send_buffer->TotalDataBufferedForTest());
+
+  char buffer[16];
+  QuicDataWriter writer(sizeof(buffer), buffer);
+  ASSERT_TRUE(send_buffer->WriteStreamData(0, 4, &writer));
+  EXPECT_EQ(absl::string_view(buffer, 4), kData);
 }
 
 }  // namespace
diff --git a/quiche/quic/test_tools/quic_stream_send_buffer_peer.cc b/quiche/quic/test_tools/quic_stream_send_buffer_peer.cc
index c2c2806..35bca77 100644
--- a/quiche/quic/test_tools/quic_stream_send_buffer_peer.cc
+++ b/quiche/quic/test_tools/quic_stream_send_buffer_peer.cc
@@ -29,13 +29,8 @@
 
 // static
 QuicByteCount QuicStreamSendBufferPeer::TotalLength(
-    QuicStreamSendBuffer* send_buffer) {
-  QuicByteCount length = 0;
-  for (auto slice = send_buffer->interval_deque_.DataBegin();
-       slice != send_buffer->interval_deque_.DataEnd(); ++slice) {
-    length += slice->slice.length();
-  }
-  return length;
+    QuicStreamSendBufferBase* send_buffer) {
+  return send_buffer->TotalDataBufferedForTest();
 }
 
 // static
diff --git a/quiche/quic/test_tools/quic_stream_send_buffer_peer.h b/quiche/quic/test_tools/quic_stream_send_buffer_peer.h
index 8969241..d65a1bf 100644
--- a/quiche/quic/test_tools/quic_stream_send_buffer_peer.h
+++ b/quiche/quic/test_tools/quic_stream_send_buffer_peer.h
@@ -19,7 +19,7 @@
   static const BufferedSlice* CurrentWriteSlice(
       QuicStreamSendBuffer* send_buffer);
 
-  static QuicByteCount TotalLength(QuicStreamSendBuffer* send_buffer);
+  static QuicByteCount TotalLength(QuicStreamSendBufferBase* send_buffer);
 
   static int32_t write_index(QuicStreamSendBuffer* send_buffer);
 };