diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index e926af7..2471756 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -430,7 +430,7 @@
     return sequencer()->Readv(iov, iov_len);
   }
   size_t bytes_read = 0;
-  sequencer()->MarkConsumed(body_buffer_.ReadBody(iov, iov_len, &bytes_read));
+  sequencer()->MarkConsumed(body_manager_.ReadBody(iov, iov_len, &bytes_read));
 
   return bytes_read;
 }
@@ -440,7 +440,7 @@
   if (!VersionHasDataFrameHeader(transport_version())) {
     return sequencer()->GetReadableRegions(iov, iov_len);
   }
-  return body_buffer_.PeekBody(iov, iov_len);
+  return body_manager_.PeekBody(iov, iov_len);
 }
 
 void QuicSpdyStream::MarkConsumed(size_t num_bytes) {
@@ -450,7 +450,7 @@
     return;
   }
 
-  sequencer()->MarkConsumed(body_buffer_.OnBodyConsumed(num_bytes));
+  sequencer()->MarkConsumed(body_manager_.OnBodyConsumed(num_bytes));
 }
 
 bool QuicSpdyStream::IsDoneReading() const {
@@ -464,7 +464,7 @@
   if (!VersionHasDataFrameHeader(transport_version())) {
     return sequencer()->HasBytesToRead();
   }
-  return body_buffer_.HasBytesToRead();
+  return body_manager_.HasBytesToRead();
 }
 
 void QuicSpdyStream::MarkTrailersConsumed() {
@@ -473,7 +473,7 @@
 
 uint64_t QuicSpdyStream::total_body_bytes_read() const {
   if (VersionHasDataFrameHeader(transport_version())) {
-    return body_buffer_.total_body_bytes_received();
+    return body_manager_.total_body_bytes_received();
   }
   return sequencer()->NumBytesConsumed();
 }
@@ -490,7 +490,7 @@
     return;
   }
 
-  if (body_buffer_.HasBytesToRead()) {
+  if (body_manager_.HasBytesToRead()) {
     OnBodyAvailable();
     return;
   }
@@ -709,7 +709,7 @@
     return;
   }
 
-  if (body_buffer_.HasBytesToRead()) {
+  if (body_manager_.HasBytesToRead()) {
     OnBodyAvailable();
     return;
   }
@@ -794,7 +794,7 @@
     return false;
   }
 
-  sequencer()->MarkConsumed(body_buffer_.OnNonBody(header_length));
+  sequencer()->MarkConsumed(body_manager_.OnNonBody(header_length));
 
   return true;
 }
@@ -802,7 +802,7 @@
 bool QuicSpdyStream::OnDataFramePayload(QuicStringPiece payload) {
   DCHECK(VersionHasDataFrameHeader(transport_version()));
 
-  body_buffer_.OnBody(payload);
+  body_manager_.OnBody(payload);
 
   return true;
 }
@@ -810,7 +810,7 @@
 bool QuicSpdyStream::OnDataFrameEnd() {
   DCHECK(VersionHasDataFrameHeader(transport_version()));
   QUIC_DVLOG(1) << "Reaches the end of a data frame. Total bytes received are "
-                << body_buffer_.total_body_bytes_received();
+                << body_manager_.total_body_bytes_received();
   return true;
 }
 
@@ -874,7 +874,7 @@
     return false;
   }
 
-  sequencer()->MarkConsumed(body_buffer_.OnNonBody(header_length));
+  sequencer()->MarkConsumed(body_manager_.OnNonBody(header_length));
 
   qpack_decoded_headers_accumulator_ =
       QuicMakeUnique<QpackDecodedHeadersAccumulator>(
@@ -895,7 +895,7 @@
 
   const bool success = qpack_decoded_headers_accumulator_->Decode(payload);
 
-  sequencer()->MarkConsumed(body_buffer_.OnNonBody(payload.size()));
+  sequencer()->MarkConsumed(body_manager_.OnNonBody(payload.size()));
 
   if (!success) {
     // TODO(124216424): Use HTTP_QPACK_DECOMPRESSION_FAILED error code.
@@ -942,7 +942,7 @@
   // TODO(renjietang): Check max push id and handle errors.
   spdy_session_->OnPushPromise(id(), push_id);
   sequencer()->MarkConsumed(
-      body_buffer_.OnNonBody(header_length + push_id_length));
+      body_manager_.OnNonBody(header_length + push_id_length));
 
   qpack_decoded_headers_accumulator_ =
       QuicMakeUnique<QpackDecodedHeadersAccumulator>(
@@ -969,7 +969,7 @@
   QUIC_DVLOG(1) << "Discarding " << header_length
                 << " byte long frame header of frame of unknown type "
                 << frame_type << ".";
-  sequencer()->MarkConsumed(body_buffer_.OnNonBody(header_length));
+  sequencer()->MarkConsumed(body_manager_.OnNonBody(header_length));
   return true;
 }
 
@@ -977,7 +977,7 @@
   // Ignore unknown frames, but consume frame payload.
   QUIC_DVLOG(1) << "Discarding " << payload.size()
                 << " bytes of payload of frame of unknown type.";
-  sequencer()->MarkConsumed(body_buffer_.OnNonBody(payload.size()));
+  sequencer()->MarkConsumed(body_manager_.OnNonBody(payload.size()));
   return true;
 }
 
