Land Recent QUIC changes.

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/rand_util.h"
@@ skipping 53 matching lines @@
 };
 
 class MockStream : public ReliableQuicStream {
  public:
   MockStream(QuicSession* session, QuicStreamId id)
       : ReliableQuicStream(id, session) {
   }
 
   MOCK_METHOD1(TerminateFromPeer, void(bool half_close));
   MOCK_METHOD2(ProcessData, uint32(const char* data, uint32 data_len));
+  MOCK_METHOD2(ConnectionClose, void(QuicErrorCode error, bool from_peer));
   MOCK_METHOD1(Close, void(QuicRstStreamErrorCode error));
   MOCK_METHOD0(OnCanWrite, void());
 };
 
 namespace {
 
 static const char kPayload[] =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 
 class QuicStreamSequencerTest : public ::testing::Test {
@@ skipping 91 matching lines @@
 
 TEST_F(QuicStreamSequencerTest, FullFrameConsumed) {
   EXPECT_CALL(stream_, ProcessData(StrEq("abc"), 3)).WillOnce(Return(3));
 
   EXPECT_TRUE(sequencer_->OnFrame(0, "abc"));
   EXPECT_EQ(0u, sequencer_->frames()->size());
   EXPECT_EQ(3u, sequencer_->num_bytes_consumed());
 }
 
 TEST_F(QuicStreamSequencerTest, EmptyFrame) {
-  EXPECT_TRUE(sequencer_->OnFrame(0, ""));
+  EXPECT_CALL(stream_, ConnectionClose(QUIC_INVALID_STREAM_FRAME, false));
+  EXPECT_FALSE(sequencer_->OnFrame(0, ""));
   EXPECT_EQ(0u, sequencer_->frames()->size());
   EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
 }
 
 TEST_F(QuicStreamSequencerTest, EmptyFinFrame) {
   EXPECT_CALL(stream_, TerminateFromPeer(true));
   EXPECT_TRUE(sequencer_->OnFinFrame(0, ""));
   EXPECT_EQ(0u, sequencer_->frames()->size());
   EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
 }
@@ skipping 196 matching lines @@
   EXPECT_TRUE(sequencer_->OnFrame(0, "abc"));
   EXPECT_TRUE(sequencer_->OnFrame(9, "jklmnopqrstuvwxyz"));
 
   // Peek into the data.  Only the first chunk should be readable
   // because of the missing data.
   const char* expected[] = {"abc"};
   ASSERT_TRUE(VerifyReadableRegions(expected, arraysize(expected)));
 
   // Now, attempt to mark consumed more data than was readable
   // and expect the stream to be closed.
-  EXPECT_CALL(stream_, Close(QUIC_SERVER_ERROR_PROCESSING_STREAM));
+  EXPECT_CALL(stream_, Close(QUIC_ERROR_PROCESSING_STREAM));
   EXPECT_DFATAL(sequencer_->MarkConsumed(4),
                 "Invalid argument to MarkConsumed.  num_bytes_consumed_: 3 "
                 "end_offset: 4 offset: 9 length: 17");
   */
 }
 
 TEST_F(QuicStreamSequencerTest, MarkConsumedWithMissingPacket) {
   InSequence s;
   EXPECT_CALL(stream_, ProcessData(StrEq("abc"), 3)).WillOnce(Return(0));
 
@@ skipping 152 matching lines @@
 
     if (acked) {
       list_.erase(list_.begin() + index);
     }
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net