Introduces QuicStreamSequencerBufferInterface with one implementation. Refactor, no behavior change.

net/quic/quic_stream_sequencer_test.cc

 // Copyright (c) 2012 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 "net/quic/quic_stream_sequencer.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "net/base/ip_endpoint.h"
+#include "net/quic/quic_frame_list.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/reliable_quic_stream.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/quic_stream_sequencer_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 13 matching lines @@
 namespace net {
 namespace test {
 
 class MockStream : public ReliableQuicStream {
  public:
   MockStream(QuicSession* session, QuicStreamId id)
       : ReliableQuicStream(id, session) {}
 
   MOCK_METHOD0(OnFinRead, void());
   MOCK_METHOD0(OnDataAvailable, void());
-  MOCK_METHOD2(CloseConnectionWithDetails, void(QuicErrorCode error,
-                                                const string& details));
+  MOCK_METHOD2(CloseConnectionWithDetails,
+               void(QuicErrorCode error, const string& details));
   MOCK_METHOD1(Reset, void(QuicRstStreamErrorCode error));
   MOCK_METHOD0(OnCanWrite, void());
   QuicPriority EffectivePriority() const override {
     return QuicUtils::HighestPriority();
   }
   virtual bool IsFlowControlEnabled() const { return true; }
 };
 
 namespace {
 
@@ skipping 13 matching lines @@
 
  protected:
   QuicStreamSequencerTest()
       : connection_(new MockConnection(&helper_, Perspective::IS_CLIENT)),
         session_(connection_),
         stream_(&session_, 1),
         sequencer_(new QuicStreamSequencer(&stream_, &clock_)) {}
 
   bool VerifyReadableRegion(const char** expected) {
     iovec iovecs[1];
-    if (sequencer_->GetReadableRegion(iovecs, nullptr)) {
+    QuicTime timestamp = clock_.ApproximateNow();
+    if (sequencer_->GetReadableRegion(iovecs, &timestamp)) {
       return (VerifyIovecs(iovecs, 1, expected, 1));
     }
     return false;
   }
 
   bool VerifyReadableRegions(const char** expected, size_t num_expected) {
     iovec iovecs[5];
     size_t num_iovecs =
         sequencer_->GetReadableRegions(iovecs, arraysize(iovecs));
     return VerifyReadableRegion(expected) &&
@@ skipping 12 matching lines @@
     for (size_t i = 0; i < num_expected; ++i) {
       if (!VerifyIovec(iovecs[i], expected[i])) {
         return false;
       }
     }
     return true;
   }
 
   bool VerifyIovec(const iovec& iovec, StringPiece expected) {
     if (iovec.iov_len != expected.length()) {
-      LOG(ERROR) << "Invalid length: " << iovec.iov_len
-                 << " vs " << expected.length();
+      LOG(ERROR) << "Invalid length: " << iovec.iov_len << " vs "
+                 << expected.length();
       return false;
     }
     if (memcmp(iovec.iov_base, expected.data(), expected.length()) != 0) {
       LOG(ERROR) << "Invalid data: " << static_cast<char*>(iovec.iov_base)
                  << " vs " << expected;
       return false;
     }
     return true;
   }
 
   void OnFinFrame(QuicStreamOffset byte_offset, const char* data) {
     QuicStreamFrame frame;
     frame.stream_id = 1;
     frame.offset = byte_offset;
     frame.data = StringPiece(data);
     frame.fin = true;
     sequencer_->OnStreamFrame(frame);
   }
 
   void OnFrame(QuicStreamOffset byte_offset, const char* data) {
     QuicStreamFrame frame;
     frame.stream_id = 1;
     frame.offset = byte_offset;
     frame.data = StringPiece(data);
     frame.fin = false;
     sequencer_->OnStreamFrame(frame);
   }
 
-  size_t NumBufferedFrames() {
-    return QuicStreamSequencerPeer::GetNumBufferedFrames(sequencer_.get());
-  }
-
-  bool FrameOverlapsBufferedData(const QuicStreamFrame& frame) {
-    return QuicStreamSequencerPeer::FrameOverlapsBufferedData(sequencer_.get(),
-                                                              frame);
+  size_t NumBufferedBytes() {
+    return QuicStreamSequencerPeer::GetNumBufferedBytes(sequencer_.get());
   }
 
   MockHelper helper_;
   MockConnection* connection_;
   MockClock clock_;
   MockQuicSpdySession session_;
   testing::StrictMock<MockStream> stream_;
   scoped_ptr<QuicStreamSequencer> sequencer_;
 };
 
 // TODO(rch): reorder these tests so they build on each other.
 
 TEST_F(QuicStreamSequencerTest, RejectOldFrame) {
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
           CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 3)));
 
   OnFrame(0, "abc");
 
-  EXPECT_EQ(0u, NumBufferedFrames());
-  EXPECT_EQ(3u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(0u, NumBufferedBytes());
+  EXPECT_EQ(3u, sequencer_->NumBytesConsumed());
   EXPECT_EQ(3u, stream_.flow_controller()->bytes_consumed());
   // Ignore this - it matches a past packet number and we should not see it
   // again.
   OnFrame(0, "def");
-  EXPECT_EQ(0u, NumBufferedFrames());
+  EXPECT_EQ(0u, NumBufferedBytes());
 }
 
 TEST_F(QuicStreamSequencerTest, RejectBufferedFrame) {
   EXPECT_CALL(stream_, OnDataAvailable());
 
   OnFrame(0, "abc");
-  EXPECT_EQ(1u, NumBufferedFrames());
-  EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(3u, NumBufferedBytes());
+  EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
 
   // Ignore this - it matches a buffered frame.
   // Right now there's no checking that the payload is consistent.
   OnFrame(0, "def");
-  EXPECT_EQ(1u, NumBufferedFrames());
+  EXPECT_EQ(3u, NumBufferedBytes());
 }
 
 TEST_F(QuicStreamSequencerTest, FullFrameConsumed) {
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
           CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 3)));
 
   OnFrame(0, "abc");