diff --git a/quic/core/http/quic_spdy_stream.h b/quic/core/http/quic_spdy_stream.h
index 7279386..42f76bb 100644
--- a/quic/core/http/quic_spdy_stream.h
+++ b/quic/core/http/quic_spdy_stream.h
@@ -18,7 +18,7 @@
 #include "net/third_party/quiche/src/quic/core/http/http_decoder.h"
 #include "net/third_party/quiche/src/quic/core/http/http_encoder.h"
 #include "net/third_party/quiche/src/quic/core/http/quic_header_list.h"
-#include "net/third_party/quiche/src/quic/core/http/quic_spdy_stream_body_buffer.h"
+#include "net/third_party/quiche/src/quic/core/http/quic_spdy_stream_body_manager.h"
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_decoded_headers_accumulator.h"
 #include "net/third_party/quiche/src/quic/core/quic_packets.h"
 #include "net/third_party/quiche/src/quic/core/quic_stream.h"
@@ -312,8 +312,10 @@
   std::unique_ptr<HttpDecoderVisitor> http_decoder_visitor_;
   // HttpDecoder for processing raw incoming stream frames.
   HttpDecoder decoder_;
-  // Buffer that contains decoded data of the stream.
-  QuicSpdyStreamBodyBuffer body_buffer_;
+  // Object that manages references to DATA frame payload fragments buffered by
+  // the sequencer and calculates how much data should be marked consumed with
+  // the sequencer each time new stream data is processed.
+  QuicSpdyStreamBodyManager body_manager_;
 
   // Sequencer offset keeping track of how much data HttpDecoder has processed.
   // Initial value is zero for fresh streams, or sequencer()->NumBytesConsumed()
diff --git a/quic/core/http/quic_spdy_stream_body_buffer.cc b/quic/core/http/quic_spdy_stream_body_manager.cc
similarity index 86%
rename from quic/core/http/quic_spdy_stream_body_buffer.cc
rename to quic/core/http/quic_spdy_stream_body_manager.cc
index 2c54167..798f551 100644
--- a/quic/core/http/quic_spdy_stream_body_buffer.cc
+++ b/quic/core/http/quic_spdy_stream_body_manager.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "net/third_party/quiche/src/quic/core/http/quic_spdy_stream_body_buffer.h"
+#include "net/third_party/quiche/src/quic/core/http/quic_spdy_stream_body_manager.h"
 
 #include <algorithm>
 
