#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"
#include "testing/gtest/include/gtest/gtest.h"
using base::StringPiece;
+using std::map;
using std::min;
using std::pair;
using std::vector;
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)
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 {
: 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) {
return true;
}
+ void 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;
+ sequencer_->OnStreamFrame(frame);
+ }
+
+ void 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;
+ 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());
+ 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());
+ 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());
+ 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());
+ 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());
+ 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());
+ 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"));
+ OnFinFrame(3, "def");
}
TEST_F(QuicStreamSequencerTest, BlockedThenFullFrameAndFinConsumed) {
sequencer_->SetBlockedUntilFlush();
- EXPECT_TRUE(sequencer_->OnFinFrame(0, "abc"));
- EXPECT_EQ(1u, sequencer_->frames()->size());
+ 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());
+ 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());
+ 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());
+ 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());
+ 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());
+ 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());
+ 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());
+ OnFrame(3, "def");
+ EXPECT_EQ(2u, buffered_frames_->size());
EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
EXPECT_EQ(6u, sequencer_->num_bytes_buffered());
EXPECT_CALL(stream_, ProcessRawData(StrEq("ghi"), 3)).WillOnce(Return(3));
// Ack right away
- EXPECT_TRUE(sequencer_->OnFrame(0, "abc"));
+ 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"));
+ 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"));
+ OnFrame(3, "def");
+ 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"));
+ 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"));
+ 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 {
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()));
+ OnFrame(list_[index].first, list_[index].second.data());
list_.erase(list_.begin() + index);
}
}
+TEST_F(QuicStreamSequencerTest, FrameOverlapsBufferedData) {
+ // Ensure that FrameOverlapsBufferedData returns appropriate responses when
+ // there is existing data buffered.
+
+ map<QuicStreamOffset, string>* buffered_frames =
+ QuicStreamSequencerPeer::GetBufferedFrames(sequencer_.get());
+
+ const int kBufferedOffset = 10;
+ const int kBufferedDataLength = 3;
+ const int kNewDataLength = 3;
+ IOVector data = MakeIOVector(string(kNewDataLength, '.'));
+
+ // No overlap if no buffered frames.
+ EXPECT_TRUE(buffered_frames_->empty());
+ EXPECT_FALSE(sequencer_->FrameOverlapsBufferedData(
+ QuicStreamFrame(1, false, kBufferedOffset - 1, data)));
+
+ // Add a buffered frame.
+ buffered_frames->insert(
+ make_pair(kBufferedOffset, string(kBufferedDataLength, '.')));
+
+ // New byte range partially overlaps with buffered frame, start offset
+ // preceeding buffered frame.
+ EXPECT_TRUE(sequencer_->FrameOverlapsBufferedData(
+ QuicStreamFrame(1, false, kBufferedOffset - 1, data)));
+ EXPECT_TRUE(sequencer_->FrameOverlapsBufferedData(
+ QuicStreamFrame(1, false, kBufferedOffset - kNewDataLength + 1, data)));
+
+ // New byte range partially overlaps with buffered frame, start offset
+ // inside existing buffered frame.
+ EXPECT_TRUE(sequencer_->FrameOverlapsBufferedData(
+ QuicStreamFrame(1, false, kBufferedOffset + 1, data)));
+ EXPECT_TRUE(sequencer_->FrameOverlapsBufferedData(QuicStreamFrame(
+ 1, false, kBufferedOffset + kBufferedDataLength - 1, data)));
+
+ // New byte range entirely outside of buffered frames, start offset preceeding
+ // buffered frame.
+ EXPECT_FALSE(sequencer_->FrameOverlapsBufferedData(
+ QuicStreamFrame(1, false, kBufferedOffset - kNewDataLength, data)));
+
+ // New byte range entirely outside of buffered frames, start offset later than
+ // buffered frame.
+ EXPECT_FALSE(sequencer_->FrameOverlapsBufferedData(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, MakeIOVector("hello"));
+ sequencer_->OnStreamFrame(frame1);
+
+ QuicStreamFrame frame2(kClientDataStreamId1, false, 2, MakeIOVector("hello"));
+ EXPECT_TRUE(sequencer_->FrameOverlapsBufferedData(frame2));
+ EXPECT_CALL(stream_, CloseConnectionWithDetails(QUIC_INVALID_STREAM_FRAME, _))
+ .Times(1);
+ sequencer_->OnStreamFrame(frame2);
+}
+
} // namespace
} // namespace test
} // namespace net
projects / platform / framework / web / crosswalk.git / blobdiff