Land Recent QUIC Changes.

net/quic/quic_stream_sequencer_test.cc

Index: net/quic/quic_stream_sequencer_test.cc
diff --git a/net/quic/quic_stream_sequencer_test.cc b/net/quic/quic_stream_sequencer_test.cc
index 4abd94bd190ba7b3f904f18c06c5e1bdcfbf823c..0b7d8fe45e79550ae9c3a0fd0223fce5e4806f98 100644
--- a/net/quic/quic_stream_sequencer_test.cc
+++ b/net/quic/quic_stream_sequencer_test.cc
@@ -12,6 +12,7 @@
 #include "net/base/ip_endpoint.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/reliable_quic_stream.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"
@@ -30,35 +31,6 @@ using testing::StrEq;
 namespace net {
 namespace test {
 
-class QuicStreamSequencerPeer : public QuicStreamSequencer {
- public:
-  explicit QuicStreamSequencerPeer(ReliableQuicStream* stream)
-      : QuicStreamSequencer(stream) {
-  }
-
-  virtual bool OnFinFrame(QuicStreamOffset byte_offset, const char* data) {
-    QuicStreamFrame frame;
-    frame.stream_id = 1;
-    frame.offset = byte_offset;
-    frame.data.Append(const_cast<char*>(data), strlen(data));
-    frame.fin = true;
-    return OnStreamFrame(frame);
-  }
-
-  virtual bool OnFrame(QuicStreamOffset byte_offset, const char* data) {
-    QuicStreamFrame frame;
-    frame.stream_id = 1;
-    frame.offset = byte_offset;
-    frame.data.Append(const_cast<char*>(data), strlen(data));
-    frame.fin = false;
-    return OnStreamFrame(frame);
-  }
-
-  uint64 num_bytes_consumed() const { return num_bytes_consumed_; }
-  const FrameMap* frames() const { return &frames_; }
-  QuicStreamOffset close_offset() const { return close_offset_; }
-};
-
 class MockStream : public ReliableQuicStream {
  public:
   MockStream(QuicSession* session, QuicStreamId id)
@@ -71,7 +43,7 @@ class MockStream : public ReliableQuicStream {
                                                 const string& details));
   MOCK_METHOD1(Reset, void(QuicRstStreamErrorCode error));
   MOCK_METHOD0(OnCanWrite, void());
-  virtual QuicPriority EffectivePriority() const {
+  virtual QuicPriority EffectivePriority() const OVERRIDE {
     return QuicUtils::HighestPriority();
   }
   virtual bool IsFlowControlEnabled() const {
@@ -90,7 +62,9 @@ class QuicStreamSequencerTest : public ::testing::Test {
       : connection_(new MockConnection(false)),
         session_(connection_),
         stream_(&session_, 1),
-        sequencer_(new QuicStreamSequencerPeer(&stream_)) {
+        sequencer_(new QuicStreamSequencer(&stream_)),
+        buffered_frames_(
+            QuicStreamSequencerPeer::GetBufferedFrames(sequencer_.get())) {
   }
 
   bool VerifyReadableRegions(const char** expected, size_t num_expected) {
@@ -131,125 +105,143 @@ class QuicStreamSequencerTest : public ::testing::Test {
     return true;
   }
 
+  bool OnFinFrame(QuicStreamOffset byte_offset, const char* data) {
+    QuicStreamFrame frame;
+    frame.stream_id = 1;
+    frame.offset = byte_offset;
+    frame.data.Append(const_cast<char*>(data), strlen(data));
+    frame.fin = true;
+    return sequencer_->OnStreamFrame(frame);
+  }
+
+  bool OnFrame(QuicStreamOffset byte_offset, const char* data) {
+    QuicStreamFrame frame;
+    frame.stream_id = 1;
+    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<QuicStreamSequencerPeer> sequencer_;
+  scoped_ptr<QuicStreamSequencer> sequencer_;
+  map<QuicStreamOffset, string>* buffered_frames_;
 };
 
 TEST_F(QuicStreamSequencerTest, RejectOldFrame) {
-  EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3))
-      .WillOnce(Return(3));
+  EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3));
 
-  EXPECT_TRUE(sequencer_->OnFrame(0, "abc"));
-  EXPECT_EQ(0u, sequencer_->frames()->size());
+  EXPECT_TRUE(OnFrame(0, "abc"));
+  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(sequencer_->OnFrame(0, "def"));
-  EXPECT_EQ(0u, sequencer_->frames()->size());
+  EXPECT_TRUE(OnFrame(0, "def"));
+  EXPECT_EQ(0u, buffered_frames_->size());
 }
 
 TEST_F(QuicStreamSequencerTest, RejectBufferedFrame) {
   EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3));
 
-  EXPECT_TRUE(sequencer_->OnFrame(0, "abc"));
-  EXPECT_EQ(1u, sequencer_->frames()->size());
+  EXPECT_TRUE(OnFrame(0, "abc"));
+  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(sequencer_->OnFrame(0, "def"));
-  EXPECT_EQ(1u, sequencer_->frames()->size());
+  EXPECT_TRUE(OnFrame(0, "def"));
+  EXPECT_EQ(1u, buffered_frames_->size());
 }
 
 TEST_F(QuicStreamSequencerTest, FullFrameConsumed) {
   EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3));
 