-  EXPECT_EQ(0u, NumBufferedFrames());
-  EXPECT_EQ(3u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(0u, NumBufferedBytes());
+  EXPECT_EQ(3u, sequencer_->NumBytesConsumed());
 }
 
 TEST_F(QuicStreamSequencerTest, BlockedThenFullFrameConsumed) {
   sequencer_->SetBlockedUntilFlush();
 
   OnFrame(0, "abc");
-  EXPECT_EQ(1u, NumBufferedFrames());
-  EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(3u, NumBufferedBytes());
+  EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
 
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
           CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 3)));
   sequencer_->SetUnblocked();
-  EXPECT_EQ(0u, NumBufferedFrames());
-  EXPECT_EQ(3u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(0u, NumBufferedBytes());
+  EXPECT_EQ(3u, sequencer_->NumBytesConsumed());
 
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
           CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 3)));
   EXPECT_FALSE(sequencer_->IsClosed());
   OnFinFrame(3, "def");
   EXPECT_TRUE(sequencer_->IsClosed());
 }
 
 TEST_F(QuicStreamSequencerTest, BlockedThenFullFrameAndFinConsumed) {
   sequencer_->SetBlockedUntilFlush();
 
   OnFinFrame(0, "abc");
-  EXPECT_EQ(1u, NumBufferedFrames());
-  EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(3u, NumBufferedBytes());
+  EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
 
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
           CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 3)));
   EXPECT_FALSE(sequencer_->IsClosed());
   sequencer_->SetUnblocked();
   EXPECT_TRUE(sequencer_->IsClosed());
-  EXPECT_EQ(0u, NumBufferedFrames());
-  EXPECT_EQ(3u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(0u, NumBufferedBytes());
+  EXPECT_EQ(3u, sequencer_->NumBytesConsumed());
 }
 
 TEST_F(QuicStreamSequencerTest, EmptyFrame) {
   EXPECT_CALL(stream_,
               CloseConnectionWithDetails(QUIC_INVALID_STREAM_FRAME, _));
   OnFrame(0, "");
-  EXPECT_EQ(0u, NumBufferedFrames());
-  EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(0u, NumBufferedBytes());
+  EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
 }
 
 TEST_F(QuicStreamSequencerTest, EmptyFinFrame) {
   EXPECT_CALL(stream_, OnDataAvailable());
   OnFinFrame(0, "");
-  EXPECT_EQ(0u, NumBufferedFrames());
-  EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(0u, NumBufferedBytes());
+  EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
 }
 
 TEST_F(QuicStreamSequencerTest, PartialFrameConsumed) {
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
           CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 2)));
 
   OnFrame(0, "abc");
