Fix a type casting bug in quic stream sequencer buffer.

net/quic/stream_sequencer_buffer_test.cc

 // Copyright (c) 2015 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/stream_sequencer_buffer.h"
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/rand_util.h"
 #include "net/quic/test_tools/mock_clock.h"
@@ skipping 117 matching lines @@
   std::list<Gap> GetGaps() { return buffer_->gaps_; }
 
   size_t max_buffer_capacity() { return buffer_->max_buffer_capacity_bytes_; }
 
   size_t ReadableBytes() { return buffer_->ReadableBytes(); }
 
   std::map<QuicStreamOffset, FrameInfo>* frame_arrival_time_map() {
     return &(buffer_->frame_arrival_time_map_);
   }
 
+  void set_total_bytes_read(QuicStreamOffset total_bytes_read) {
+    buffer_->total_bytes_read_ = total_bytes_read;
+  }
+
+  void set_gaps(const std::list<Gap>& gaps) { buffer_->gaps_ = gaps; }
+
  private:
   StreamSequencerBuffer* buffer_;
 };
 
 namespace {
 
 class StreamSequencerBufferTest : public testing::Test {
  public:
   void SetUp() override { Initialize(); }
 
@@ skipping 122 matching lines @@
   source = std::string(100, 'b');
   // Write something into [kBlockSizeBytes * 2 - 20, kBlockSizeBytes * 2 + 80).
   EXPECT_EQ(QUIC_NO_ERROR,
             buffer_->OnStreamData(kBlockSizeBytes * 2 - 20, source,
                                   clock_.ApproximateNow(), &written));
   EXPECT_EQ(3, helper_->GapSize());
   EXPECT_EQ(1024u + 100u, buffer_->BytesBuffered());
   EXPECT_TRUE(helper_->CheckBufferInvariants());
 }
 
+TEST_F(StreamSequencerBufferTest, OnStreamDataInLongStreamWithOverlap) {
+  // Assume a stream has already buffered almost 4GB.
+  uint64_t total_bytes_read = pow(2, 32) - 1;
+  helper_->set_total_bytes_read(total_bytes_read);
+  helper_->set_gaps(std::list<Gap>(
+      1, Gap(total_bytes_read, std::numeric_limits<QuicStreamOffset>::max())));
+
+  // Three new out of order frames arrive.
+  const size_t kBytesToWrite = 100;
+  string source(kBytesToWrite, 'a');
+  size_t written;
+  // Frame [2^32 + 500, 2^32 + 600).
+  QuicStreamOffset offset = pow(2, 32) + 500;
+  EXPECT_EQ(
+      QUIC_NO_ERROR,
+      buffer_->OnStreamData(offset, source, clock_.ApproximateNow(), &written));
+  EXPECT_EQ(2, helper_->GapSize());
+
+  // Frame [2^32 + 700, 2^32 + 800).
+  offset = pow(2, 32) + 700;
+  EXPECT_EQ(
+      QUIC_NO_ERROR,
+      buffer_->OnStreamData(offset, source, clock_.ApproximateNow(), &written));
+  EXPECT_EQ(3, helper_->GapSize());
+
+  // Another frame [2^32 + 300, 2^32 + 400).
+  offset = pow(2, 32) + 300;
+  EXPECT_EQ(
+      QUIC_NO_ERROR,
+      buffer_->OnStreamData(offset, source, clock_.ApproximateNow(), &written));
+  EXPECT_EQ(4, helper_->GapSize());
+}
+
 TEST_F(StreamSequencerBufferTest, OnStreamDataTillEnd) {
   // Write 50 bytes to the end.
   const size_t kBytesToWrite = 50;
   std::string source(kBytesToWrite, 'a');
   size_t written;
   EXPECT_EQ(QUIC_NO_ERROR,
             buffer_->OnStreamData(max_capacity_bytes_ - kBytesToWrite, source,
                                   clock_.ApproximateNow(), &written));
   EXPECT_EQ(50u, buffer_->BytesBuffered());
   EXPECT_TRUE(helper_->CheckBufferInvariants());
@@ skipping 682 matching lines @@
   EXPECT_LE(bytes_to_buffer_, total_bytes_read_) << "iterations: "
                                                  << iterations;
   EXPECT_LE(bytes_to_buffer_, total_bytes_written_);
 }
 
 }  // anonymous namespace
 
 }  // namespace test
 
 }  // namespace net