-  EXPECT_TRUE(sequencer_->OnFrame(0, "abc"));
-  EXPECT_EQ(0u, sequencer_->frames()->size());
+  EXPECT_TRUE(OnFrame(0, "abc"));
+  EXPECT_EQ(0u, buffered_frames_->size());
   EXPECT_EQ(3u, sequencer_->num_bytes_consumed());
 }
 
 TEST_F(QuicStreamSequencerTest, BlockedThenFullFrameConsumed) {
   sequencer_->SetBlockedUntilFlush();
 
-  EXPECT_TRUE(sequencer_->OnFrame(0, "abc"));
-  EXPECT_EQ(1u, sequencer_->frames()->size());
+  EXPECT_TRUE(OnFrame(0, "abc"));
+  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, sequencer_->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(sequencer_->OnFinFrame(3, "def"));
+  EXPECT_TRUE(OnFinFrame(3, "def"));
 }
 
 TEST_F(QuicStreamSequencerTest, BlockedThenFullFrameAndFinConsumed) {
   sequencer_->SetBlockedUntilFlush();
 
-  EXPECT_TRUE(sequencer_->OnFinFrame(0, "abc"));
-  EXPECT_EQ(1u, sequencer_->frames()->size());
+  EXPECT_TRUE(OnFinFrame(0, "abc"));
+  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, sequencer_->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(sequencer_->OnFrame(0, ""));
-  EXPECT_EQ(0u, sequencer_->frames()->size());
+  EXPECT_FALSE(OnFrame(0, ""));
+  EXPECT_EQ(0u, buffered_frames_->size());
   EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
 }
 
 TEST_F(QuicStreamSequencerTest, EmptyFinFrame) {
   EXPECT_CALL(stream_, OnFinRead());
-  EXPECT_TRUE(sequencer_->OnFinFrame(0, ""));
-  EXPECT_EQ(0u, sequencer_->frames()->size());
+  EXPECT_TRUE(OnFinFrame(0, ""));
+  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(sequencer_->OnFrame(0, "abc"));
-  EXPECT_EQ(1u, sequencer_->frames()->size());
+  EXPECT_TRUE(OnFrame(0, "abc"));
+  EXPECT_EQ(1u, buffered_frames_->size());
   EXPECT_EQ(2u, sequencer_->num_bytes_consumed());
-  EXPECT_EQ("c", sequencer_->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(sequencer_->OnFrame(0, "abc"));
-  EXPECT_EQ(1u, sequencer_->frames()->size());
+  EXPECT_TRUE(OnFrame(0, "abc"));
+  EXPECT_EQ(1u, buffered_frames_->size());
   EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
-  EXPECT_EQ("abc", sequencer_->frames()->find(0)->second);
+  EXPECT_EQ("abc", buffered_frames_->find(0)->second);
 }
 
 TEST_F(QuicStreamSequencerTest, FutureFrameNotProcessed) {
-  EXPECT_TRUE(sequencer_->OnFrame(3, "abc"));
-  EXPECT_EQ(1u, sequencer_->frames()->size());
+  EXPECT_TRUE(OnFrame(3, "abc"));
+  EXPECT_EQ(1u, buffered_frames_->size());
   EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
-  EXPECT_EQ("abc", sequencer_->frames()->find(3)->second);
+  EXPECT_EQ("abc", buffered_frames_->find(3)->second);
 }
 
 TEST_F(QuicStreamSequencerTest, OutOfOrderFrameProcessed) {
   // Buffer the first
-  EXPECT_TRUE(sequencer_->OnFrame(6, "ghi"));
-  EXPECT_EQ(1u, sequencer_->frames()->size());
+  EXPECT_TRUE(OnFrame(6, "ghi"));
+  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(sequencer_->OnFrame(3, "def"));
-  EXPECT_EQ(2u, sequencer_->frames()->size());
+  EXPECT_TRUE(OnFrame(3, "def"));
+  EXPECT_EQ(2u, buffered_frames_->size());
   EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
   EXPECT_EQ(6u, sequencer_->num_bytes_buffered());
 
@@ -259,77 +251,76 @@ TEST_F(QuicStreamSequencerTest, OutOfOrderFrameProcessed) {
   EXPECT_CALL(stream_, ProcessRawData(StrEq("ghi"), 3)).WillOnce(Return(3));
 
   // Ack right away
-  EXPECT_TRUE(sequencer_->OnFrame(0, "abc"));
+  EXPECT_TRUE(OnFrame(0, "abc"));
   EXPECT_EQ(9u, sequencer_->num_bytes_consumed());
   EXPECT_EQ(0u, sequencer_->num_bytes_buffered());
 
-  EXPECT_EQ(0u, sequencer_->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(sequencer_->OnFinFrame(0, "abc"));
+  EXPECT_TRUE(OnFinFrame(0, "abc"));
 
-  EXPECT_EQ(3u, sequencer_->close_offset());
+  EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
 }
 
 TEST_F(QuicStreamSequencerTest, BasicHalfCloseUnorderedWithFlush) {
-  sequencer_->OnFinFrame(6, "");
-  EXPECT_EQ(6u, sequencer_->close_offset());
+  OnFinFrame(6, "");
+  EXPECT_EQ(6u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
   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_, OnFinRead());
 
-  EXPECT_TRUE(sequencer_->OnFrame(3, "def"));
-  EXPECT_TRUE(sequencer_->OnFrame(0, "abc"));
+  EXPECT_TRUE(OnFrame(3, "def"));
+  EXPECT_TRUE(OnFrame(0, "abc"));
 }
 
 TEST_F(QuicStreamSequencerTest, BasicHalfUnordered) {
-  sequencer_->OnFinFrame(3, "");
-  EXPECT_EQ(3u, sequencer_->close_offset());
+  OnFinFrame(3, "");
+  EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
   InSequence s;
   EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3));
   EXPECT_CALL(stream_, OnFinRead());
 
-  EXPECT_TRUE(sequencer_->OnFrame(0, "abc"));
+  EXPECT_TRUE(OnFrame(0, "abc"));
 }
 
 TEST_F(QuicStreamSequencerTest, TerminateWithReadv) {
   char buffer[3];
 
-  sequencer_->OnFinFrame(3, "");
-  EXPECT_EQ(3u, sequencer_->close_offset());
+  OnFinFrame(3, "");
+  EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
 
   EXPECT_FALSE(sequencer_->IsClosed());
 
   EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(0));
-  EXPECT_TRUE(sequencer_->OnFrame(0, "abc"));
+  EXPECT_TRUE(OnFrame(0, "abc"));
 
-  iovec iov = { &buffer[0], 3 };
+  iovec iov = {&buffer[0], 3};
   int bytes_read = sequencer_->Readv(&iov, 1);
   EXPECT_EQ(3, bytes_read);
   EXPECT_TRUE(sequencer_->IsClosed());
 }
 
 TEST_F(QuicStreamSequencerTest, MutipleOffsets) {
-  sequencer_->OnFinFrame(3, "");
-  EXPECT_EQ(3u, sequencer_->close_offset());
+  OnFinFrame(3, "");
+  EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
 
   EXPECT_CALL(stream_, Reset(QUIC_MULTIPLE_TERMINATION_OFFSETS));
-  sequencer_->OnFinFrame(5, "");
-  EXPECT_EQ(3u, sequencer_->close_offset());
+  OnFinFrame(5, "");
+  EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
 
   EXPECT_CALL(stream_, Reset(QUIC_MULTIPLE_TERMINATION_OFFSETS));
-  sequencer_->OnFinFrame(1, "");
-  EXPECT_EQ(3u, sequencer_->close_offset());
+  OnFinFrame(1, "");
+  EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
 
-  sequencer_->OnFinFrame(3, "");
-  EXPECT_EQ(3u, sequencer_->close_offset());
+  OnFinFrame(3, "");
+  EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
 }
 
 class QuicSequencerRandomTest : public QuicStreamSequencerTest {
@@ -382,8 +373,7 @@ TEST_F(QuicSequencerRandomTest, RandomFramesNoDroppingNoBackup) {
   while (!list_.empty()) {
     int index = OneToN(list_.size()) - 1;
     LOG(ERROR) << "Sending index " << index << " " << list_[index].second;
-    EXPECT_TRUE(sequencer_->OnFrame(list_[index].first,
-                                    list_[index].second.data()));
+    EXPECT_TRUE(OnFrame(list_[index].first, list_[index].second.data()));
 
     list_.erase(list_.begin() + index);
   }