-  EXPECT_EQ(1u, NumBufferedFrames());
-  EXPECT_EQ(2u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(1u, NumBufferedBytes());
+  EXPECT_EQ(2u, sequencer_->NumBytesConsumed());
 }
 
 TEST_F(QuicStreamSequencerTest, NextxFrameNotConsumed) {
   EXPECT_CALL(stream_, OnDataAvailable());
 
   OnFrame(0, "abc");
-  EXPECT_EQ(1u, NumBufferedFrames());
-  EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(3u, NumBufferedBytes());
+  EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
   EXPECT_EQ(0, sequencer_->num_early_frames_received());
 }
 
 TEST_F(QuicStreamSequencerTest, FutureFrameNotProcessed) {
   OnFrame(3, "abc");
-  EXPECT_EQ(1u, NumBufferedFrames());
-  EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(3u, NumBufferedBytes());
+  EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
   EXPECT_EQ(1, sequencer_->num_early_frames_received());
 }
 
 TEST_F(QuicStreamSequencerTest, OutOfOrderFrameProcessed) {
   // Buffer the first
   OnFrame(6, "ghi");
-  EXPECT_EQ(1u, NumBufferedFrames());
-  EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
-  EXPECT_EQ(3u, sequencer_->num_bytes_buffered());
+  EXPECT_EQ(3u, NumBufferedBytes());
+  EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
+  EXPECT_EQ(3u, sequencer_->NumBytesBuffered());
   // Buffer the second
   OnFrame(3, "def");
-  EXPECT_EQ(2u, NumBufferedFrames());
-  EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
-  EXPECT_EQ(6u, sequencer_->num_bytes_buffered());
+  EXPECT_EQ(6u, NumBufferedBytes());
+  EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
+  EXPECT_EQ(6u, sequencer_->NumBytesBuffered());
 
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
           CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 9)));
 
   // Now process all of them at once.
   OnFrame(0, "abc");
-  EXPECT_EQ(9u, sequencer_->num_bytes_consumed());
-  EXPECT_EQ(0u, sequencer_->num_bytes_buffered());
+  EXPECT_EQ(9u, sequencer_->NumBytesConsumed());
+  EXPECT_EQ(0u, sequencer_->NumBytesBuffered());
 
-  EXPECT_EQ(0u, NumBufferedFrames());
+  EXPECT_EQ(0u, NumBufferedBytes());
 }
 
 TEST_F(QuicStreamSequencerTest, BasicHalfCloseOrdered) {
   InSequence s;
 
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
           CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 3)));
   OnFinFrame(0, "abc");
 
