relnote: Convert the map into a list in QuicStreamSequencer.

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"
@@ skipping 341 matching lines @@
   int OneToN(int n) {
     return base::RandInt(1, n);
   }
 
   int MaybeProcessMaybeBuffer(const char* data, uint32 len) {
     int to_process = len;
     if (base::RandUint64() % 2 != 0) {
       to_process = base::RandInt(0, len);
     }
     output_.append(data, to_process);
+    peeked_.append(data, to_process);
     return to_process;
   }
 
   string output_;
+  // Data which peek at using GetReadableRegion if we back up.
+  string peeked_;
   FrameList list_;
 };
 
 // All frames are processed as soon as we have sequential data.
 // Infinite buffering, so all frames are acked right away.
 TEST_F(QuicSequencerRandomTest, RandomFramesNoDroppingNoBackup) {
   InSequence s;
   for (size_t i = 0; i < list_.size(); ++i) {
     string* data = &list_[i].second;
     EXPECT_CALL(stream_, ProcessRawData(StrEq(*data), data->size()))
         .WillOnce(Return(data->size()));
   }
 
   while (!list_.empty()) {
     int index = OneToN(list_.size()) - 1;
     LOG(ERROR) << "Sending index " << index << " " << list_[index].second;
     OnFrame(list_[index].first, list_[index].second.data());
 
     list_.erase(list_.begin() + index);
   }
 }
 
+TEST_F(QuicSequencerRandomTest, RandomFramesNoDroppingBackup) {

[ramant (doing other things), 2015/07/17 01:27:45]

Hi Ryan,
  While porting this CL, found this test missing in the chromium code base. Thus
added this (though it is not part of this CL's merge). Used
chromium's RandUint64.

thanks
raman

+  char buffer[10];
+  iovec iov[2];
+  iov[0].iov_base = &buffer[0];
+  iov[0].iov_len = 5;
+  iov[1].iov_base = &buffer[5];
+  iov[1].iov_len = 5;
+
+  EXPECT_CALL(stream_, ProcessRawData(_, _))
+      .Times(AnyNumber())
+      .WillRepeatedly(
+          Invoke(this, &QuicSequencerRandomTest::MaybeProcessMaybeBuffer));
+
+  while (output_.size() != arraysize(kPayload) - 1) {
+    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);
+      } else {
+        ASSERT_EQ(0, iovs_peeked);
+      }
+      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;
+        }
+      }
+      int bytes_read = sequencer_->Readv(iov, 2);
+      output_.append(buffer, bytes_read);
+      ASSERT_EQ(output_.size(), peeked_.size());
+    }
+  }
+  EXPECT_EQ(0, strcmp(kPayload, output_.data()));
+  EXPECT_EQ(0, strcmp(kPayload, peeked_.data()));
+}
+
 // Same as above, just using a different method for reading.
 TEST_F(QuicStreamSequencerTest, MarkConsumed) {
   InSequence s;
   EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(0));
 
   OnFrame(0, "abc");
   OnFrame(3, "def");
   OnFrame(6, "ghi");
 
   // abcdefghi buffered.
@@ skipping 108 matching lines @@
   QuicStreamFrame frame2(kClientDataStreamId1, false, 2, StringPiece("hello"));
   EXPECT_TRUE(FrameOverlapsBufferedData(frame2));
   EXPECT_CALL(stream_, CloseConnectionWithDetails(QUIC_INVALID_STREAM_FRAME, _))
       .Times(1);
   sequencer_->OnStreamFrame(frame2);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net