(minor) rename frames_ to buffered_frames_ in QuicStreamSequencer

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"
@@ skipping 45 matching lines @@
 static const char kPayload[] =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 
 class QuicStreamSequencerTest : public ::testing::Test {
  protected:
   QuicStreamSequencerTest()
       : connection_(new MockConnection(false)),
         session_(connection_),
         stream_(&session_, 1),
         sequencer_(new QuicStreamSequencer(&stream_)),
-        frames_(QuicStreamSequencerPeer::GetFrames(sequencer_.get())) {
+        buffered_frames_(
+            QuicStreamSequencerPeer::GetBufferedFrames(sequencer_.get())) {
   }
 
   bool VerifyReadableRegions(const char** expected, size_t num_expected) {
     iovec iovecs[5];
     size_t num_iovecs = sequencer_->GetReadableRegions(iovecs,
                                                        arraysize(iovecs));
     return VerifyIovecs(iovecs, num_iovecs, expected, num_expected);
   }
 
   bool VerifyIovecs(iovec* iovecs,
@@ skipping 42 matching lines @@
     frame.offset = byte_offset;
     frame.data.Append(const_cast<char*>(data), strlen(data));
     frame.fin = false;
     return sequencer_->OnStreamFrame(frame);
   }
 
   MockConnection* connection_;
   MockSession session_;
   testing::StrictMock<MockStream> stream_;
   scoped_ptr<QuicStreamSequencer> sequencer_;
-  map<QuicStreamOffset, string>* frames_;
+  map<QuicStreamOffset, string>* buffered_frames_;
 };
 
 TEST_F(QuicStreamSequencerTest, RejectOldFrame) {
   EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3));
 
   EXPECT_TRUE(OnFrame(0, "abc"));
-  EXPECT_EQ(0u, frames_->size());
+  EXPECT_EQ(0u, buffered_frames_->size());
   EXPECT_EQ(3u, sequencer_->num_bytes_consumed());
   // Ignore this - it matches a past sequence number and we should not see it
   // again.
   EXPECT_TRUE(OnFrame(0, "def"));
-  EXPECT_EQ(0u, frames_->size());
+  EXPECT_EQ(0u, buffered_frames_->size());
 }
 
 TEST_F(QuicStreamSequencerTest, RejectBufferedFrame) {
   EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3));
 
   EXPECT_TRUE(OnFrame(0, "abc"));
-  EXPECT_EQ(1u, frames_->size());
+  EXPECT_EQ(1u, buffered_frames_->size());
   EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
   // Ignore this - it matches a buffered frame.
   // Right now there's no checking that the payload is consistent.
   EXPECT_TRUE(OnFrame(0, "def"));
-  EXPECT_EQ(1u, frames_->size());
+  EXPECT_EQ(1u, buffered_frames_->size());
 }
 
 TEST_F(QuicStreamSequencerTest, FullFrameConsumed) {
   EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3));
 
   EXPECT_TRUE(OnFrame(0, "abc"));
-  EXPECT_EQ(0u, frames_->size());
+  EXPECT_EQ(0u, buffered_frames_->size());
   EXPECT_EQ(3u, sequencer_->num_bytes_consumed());
 }
 
 TEST_F(QuicStreamSequencerTest, BlockedThenFullFrameConsumed) {
   sequencer_->SetBlockedUntilFlush();
 
   EXPECT_TRUE(OnFrame(0, "abc"));
-  EXPECT_EQ(1u, frames_->size());
+  EXPECT_EQ(1u, buffered_frames_->size());
   EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
 
   EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3));
   sequencer_->FlushBufferedFrames();
-  EXPECT_EQ(0u, frames_->size());
+  EXPECT_EQ(0u, buffered_frames_->size());
   EXPECT_EQ(3u, sequencer_->num_bytes_consumed());
 
   EXPECT_CALL(stream_, ProcessRawData(StrEq("def"), 3)).WillOnce(Return(3));
   EXPECT_CALL(stream_, OnFinRead());
   EXPECT_TRUE(OnFinFrame(3, "def"));
 }
 
 TEST_F(QuicStreamSequencerTest, BlockedThenFullFrameAndFinConsumed) {
   sequencer_->SetBlockedUntilFlush();
 
   EXPECT_TRUE(OnFinFrame(0, "abc"));
-  EXPECT_EQ(1u, frames_->size());
+  EXPECT_EQ(1u, buffered_frames_->size());
   EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
 
   EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3));
   EXPECT_CALL(stream_, OnFinRead());
   sequencer_->FlushBufferedFrames();