@@ skipping 130 matching lines @@
 
   while (output_.size() != arraysize(kPayload) - 1) {
     if (!list_.empty() && (base::RandUint64() % 2 == 0)) {  // Send data
       int index = OneToN(list_.size()) - 1;
       OnFrame(list_[index].first, list_[index].second.data());
       list_.erase(list_.begin() + index);
     } else {  // Read data
       bool has_bytes = sequencer_->HasBytesToRead();
       iovec peek_iov[20];
       int iovs_peeked = sequencer_->GetReadableRegions(peek_iov, 20);
+      QuicTime timestamp = clock_.ApproximateNow();
       if (has_bytes) {
         ASSERT_LT(0, iovs_peeked);
-        ASSERT_TRUE(sequencer_->GetReadableRegion(peek_iov, nullptr));
+        ASSERT_TRUE(sequencer_->GetReadableRegion(peek_iov, &timestamp));
       } else {
         ASSERT_EQ(0, iovs_peeked);
-        ASSERT_FALSE(sequencer_->GetReadableRegion(peek_iov, nullptr));
+        ASSERT_FALSE(sequencer_->GetReadableRegion(peek_iov, &timestamp));
       }
       int total_bytes_to_peek = arraysize(buffer);
       for (int i = 0; i < iovs_peeked; ++i) {
         int bytes_to_peek = min<int>(peek_iov[i].iov_len, total_bytes_to_peek);
         peeked_.append(static_cast<char*>(peek_iov[i].iov_base), bytes_to_peek);
         total_bytes_to_peek -= bytes_to_peek;
         if (total_bytes_to_peek == 0) {
           break;
         }
       }
       int bytes_read = sequencer_->Readv(iov, 2);
       output_.append(buffer, bytes_read);
       ASSERT_EQ(output_.size(), peeked_.size());
     }
   }
   EXPECT_EQ(string(kPayload), output_);
   EXPECT_EQ(string(kPayload), peeked_);
 }
 
 // Same as above, just using a different method for reading.
 TEST_F(QuicStreamSequencerTest, MarkConsumed) {
   InSequence s;
   EXPECT_CALL(stream_, OnDataAvailable());
 
   OnFrame(0, "abc");
   OnFrame(3, "def");
   OnFrame(6, "ghi");
 
   // abcdefghi buffered.
-  EXPECT_EQ(9u, sequencer_->num_bytes_buffered());
+  EXPECT_EQ(9u, sequencer_->NumBytesBuffered());
 
   // Peek into the data.
   const char* expected[] = {"abc", "def", "ghi"};
   ASSERT_TRUE(VerifyReadableRegions(expected, arraysize(expected)));
 
   // Consume 1 byte.
   sequencer_->MarkConsumed(1);
   EXPECT_EQ(1u, stream_.flow_controller()->bytes_consumed());
   // Verify data.
   const char* expected2[] = {"bc", "def", "ghi"};
   ASSERT_TRUE(VerifyReadableRegions(expected2, arraysize(expected2)));
-  EXPECT_EQ(8u, sequencer_->num_bytes_buffered());
+  EXPECT_EQ(8u, sequencer_->NumBytesBuffered());
 
   // Consume 2 bytes.
   sequencer_->MarkConsumed(2);
   EXPECT_EQ(3u, stream_.flow_controller()->bytes_consumed());
   // Verify data.
   const char* expected3[] = {"def", "ghi"};
   ASSERT_TRUE(VerifyReadableRegions(expected3, arraysize(expected3)));
-  EXPECT_EQ(6u, sequencer_->num_bytes_buffered());
+  EXPECT_EQ(6u, sequencer_->NumBytesBuffered());
 
   // Consume 5 bytes.
   sequencer_->MarkConsumed(5);
   EXPECT_EQ(8u, stream_.flow_controller()->bytes_consumed());
   // Verify data.
   const char* expected4[] = {"i"};
   ASSERT_TRUE(VerifyReadableRegions(expected4, arraysize(expected4)));
-  EXPECT_EQ(1u, sequencer_->num_bytes_buffered());
+  EXPECT_EQ(1u, sequencer_->NumBytesBuffered());
 }
 
 TEST_F(QuicStreamSequencerTest, MarkConsumedError) {
   EXPECT_CALL(stream_, OnDataAvailable());
 
   OnFrame(0, "abc");
   OnFrame(9, "jklmnopqrstuvwxyz");
 
   // Peek into the data.  Only the first chunk should be readable because of the
   // missing data.
@@ skipping 16 matching lines @@
   OnFrame(3, "def");
   // Missing packet: 6, ghi.
   OnFrame(9, "jkl");
 
   const char* expected[] = {"abc", "def"};
   ASSERT_TRUE(VerifyReadableRegions(expected, arraysize(expected)));
 
   sequencer_->MarkConsumed(6);
 }
 