@@ -10,10 +10,10 @@
 
 namespace quic {
 
-QuicSpdyStreamBodyBuffer::QuicSpdyStreamBodyBuffer()
+QuicSpdyStreamBodyManager::QuicSpdyStreamBodyManager()
     : total_body_bytes_received_(0) {}
 
-size_t QuicSpdyStreamBodyBuffer::OnNonBody(QuicByteCount length) {
+size_t QuicSpdyStreamBodyManager::OnNonBody(QuicByteCount length) {
   DCHECK_NE(0u, length);
 
   if (fragments_.empty()) {
@@ -27,14 +27,14 @@
   return 0;
 }
 
-void QuicSpdyStreamBodyBuffer::OnBody(QuicStringPiece body) {
+void QuicSpdyStreamBodyManager::OnBody(QuicStringPiece body) {
   DCHECK(!body.empty());
 
   fragments_.push_back({body, 0});
   total_body_bytes_received_ += body.length();
 }
 
-size_t QuicSpdyStreamBodyBuffer::OnBodyConsumed(size_t num_bytes) {
+size_t QuicSpdyStreamBodyManager::OnBodyConsumed(size_t num_bytes) {
   QuicByteCount bytes_to_consume = 0;
   size_t remaining_bytes = num_bytes;
 
@@ -64,7 +64,7 @@
   return bytes_to_consume;
 }
 
-int QuicSpdyStreamBodyBuffer::PeekBody(iovec* iov, size_t iov_len) const {
+int QuicSpdyStreamBodyManager::PeekBody(iovec* iov, size_t iov_len) const {
   DCHECK(iov);
   DCHECK_GT(iov_len, 0u);
 
@@ -86,9 +86,9 @@
   return iov_filled;
 }
 
-size_t QuicSpdyStreamBodyBuffer::ReadBody(const struct iovec* iov,
-                                          size_t iov_len,
-                                          size_t* total_bytes_read) {
+size_t QuicSpdyStreamBodyManager::ReadBody(const struct iovec* iov,
+                                           size_t iov_len,
+                                           size_t* total_bytes_read) {
   *total_bytes_read = 0;
   QuicByteCount bytes_to_consume = 0;
 
diff --git a/quic/core/http/quic_spdy_stream_body_buffer.h b/quic/core/http/quic_spdy_stream_body_manager.h
similarity index 89%
rename from quic/core/http/quic_spdy_stream_body_buffer.h
rename to quic/core/http/quic_spdy_stream_body_manager.h
index c1a907a..6b2dd62 100644
--- a/quic/core/http/quic_spdy_stream_body_buffer.h
+++ b/quic/core/http/quic_spdy_stream_body_manager.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef QUICHE_QUIC_CORE_HTTP_QUIC_SPDY_STREAM_BODY_BUFFER_H_
-#define QUICHE_QUIC_CORE_HTTP_QUIC_SPDY_STREAM_BODY_BUFFER_H_
+#ifndef QUICHE_QUIC_CORE_HTTP_QUIC_SPDY_STREAM_BODY_MANAGER_H_
+#define QUICHE_QUIC_CORE_HTTP_QUIC_SPDY_STREAM_BODY_MANAGER_H_
 
 #include "net/third_party/quiche/src/quic/core/quic_constants.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
@@ -21,16 +21,15 @@
 //  * everything else, which QuicSpdyStream immediately processes and thus could
 //    be marked as consumed with QuicStreamSequencer, unless there is some piece
 //    of body received prior that still needs to be buffered.
-// QuicSpdyStreamBodyBuffer does two things: it keeps references to body
+// QuicSpdyStreamBodyManager does two things: it keeps references to body
 // fragments (owned by QuicStreamSequencer) and offers methods to read them; and
 // it calculates the total number of bytes (including non-body bytes) the caller
 // needs to mark consumed (with QuicStreamSequencer) when non-body bytes are
 // received or when body is consumed.
-// TODO(bnc): Rename to QuicSpdyStreamBodyManager or similar.
-class QUIC_EXPORT_PRIVATE QuicSpdyStreamBodyBuffer {
+class QUIC_EXPORT_PRIVATE QuicSpdyStreamBodyManager {
  public:
-  QuicSpdyStreamBodyBuffer();
-  ~QuicSpdyStreamBodyBuffer() = default;
+  QuicSpdyStreamBodyManager();
+  ~QuicSpdyStreamBodyManager() = default;
 
   // One of the following two methods must be called every time data is received
   // on the request stream.
@@ -92,4 +91,4 @@
 
 }  // namespace quic
 
-#endif  // QUICHE_QUIC_CORE_HTTP_QUIC_SPDY_STREAM_BODY_BUFFER_H_
+#endif  // QUICHE_QUIC_CORE_HTTP_QUIC_SPDY_STREAM_BODY_MANAGER_H_
diff --git a/quic/core/http/quic_spdy_stream_body_buffer_test.cc b/quic/core/http/quic_spdy_stream_body_manager_test.cc
similarity index 84%
rename from quic/core/http/quic_spdy_stream_body_buffer_test.cc
rename to quic/core/http/quic_spdy_stream_body_manager_test.cc
index ef9dfe2..3a5b720 100644
--- a/quic/core/http/quic_spdy_stream_body_buffer_test.cc
+++ b/quic/core/http/quic_spdy_stream_body_manager_test.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "net/third_party/quiche/src/quic/core/http/quic_spdy_stream_body_buffer.h"
+#include "net/third_party/quiche/src/quic/core/http/quic_spdy_stream_body_manager.h"
 
 #include <algorithm>
 #include <numeric>
@@ -19,33 +19,33 @@
 
 namespace {
 
-class QuicSpdyStreamBodyBufferTest : public QuicTest {
+class QuicSpdyStreamBodyManagerTest : public QuicTest {
  protected:
-  QuicSpdyStreamBodyBuffer body_buffer_;
+  QuicSpdyStreamBodyManager body_manager_;
 };
 
-TEST_F(QuicSpdyStreamBodyBufferTest, HasBytesToRead) {
-  EXPECT_FALSE(body_buffer_.HasBytesToRead());
-  EXPECT_EQ(0u, body_buffer_.total_body_bytes_received());
+TEST_F(QuicSpdyStreamBodyManagerTest, HasBytesToRead) {
+  EXPECT_FALSE(body_manager_.HasBytesToRead());
+  EXPECT_EQ(0u, body_manager_.total_body_bytes_received());
 
   const QuicByteCount header_length = 3;
-  EXPECT_EQ(header_length, body_buffer_.OnNonBody(header_length));
+  EXPECT_EQ(header_length, body_manager_.OnNonBody(header_length));
 
-  EXPECT_FALSE(body_buffer_.HasBytesToRead());
-  EXPECT_EQ(0u, body_buffer_.total_body_bytes_received());
+  EXPECT_FALSE(body_manager_.HasBytesToRead());
+  EXPECT_EQ(0u, body_manager_.total_body_bytes_received());
 
   std::string body(1024, 'a');
-  body_buffer_.OnBody(body);
+  body_manager_.OnBody(body);
 
-  EXPECT_TRUE(body_buffer_.HasBytesToRead());
-  EXPECT_EQ(1024u, body_buffer_.total_body_bytes_received());
+  EXPECT_TRUE(body_manager_.HasBytesToRead());
+  EXPECT_EQ(1024u, body_manager_.total_body_bytes_received());
 }
 
-TEST_F(QuicSpdyStreamBodyBufferTest, ConsumeMoreThanAvailable) {
+TEST_F(QuicSpdyStreamBodyManagerTest, ConsumeMoreThanAvailable) {
   std::string body(1024, 'a');
-  body_buffer_.OnBody(body);
+  body_manager_.OnBody(body);
   size_t bytes_to_consume = 0;
-  EXPECT_QUIC_BUG(bytes_to_consume = body_buffer_.OnBodyConsumed(2048),
+  EXPECT_QUIC_BUG(bytes_to_consume = body_manager_.OnBodyConsumed(2048),
                   "Not enough available body to consume.");
   EXPECT_EQ(0u, bytes_to_consume);
 }
@@ -72,7 +72,7 @@
     {{3, 5}, {"foobar", "baz"}, {7, 2}, {12, 2}},
 };
 
-TEST_F(QuicSpdyStreamBodyBufferTest, OnBodyConsumed) {
+TEST_F(QuicSpdyStreamBodyManagerTest, OnBodyConsumed) {
   for (size_t test_case_index = 0;
        test_case_index < QUIC_ARRAYSIZE(kOnBodyConsumedTestData);
        ++test_case_index) {
@@ -89,19 +89,19 @@
          ++frame_index) {
       // Frame header of first frame can immediately be consumed, but not the
       // other frames.  Each test case start with an empty
-      // QuicSpdyStreamBodyBuffer.
+      // QuicSpdyStreamBodyManager.
       EXPECT_EQ(frame_index == 0 ? frame_header_lengths[frame_index] : 0u,
-                body_buffer_.OnNonBody(frame_header_lengths[frame_index]));
-      body_buffer_.OnBody(frame_payloads[frame_index]);
+                body_manager_.OnNonBody(frame_header_lengths[frame_index]));
+      body_manager_.OnBody(frame_payloads[frame_index]);
     }
 
     for (size_t call_index = 0; call_index < body_bytes_to_read.size();
          ++call_index) {
       EXPECT_EQ(expected_return_values[call_index],
-                body_buffer_.OnBodyConsumed(body_bytes_to_read[call_index]));
+                body_manager_.OnBodyConsumed(body_bytes_to_read[call_index]));
     }
 
-    EXPECT_FALSE(body_buffer_.HasBytesToRead());
+    EXPECT_FALSE(body_manager_.HasBytesToRead());
   }
 }
 
@@ -124,7 +124,7 @@
     {{3, 5}, {"foobar", "baz"}, 3},
 };
 
-TEST_F(QuicSpdyStreamBodyBufferTest, PeekBody) {
+TEST_F(QuicSpdyStreamBodyManagerTest, PeekBody) {
   for (size_t test_case_index = 0;
        test_case_index < QUIC_ARRAYSIZE(kPeekBodyTestData); ++test_case_index) {
     const std::vector<QuicByteCount>& frame_header_lengths =
@@ -133,23 +133,23 @@
         kPeekBodyTestData[test_case_index].frame_payloads;
     size_t iov_len = kPeekBodyTestData[test_case_index].iov_len;
 
-    QuicSpdyStreamBodyBuffer body_buffer;
+    QuicSpdyStreamBodyManager body_manager;
 
     for (size_t frame_index = 0; frame_index < frame_header_lengths.size();
          ++frame_index) {
       // Frame header of first frame can immediately be consumed, but not the
-      // other frames.  Each test case uses a new QuicSpdyStreamBodyBuffer
+      // other frames.  Each test case uses a new QuicSpdyStreamBodyManager
       // instance.
       EXPECT_EQ(frame_index == 0 ? frame_header_lengths[frame_index] : 0u,
-                body_buffer.OnNonBody(frame_header_lengths[frame_index]));
-      body_buffer.OnBody(frame_payloads[frame_index]);
+                body_manager.OnNonBody(frame_header_lengths[frame_index]));
+      body_manager.OnBody(frame_payloads[frame_index]);
     }
 
     std::vector<iovec> iovecs;
     iovecs.resize(iov_len);
     size_t iovs_filled = std::min(frame_payloads.size(), iov_len);
     ASSERT_EQ(iovs_filled,
-              static_cast<size_t>(body_buffer.PeekBody(&iovecs[0], iov_len)));
+              static_cast<size_t>(body_manager.PeekBody(&iovecs[0], iov_len)));
     for (size_t iovec_index = 0; iovec_index < iovs_filled; ++iovec_index) {
       EXPECT_EQ(frame_payloads[iovec_index],
                 QuicStringPiece(
@@ -214,7 +214,7 @@
      {10, 5, 10}},
 };
 
-TEST_F(QuicSpdyStreamBodyBufferTest, ReadBody) {
+TEST_F(QuicSpdyStreamBodyManagerTest, ReadBody) {
   for (size_t test_case_index = 0;
        test_case_index < QUIC_ARRAYSIZE(kReadBodyTestData); ++test_case_index) {
     const std::vector<QuicByteCount>& frame_header_lengths =
@@ -228,18 +228,18 @@
     const std::vector<QuicByteCount>& expected_return_values =
         kReadBodyTestData[test_case_index].expected_return_values;
 
-    QuicSpdyStreamBodyBuffer body_buffer;
+    QuicSpdyStreamBodyManager body_manager;
 
     std::string received_body;
 
     for (size_t frame_index = 0; frame_index < frame_header_lengths.size();
          ++frame_index) {
       // Frame header of first frame can immediately be consumed, but not the
-      // other frames.  Each test case uses a new QuicSpdyStreamBodyBuffer
+      // other frames.  Each test case uses a new QuicSpdyStreamBodyManager
       // instance.
       EXPECT_EQ(frame_index == 0 ? frame_header_lengths[frame_index] : 0u,
-                body_buffer.OnNonBody(frame_header_lengths[frame_index]));
-      body_buffer.OnBody(frame_payloads[frame_index]);
+                body_manager.OnNonBody(frame_header_lengths[frame_index]));
+      body_manager.OnBody(frame_payloads[frame_index]);
       received_body.append(frame_payloads[frame_index]);
     }
 
@@ -265,13 +265,13 @@
       size_t total_bytes_read = expected_total_bytes_read[call_index] + 12;
       EXPECT_EQ(
           expected_return_values[call_index],
-          body_buffer.ReadBody(&iovecs[0], iovecs.size(), &total_bytes_read));
+          body_manager.ReadBody(&iovecs[0], iovecs.size(), &total_bytes_read));
       read_body.append(buffer.substr(0, total_bytes_read));
     }
 
     EXPECT_EQ(received_body.substr(0, read_body.size()), read_body);
     EXPECT_EQ(read_body.size() < received_body.size(),
-              body_buffer.HasBytesToRead());
+              body_manager.HasBytesToRead());
   }
 }