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/logging.h"
 #include "base/rand_util.h"
 #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;
 using testing::_;
 using testing::AnyNumber;
 using testing::InSequence;
 using testing::Return;
 using testing::StrEq;
 
 namespace net {
@@ skipping 340 matching lines @@
 
   while (!list_.empty()) {
     int index = OneToN(list_.size()) - 1;
     LOG(ERROR) << "Sending index " << index << " " << list_[index].second;
     EXPECT_TRUE(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