-TEST_F(QuicStreamSequencerTest, FrameOverlapsBufferedData) {
+TEST(QuicFrameListTest, FrameOverlapsBufferedData) {
+  QuicFrameList buffer;
+
   // Ensure that FrameOverlapsBufferedData returns appropriate responses when
   // there is existing data buffered.
   const int kBufferedOffset = 10;
   const int kBufferedDataLength = 3;
   const int kNewDataLength = 3;
   string data(kNewDataLength, '.');
 
   // No overlap if no buffered frames.
-  EXPECT_EQ(0u, NumBufferedFrames());
+  EXPECT_EQ(0u, buffer.BytesBuffered());
+  size_t bytes_written;
   // Add a buffered frame.
-  sequencer_->OnStreamFrame(QuicStreamFrame(1, false, kBufferedOffset,
-                                            string(kBufferedDataLength, '.')));
+  buffer.OnStreamData(
+      kBufferedOffset,
+      StringPiece(string(kBufferedDataLength, '.').data(), kBufferedDataLength),
+      QuicTime::Zero(), &bytes_written);
 
   // New byte range partially overlaps with buffered frame, start offset
   // preceding buffered frame.
-  EXPECT_TRUE(FrameOverlapsBufferedData(
-      QuicStreamFrame(1, false, kBufferedOffset - 1, data)));
-  EXPECT_TRUE(FrameOverlapsBufferedData(
+  EXPECT_TRUE(QuicStreamSequencerPeer::FrameOverlapsBufferedData(
+      &buffer, QuicStreamFrame(1, false, kBufferedOffset - 1, data)));
+  EXPECT_TRUE(QuicStreamSequencerPeer::FrameOverlapsBufferedData(
+      &buffer,
       QuicStreamFrame(1, false, kBufferedOffset - kNewDataLength + 1, data)));
 
   // New byte range partially overlaps with buffered frame, start offset inside
   // existing buffered frame.
-  EXPECT_TRUE(FrameOverlapsBufferedData(
-      QuicStreamFrame(1, false, kBufferedOffset + 1, data)));
-  EXPECT_TRUE(FrameOverlapsBufferedData(QuicStreamFrame(
-      1, false, kBufferedOffset + kBufferedDataLength - 1, data)));
+  EXPECT_TRUE(QuicStreamSequencerPeer::FrameOverlapsBufferedData(
+      &buffer, QuicStreamFrame(1, false, kBufferedOffset + 1, data)));
+  EXPECT_TRUE(QuicStreamSequencerPeer::FrameOverlapsBufferedData(
+      &buffer, QuicStreamFrame(
+                   1, false, kBufferedOffset + kBufferedDataLength - 1, data)));
 
-  // New byte range entirely outside of buffered frames, start offset preceeding
-  // buffered frame.
-  EXPECT_FALSE(FrameOverlapsBufferedData(
+  // New byte range entirely outside of buffered frames, start offset
+  // preceeding buffered frame.
+  EXPECT_FALSE(QuicStreamSequencerPeer::FrameOverlapsBufferedData(
+      &buffer,
       QuicStreamFrame(1, false, kBufferedOffset - kNewDataLength, data)));
 
   // New byte range entirely outside of buffered frames, start offset later than
   // buffered frame.
-  EXPECT_FALSE(FrameOverlapsBufferedData(
+  EXPECT_FALSE(QuicStreamSequencerPeer::FrameOverlapsBufferedData(
+      &buffer,
       QuicStreamFrame(1, false, kBufferedOffset + kBufferedDataLength, data)));
 }
 
 TEST_F(QuicStreamSequencerTest, DontAcceptOverlappingFrames) {
   // The peer should never send us non-identical stream frames which contain
   // overlapping byte ranges - if they do, we close the connection.
 
   QuicStreamFrame frame1(kClientDataStreamId1, false, 1, StringPiece("hello"));
   sequencer_->OnStreamFrame(frame1);
 
   QuicStreamFrame frame2(kClientDataStreamId1, false, 2, StringPiece("hello"));
-  EXPECT_TRUE(FrameOverlapsBufferedData(frame2));
   EXPECT_CALL(stream_, CloseConnectionWithDetails(QUIC_INVALID_STREAM_FRAME, _))
       .Times(1);
   sequencer_->OnStreamFrame(frame2);
 }
 
 TEST_F(QuicStreamSequencerTest, InOrderTimestamps) {
   // This test verifies that timestamps returned by
   // GetReadableRegion() are in the correct sequence when frames
   // arrive at the sequencer in order.
   EXPECT_CALL(stream_, OnDataAvailable());
 
   clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
 
   // Buffer the first frame.
   clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
   QuicTime t1 = clock_.ApproximateNow();
   OnFrame(0, "abc");
-  EXPECT_EQ(1u, NumBufferedFrames());
-  EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
-  EXPECT_EQ(3u, sequencer_->num_bytes_buffered());
+  EXPECT_EQ(3u, NumBufferedBytes());
+  EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
+  EXPECT_EQ(3u, sequencer_->NumBytesBuffered());
   // Buffer the second frame.
   QuicTime t2 = clock_.ApproximateNow();
   OnFrame(3, "def");
   clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
-  EXPECT_EQ(2u, NumBufferedFrames());
-  EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
-  EXPECT_EQ(6u, sequencer_->num_bytes_buffered());
+  EXPECT_EQ(6u, NumBufferedBytes());
+  EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
+  EXPECT_EQ(6u, sequencer_->NumBytesBuffered());
 
   iovec iovecs[1];
   QuicTime timestamp(QuicTime::Zero());
 
   EXPECT_TRUE(sequencer_->GetReadableRegion(iovecs, &timestamp));
   EXPECT_EQ(timestamp, t1);
   QuicStreamSequencerTest::ConsumeData(3);
-  EXPECT_EQ(1u, NumBufferedFrames());
-  EXPECT_EQ(3u, sequencer_->num_bytes_consumed());
-  EXPECT_EQ(3u, sequencer_->num_bytes_buffered());
+  EXPECT_EQ(3u, NumBufferedBytes());
+  EXPECT_EQ(3u, sequencer_->NumBytesConsumed());
+  EXPECT_EQ(3u, sequencer_->NumBytesBuffered());
 
   EXPECT_TRUE(sequencer_->GetReadableRegion(iovecs, &timestamp));
   EXPECT_EQ(timestamp, t2);
   QuicStreamSequencerTest::ConsumeData(3);
-  EXPECT_EQ(0u, NumBufferedFrames());
-  EXPECT_EQ(6u, sequencer_->num_bytes_consumed());
-  EXPECT_EQ(0u, sequencer_->num_bytes_buffered());
+  EXPECT_EQ(0u, NumBufferedBytes());
+  EXPECT_EQ(6u, sequencer_->NumBytesConsumed());
+  EXPECT_EQ(0u, sequencer_->NumBytesBuffered());
 }
 
 TEST_F(QuicStreamSequencerTest, OutOfOrderTimestamps) {
   // This test verifies that timestamps returned by
   // GetReadableRegion() are in the correct sequence when frames
   // arrive at the sequencer out of order.
   EXPECT_CALL(stream_, OnDataAvailable());
 
   clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
 
   // Buffer the first frame
   clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
   QuicTime t1 = clock_.ApproximateNow();
   OnFrame(3, "def");
-  EXPECT_EQ(1u, NumBufferedFrames());
-  EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
-  EXPECT_EQ(3u, sequencer_->num_bytes_buffered());
+  EXPECT_EQ(3u, NumBufferedBytes());
+  EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
+  EXPECT_EQ(3u, sequencer_->NumBytesBuffered());
   // Buffer the second frame
   QuicTime t2 = clock_.ApproximateNow();
   OnFrame(0, "abc");
   clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
-  EXPECT_EQ(2u, NumBufferedFrames());
-  EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
-  EXPECT_EQ(6u, sequencer_->num_bytes_buffered());
+  EXPECT_EQ(6u, NumBufferedBytes());
+  EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
+  EXPECT_EQ(6u, sequencer_->NumBytesBuffered());
 
   iovec iovecs[1];
   QuicTime timestamp(QuicTime::Zero());
 
   EXPECT_TRUE(sequencer_->GetReadableRegion(iovecs, &timestamp));
   EXPECT_EQ(timestamp, t2);
   QuicStreamSequencerTest::ConsumeData(3);
-  EXPECT_EQ(1u, NumBufferedFrames());
-  EXPECT_EQ(3u, sequencer_->num_bytes_consumed());
-  EXPECT_EQ(3u, sequencer_->num_bytes_buffered());
+  EXPECT_EQ(3u, NumBufferedBytes());
+  EXPECT_EQ(3u, sequencer_->NumBytesConsumed());
+  EXPECT_EQ(3u, sequencer_->NumBytesBuffered());
 
   EXPECT_TRUE(sequencer_->GetReadableRegion(iovecs, &timestamp));
   EXPECT_EQ(timestamp, t1);
   QuicStreamSequencerTest::ConsumeData(3);
-  EXPECT_EQ(0u, NumBufferedFrames());
-  EXPECT_EQ(6u, sequencer_->num_bytes_consumed());
-  EXPECT_EQ(0u, sequencer_->num_bytes_buffered());
+  EXPECT_EQ(0u, NumBufferedBytes());
+  EXPECT_EQ(6u, sequencer_->NumBytesConsumed());
+  EXPECT_EQ(0u, sequencer_->NumBytesBuffered());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net