-  EXPECT_EQ(0u, frames_->size());
+  EXPECT_EQ(0u, buffered_frames_->size());
   EXPECT_EQ(3u, sequencer_->num_bytes_consumed());
 }
 
 TEST_F(QuicStreamSequencerTest, EmptyFrame) {
   EXPECT_CALL(stream_,
               CloseConnectionWithDetails(QUIC_INVALID_STREAM_FRAME, _));
   EXPECT_FALSE(OnFrame(0, ""));
-  EXPECT_EQ(0u, frames_->size());
+  EXPECT_EQ(0u, buffered_frames_->size());
   EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
 }
 
 TEST_F(QuicStreamSequencerTest, EmptyFinFrame) {
   EXPECT_CALL(stream_, OnFinRead());
   EXPECT_TRUE(OnFinFrame(0, ""));
-  EXPECT_EQ(0u, frames_->size());
+  EXPECT_EQ(0u, buffered_frames_->size());
   EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
 }
 
 TEST_F(QuicStreamSequencerTest, PartialFrameConsumed) {
   EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(2));
 
   EXPECT_TRUE(OnFrame(0, "abc"));
-  EXPECT_EQ(1u, frames_->size());
+  EXPECT_EQ(1u, buffered_frames_->size());
   EXPECT_EQ(2u, sequencer_->num_bytes_consumed());
-  EXPECT_EQ("c", frames_->find(2)->second);
+  EXPECT_EQ("c", buffered_frames_->find(2)->second);
 }
 
 TEST_F(QuicStreamSequencerTest, NextxFrameNotConsumed) {
   EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(0));
 
   EXPECT_TRUE(OnFrame(0, "abc"));
-  EXPECT_EQ(1u, frames_->size());
+  EXPECT_EQ(1u, buffered_frames_->size());
   EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
-  EXPECT_EQ("abc", frames_->find(0)->second);
+  EXPECT_EQ("abc", buffered_frames_->find(0)->second);
 }
 
 TEST_F(QuicStreamSequencerTest, FutureFrameNotProcessed) {
   EXPECT_TRUE(OnFrame(3, "abc"));
-  EXPECT_EQ(1u, frames_->size());
+  EXPECT_EQ(1u, buffered_frames_->size());
   EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
-  EXPECT_EQ("abc", frames_->find(3)->second);
+  EXPECT_EQ("abc", buffered_frames_->find(3)->second);
 }
 
 TEST_F(QuicStreamSequencerTest, OutOfOrderFrameProcessed) {
   // Buffer the first
   EXPECT_TRUE(OnFrame(6, "ghi"));
-  EXPECT_EQ(1u, frames_->size());
+  EXPECT_EQ(1u, buffered_frames_->size());
   EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
   EXPECT_EQ(3u, sequencer_->num_bytes_buffered());
   // Buffer the second
   EXPECT_TRUE(OnFrame(3, "def"));
-  EXPECT_EQ(2u, frames_->size());
+  EXPECT_EQ(2u, buffered_frames_->size());
   EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
   EXPECT_EQ(6u, sequencer_->num_bytes_buffered());
 
   InSequence s;
   EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3));
   EXPECT_CALL(stream_, ProcessRawData(StrEq("def"), 3)).WillOnce(Return(3));
   EXPECT_CALL(stream_, ProcessRawData(StrEq("ghi"), 3)).WillOnce(Return(3));
 
   // Ack right away
   EXPECT_TRUE(OnFrame(0, "abc"));
   EXPECT_EQ(9u, sequencer_->num_bytes_consumed());
   EXPECT_EQ(0u, sequencer_->num_bytes_buffered());
 
-  EXPECT_EQ(0u, frames_->size());
+  EXPECT_EQ(0u, buffered_frames_->size());
 }
 
 TEST_F(QuicStreamSequencerTest, BasicHalfCloseOrdered) {
   InSequence s;
 
   EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3));
   EXPECT_CALL(stream_, OnFinRead());
   EXPECT_TRUE(OnFinFrame(0, "abc"));
 
   EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
@@ skipping 106 matching lines @@
     LOG(ERROR) << "Sending index " << index << " " << list_[index].second;
     EXPECT_TRUE(OnFrame(list_[index].first, list_[index].second.data()));
 
     list_.erase(list_.begin() + index);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net