relnote: Measure HOL blocking in QUIC headers stream. Flag protected by quic_measure_headers_hol_bl…

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/mock_clock.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/gmock_mutant.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
 using std::map;
 using std::min;
@@ skipping 44 matching lines @@
     iov.iov_base = buffer;
     iov.iov_len = num_bytes;
     ASSERT_EQ(static_cast<int>(num_bytes), sequencer_->Readv(&iov, 1));
   }
 
  protected:
   QuicStreamSequencerTest()
       : connection_(new MockConnection(Perspective::IS_CLIENT)),
         session_(connection_),
         stream_(&session_, 1),
-        sequencer_(new QuicStreamSequencer(&stream_)) {}
+        sequencer_(new QuicStreamSequencer(&stream_, &clock_)) {}
+
+  bool VerifyReadableRegion(const char** expected) {
+    iovec iovecs[1];
+    if (sequencer_->GetReadableRegion(iovecs, nullptr)) {
+      return (VerifyIovecs(iovecs, 1, expected, 1));
+    }
+    return false;
+  }
 
   bool VerifyReadableRegions(const char** expected, size_t num_expected) {
     iovec iovecs[5];
     size_t num_iovecs =
         sequencer_->GetReadableRegions(iovecs, arraysize(iovecs));
-    return VerifyIovecs(iovecs, num_iovecs, expected, num_expected);
+    return VerifyReadableRegion(expected) &&
+           VerifyIovecs(iovecs, num_iovecs, expected, num_expected);
   }
 
   bool VerifyIovecs(iovec* iovecs,
                     size_t num_iovecs,
                     const char** expected,
                     size_t num_expected) {
     if (num_expected != num_iovecs) {
       LOG(ERROR) << "Incorrect number of iovecs.  Expected: " << num_expected
                  << " Actual: " << num_iovecs;
       return false;
@@ skipping 41 matching lines @@
   size_t NumBufferedFrames() {
     return QuicStreamSequencerPeer::GetNumBufferedFrames(sequencer_.get());
   }
 
   bool FrameOverlapsBufferedData(const QuicStreamFrame& frame) {
     return QuicStreamSequencerPeer::FrameOverlapsBufferedData(sequencer_.get(),
                                                               frame);
   }
 
   MockConnection* connection_;
+  MockClock clock_;
   MockQuicSpdySession session_;
   testing::StrictMock<MockStream> stream_;
   scoped_ptr<QuicStreamSequencer> sequencer_;
 };
 
 // TODO(rch): reorder these tests so they build on each other.
 
 TEST_F(QuicStreamSequencerTest, RejectOldFrame) {
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
@@ skipping 282 matching lines @@
     if (!list_.empty() && (base::RandUint64() % 2 == 0)) {  // Send data
       int index = OneToN(list_.size()) - 1;
       OnFrame(list_[index].first, list_[index].second.data());
       list_.erase(list_.begin() + index);
     } else {  // Read data
       bool has_bytes = sequencer_->HasBytesToRead();
       iovec peek_iov[20];
       int iovs_peeked = sequencer_->GetReadableRegions(peek_iov, 20);
       if (has_bytes) {
         ASSERT_LT(0, iovs_peeked);
+        ASSERT_TRUE(sequencer_->GetReadableRegion(peek_iov, nullptr));
       } else {
         ASSERT_EQ(0, iovs_peeked);
+        ASSERT_FALSE(sequencer_->GetReadableRegion(peek_iov, nullptr));
       }
       int total_bytes_to_peek = arraysize(buffer);
       for (int i = 0; i < iovs_peeked; ++i) {
         int bytes_to_peek = min<int>(peek_iov[i].iov_len, total_bytes_to_peek);
         peeked_.append(static_cast<char*>(peek_iov[i].iov_base), bytes_to_peek);
         total_bytes_to_peek -= bytes_to_peek;
         if (total_bytes_to_peek == 0) {
           break;
         }
       }
@@ skipping 127 matching lines @@
   QuicStreamFrame frame1(kClientDataStreamId1, false, 1, StringPiece("hello"));
   sequencer_->OnStreamFrame(frame1);
 
   QuicStreamFrame frame2(kClientDataStreamId1, false, 2, StringPiece("hello"));
   EXPECT_TRUE(FrameOverlapsBufferedData(frame2));
   EXPECT_CALL(stream_, CloseConnectionWithDetails(QUIC_INVALID_STREAM_FRAME, _))
       .Times(1);
   sequencer_->OnStreamFrame(frame2);
 }
 
+TEST_F(QuicStreamSequencerTest, InOrderTimestamps) {
+  // This test verifies that timestamps returned by
+  // GetReadableRegion() are in the correct sequence when frames
+  // arrive at the sequencer in order.
+  EXPECT_CALL(stream_, OnDataAvailable());
+
+  clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
+
+  // Buffer the first frame.
+  clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
+  QuicTime t1 = clock_.ApproximateNow();
+  OnFrame(0, "abc");
+  EXPECT_EQ(1u, NumBufferedFrames());
+  EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(3u, sequencer_->num_bytes_buffered());
+  // Buffer the second frame.
+  QuicTime t2 = clock_.ApproximateNow();
+  OnFrame(3, "def");
+  clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
+  EXPECT_EQ(2u, NumBufferedFrames());
+  EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(6u, sequencer_->num_bytes_buffered());
+
+  iovec iovecs[1];
+  QuicTime timestamp(QuicTime::Zero());
+
+  EXPECT_TRUE(sequencer_->GetReadableRegion(iovecs, &timestamp));
+  EXPECT_EQ(timestamp, t1);
+  QuicStreamSequencerTest::ConsumeData(3);
+  EXPECT_EQ(1u, NumBufferedFrames());
+  EXPECT_EQ(3u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(3u, sequencer_->num_bytes_buffered());
+
+  EXPECT_TRUE(sequencer_->GetReadableRegion(iovecs, &timestamp));
+  EXPECT_EQ(timestamp, t2);
+  QuicStreamSequencerTest::ConsumeData(3);
+  EXPECT_EQ(0u, NumBufferedFrames());
+  EXPECT_EQ(6u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(0u, sequencer_->num_bytes_buffered());
+}
+
+TEST_F(QuicStreamSequencerTest, OutOfOrderTimestamps) {
+  // This test verifies that timestamps returned by
+  // GetReadableRegion() are in the correct sequence when frames
+  // arrive at the sequencer out of order.
+  EXPECT_CALL(stream_, OnDataAvailable());
+
+  clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
+
+  // Buffer the first frame
+  clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
+  QuicTime t1 = clock_.ApproximateNow();
+  OnFrame(3, "def");
+  EXPECT_EQ(1u, NumBufferedFrames());
+  EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(3u, sequencer_->num_bytes_buffered());
+  // Buffer the second frame
+  QuicTime t2 = clock_.ApproximateNow();
+  OnFrame(0, "abc");
+  clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
+  EXPECT_EQ(2u, NumBufferedFrames());
+  EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(6u, sequencer_->num_bytes_buffered());
+
+  iovec iovecs[1];
+  QuicTime timestamp(QuicTime::Zero());
+
+  EXPECT_TRUE(sequencer_->GetReadableRegion(iovecs, &timestamp));
+  EXPECT_EQ(timestamp, t2);
+  QuicStreamSequencerTest::ConsumeData(3);
+  EXPECT_EQ(1u, NumBufferedFrames());
+  EXPECT_EQ(3u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(3u, sequencer_->num_bytes_buffered());
+
+  EXPECT_TRUE(sequencer_->GetReadableRegion(iovecs, &timestamp));
+  EXPECT_EQ(timestamp, t1);
+  QuicStreamSequencerTest::ConsumeData(3);
+  EXPECT_EQ(0u, NumBufferedFrames());
+  EXPECT_EQ(6u, sequencer_->num_bytes_consumed());
+  EXPECT_EQ(0u, sequencer_->num_bytes_buffered());
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace net