Landing Recent QUIC changes until Sat Apr 29 00:22:04 2017 +0000

net/quic/core/quic_headers_stream_test.cc

 // Copyright 2013 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/core/quic_headers_stream.h"
 
 #include <cstdint>
 #include <ostream>
 #include <string>
 #include <tuple>
@@ skipping 206 matching lines @@
         next_promised_stream_id_(2) {
     headers_[":version"] = "HTTP/1.1";
     headers_[":status"] = "200 Ok";
     headers_["content-length"] = "11";
     framer_ = std::unique_ptr<SpdyFramer>(
         new SpdyFramer(SpdyFramer::ENABLE_COMPRESSION));
     framer_->set_visitor(&visitor_);
     EXPECT_EQ(version(), session_.connection()->version());
     EXPECT_TRUE(headers_stream_ != nullptr);
     connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
+    client_id_1_ =
+        QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, 0);
+    client_id_2_ =
+        QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, 1);
+    client_id_3_ =
+        QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, 2);
+    next_stream_id_ = QuicSpdySessionPeer::NextStreamId(session_);
+  }
+
+  QuicStreamId GetNthClientInitiatedId(int n) {
+    return QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, n);
   }
 
   QuicConsumedData SaveIov(const QuicIOVector& data) {
     const iovec* iov = data.iov;
     int count = data.iov_count;
     int consumed = 0;
     for (int i = 0; i < count; ++i) {
       saved_data_.append(static_cast<char*>(iov[i].iov_base), iov[i].iov_len);
       consumed += iov[i].iov_len;
     }
@@ skipping 117 matching lines @@
   QuicVersionVector GetVersion() {
     QuicVersionVector versions;
     versions.push_back(version());
     return versions;
   }
 
   void TearDownLocalConnectionState() {
     QuicConnectionPeer::TearDownLocalConnectionState(connection_);
   }
 
-  QuicStreamId NextPromisedStreamId() { return next_promised_stream_id_ += 2; }
+  QuicStreamId NextPromisedStreamId() {
+    return next_promised_stream_id_ += next_stream_id_;
+  }
 
   static const bool kFrameComplete = true;
   static const bool kHasPriority = true;
 
   const TestParams test_params_;
   MockQuicConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
   StrictMock<MockQuicConnection>* connection_;
   StrictMock<MockQuicSpdySession> session_;
   QuicHeadersStream* headers_stream_;
   SpdyHeaderBlock headers_;
   std::unique_ptr<TestHeadersHandler> headers_handler_;
   string body_;
   string saved_data_;
   string saved_header_data_;
   string saved_payloads_;
   std::unique_ptr<SpdyFramer> framer_;
   StrictMock<MockVisitor> visitor_;
   QuicStreamFrame stream_frame_;
   QuicStreamId next_promised_stream_id_;
+  QuicStreamId client_id_1_;
+  QuicStreamId client_id_2_;
+  QuicStreamId client_id_3_;
+  QuicStreamId next_stream_id_;
 };
 
 // Run all tests with each version, perspective (client or server),
 // HTTP/2 and HPACK decoder.
 INSTANTIATE_TEST_CASE_P(
     Tests,
     QuicHeadersStreamTest,
     ::testing::Combine(::testing::ValuesIn(AllSupportedVersions()),
                        ::testing::Values(Perspective::IS_CLIENT,
                                          Perspective::IS_SERVER),
                        ::testing::Values(HTTP2_DECODER_SPDY,
                                          HTTP2_DECODER_NEW),
                        ::testing::Values(HPACK_DECODER_SPDY, HPACK_DECODER3)));
 
 TEST_P(QuicHeadersStreamTest, StreamId) {
   EXPECT_EQ(3u, headers_stream_->id());
 }
 
 TEST_P(QuicHeadersStreamTest, WriteHeaders) {
-  for (QuicStreamId stream_id = kClientDataStreamId1;
-       stream_id < kClientDataStreamId3; stream_id += 2) {
+  for (QuicStreamId stream_id = client_id_1_; stream_id < client_id_3_;
+       stream_id += next_stream_id_) {
     for (bool fin : kFins) {
       if (perspective() == Perspective::IS_SERVER) {
         WriteAndExpectResponseHeaders(stream_id, fin);
       } else {
         for (SpdyPriority priority = 0; priority < 7; ++priority) {
           // TODO(rch): implement priorities correctly.
           WriteAndExpectRequestHeaders(stream_id, fin, 0);
         }
       }
     }
   }
 }
 
 TEST_P(QuicHeadersStreamTest, WritePushPromises) {
-  for (QuicStreamId stream_id = kClientDataStreamId1;
-       stream_id < kClientDataStreamId3; stream_id += 2) {
+  for (QuicStreamId stream_id = client_id_1_; stream_id < client_id_3_;
+       stream_id += next_stream_id_) {
     QuicStreamId promised_stream_id = NextPromisedStreamId();
     if (perspective() == Perspective::IS_SERVER) {
       // Write the headers and capture the outgoing data
       EXPECT_CALL(session_, WritevData(headers_stream_, kHeadersStreamId, _, _,
                                        NO_FIN, _))
           .WillOnce(WithArgs<2>(Invoke(this, &QuicHeadersStreamTest::SaveIov)));
       session_.WritePushPromise(stream_id, promised_stream_id,
                                 headers_.Clone());
 
       // Parse the outgoing data and check that it matches was was written.
@@ skipping 10 matching lines @@
       saved_data_.clear();
     } else {
       EXPECT_QUIC_BUG(session_.WritePushPromise(stream_id, promised_stream_id,
                                                 headers_.Clone()),
                       "Client shouldn't send PUSH_PROMISE");
     }
   }
 }
 
 TEST_P(QuicHeadersStreamTest, ProcessRawData) {
-  for (QuicStreamId stream_id = kClientDataStreamId1;
-       stream_id < kClientDataStreamId3; stream_id += 2) {
+  for (QuicStreamId stream_id = client_id_1_; stream_id < client_id_3_;
+       stream_id += next_stream_id_) {
     for (bool fin : {false, true}) {
       for (SpdyPriority priority = 0; priority < 7; ++priority) {
         // Replace with "WriteHeadersAndSaveData"
         SpdySerializedFrame frame;
         if (perspective() == Perspective::IS_SERVER) {
           SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
           headers_frame.set_fin(fin);
           headers_frame.set_has_priority(true);
           headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0));
           frame = framer_->SerializeFrame(headers_frame);
@@ skipping 12 matching lines @@
         stream_frame_.offset += frame.size();
         CheckHeaders();
       }
     }
   }
 }
 
 TEST_P(QuicHeadersStreamTest, ProcessPushPromise) {
   if (perspective() == Perspective::IS_SERVER)
     return;
-  for (QuicStreamId stream_id = kClientDataStreamId1;
-       stream_id < kClientDataStreamId3; stream_id += 2) {
+  for (QuicStreamId stream_id = client_id_1_; stream_id < client_id_3_;
+       stream_id += next_stream_id_) {
     QuicStreamId promised_stream_id = NextPromisedStreamId();
     SpdyPushPromiseIR push_promise(stream_id, promised_stream_id,
                                    headers_.Clone());
     SpdySerializedFrame frame(framer_->SerializeFrame(push_promise));
     if (perspective() == Perspective::IS_SERVER) {
       EXPECT_CALL(*connection_,
                   CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
                                   "PUSH_PROMISE not supported.", _))
           .WillRepeatedly(InvokeWithoutArgs(
               this, &QuicHeadersStreamTest::TearDownLocalConnectionState));
@@ skipping 32 matching lines @@
   headers_stream_->OnStreamFrame(stream_frame_);
   EXPECT_EQ(session_.server_push_enabled(),
             perspective() == Perspective::IS_CLIENT);
 }
 
 TEST_P(QuicHeadersStreamTest, EmptyHeaderHOLBlockedTime) {
   EXPECT_CALL(session_, OnHeadersHeadOfLineBlocking(_)).Times(0);
   InSequence seq;
   bool fin = true;
   for (int stream_num = 0; stream_num < 10; stream_num++) {
-    QuicStreamId stream_id = QuicClientDataStreamId(stream_num);
+    QuicStreamId stream_id = GetNthClientInitiatedId(stream_num);
     // Replace with "WriteHeadersAndSaveData"
     SpdySerializedFrame frame;
     if (perspective() == Perspective::IS_SERVER) {
       SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
       headers_frame.set_fin(fin);
       headers_frame.set_has_priority(true);
       headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0));
       frame = framer_->SerializeFrame(headers_frame);
       EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0));
     } else {
@@ skipping 13 matching lines @@
 
 TEST_P(QuicHeadersStreamTest, NonEmptyHeaderHOLBlockedTime) {
   QuicStreamId stream_id;
   bool fin = true;
   QuicStreamFrame stream_frames[10];
   SpdySerializedFrame frames[10];
   // First create all the frames in order
   {
     InSequence seq;
     for (int stream_num = 0; stream_num < 10; ++stream_num) {
-      stream_id = QuicClientDataStreamId(stream_num);
+      stream_id = GetNthClientInitiatedId(stream_num);
       if (perspective() == Perspective::IS_SERVER) {
         SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
         headers_frame.set_fin(fin);
         headers_frame.set_has_priority(true);
         headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0));
         frames[stream_num] = framer_->SerializeFrame(headers_frame);
         EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0)).Times(1);
       } else {
         SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
         headers_frame.set_fin(fin);
@@ skipping 22 matching lines @@
 }
 
 TEST_P(QuicHeadersStreamTest, ProcessLargeRawData) {
   QuicSpdySessionPeer::SetMaxUncompressedHeaderBytes(&session_, 256 * 1024);
   // We want to create a frame that is more than the SPDY Framer's max control
   // frame size, which is 16K, but less than the HPACK decoders max decode
   // buffer size, which is 32K.
   headers_["key0"] = string(1 << 13, '.');
   headers_["key1"] = string(1 << 13, '.');
   headers_["key2"] = string(1 << 13, '.');
-  for (QuicStreamId stream_id = kClientDataStreamId1;
-       stream_id < kClientDataStreamId3; stream_id += 2) {
+  for (QuicStreamId stream_id = client_id_1_; stream_id < client_id_3_;
+       stream_id += next_stream_id_) {
     for (bool fin : {false, true}) {
       for (SpdyPriority priority = 0; priority < 7; ++priority) {
         // Replace with "WriteHeadersAndSaveData"
         SpdySerializedFrame frame;
         if (perspective() == Perspective::IS_SERVER) {
           SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
           headers_frame.set_fin(fin);
           headers_frame.set_has_priority(true);
           headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0));
           frame = framer_->SerializeFrame(headers_frame);
@@ skipping 209 matching lines @@
     }
   }
   QuicSpdySessionPeer::SetHpackDecoderDebugVisitor(
       &session_, std::move(hpack_decoder_visitor));
 
   // Create some headers we expect to generate entries in HPACK's
   // dynamic table, in addition to content-length.
   headers_["key0"] = string(1 << 1, '.');
   headers_["key1"] = string(1 << 2, '.');
   headers_["key2"] = string(1 << 3, '.');
-  for (QuicStreamId stream_id = kClientDataStreamId1;
-       stream_id < kClientDataStreamId3; stream_id += 2) {
+  for (QuicStreamId stream_id = client_id_1_; stream_id < client_id_3_;
+       stream_id += next_stream_id_) {
     for (bool fin : {false, true}) {
       for (SpdyPriority priority = 0; priority < 7; ++priority) {
         // Replace with "WriteHeadersAndSaveData"
         SpdySerializedFrame frame;
         if (perspective() == Perspective::IS_SERVER) {
           SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
           headers_frame.set_fin(fin);
           headers_frame.set_has_priority(true);
           headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0));
           frame = framer_->SerializeFrame(headers_frame);
@@ skipping 29 matching lines @@
   } else {
     InSequence seq;
     for (int i = 1; i < 28; i++) {
       EXPECT_CALL(*hpack_encoder_visitor,
                   OnUseEntry(QuicTime::Delta::FromMilliseconds(i)));
     }
   }
   QuicSpdySessionPeer::SetHpackEncoderDebugVisitor(
       &session_, std::move(hpack_encoder_visitor));
 
-  for (QuicStreamId stream_id = kClientDataStreamId1;
-       stream_id < kClientDataStreamId3; stream_id += 2) {
+  for (QuicStreamId stream_id = client_id_1_; stream_id < client_id_3_;
+       stream_id += next_stream_id_) {
     for (bool fin : {false, true}) {
       if (perspective() == Perspective::IS_SERVER) {
         WriteAndExpectResponseHeaders(stream_id, fin);
         connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
       } else {
         for (SpdyPriority priority = 0; priority < 7; ++priority) {
           // TODO(rch): implement priorities correctly.
           WriteAndExpectRequestHeaders(stream_id, fin, 0);
           connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
         }
       }
     }
   }
 }
 
 TEST_P(QuicHeadersStreamTest, WritevStreamData) {
-  QuicStreamId id = kClientDataStreamId1;
+  QuicStreamId id = client_id_1_;
   QuicStreamOffset offset = 0;
   struct iovec iov;
 
   // This test will issue a write that will require fragmenting into
   // multiple HTTP/2 DATA frames.
   const int kMinDataFrames = 4;
   const size_t data_len = kSpdyInitialFrameSizeLimit * kMinDataFrames + 1024;
   // Set headers stream send window large enough for data written below.
   headers_stream_->flow_controller()->UpdateSendWindowOffset(data_len * 2 * 4);
   string data(data_len, 'a');
@@ skipping 41 matching lines @@
 TEST_P(QuicHeadersStreamTest, WritevStreamDataFinOnly) {
   struct iovec iov;
   string data;
 
   EXPECT_CALL(session_,
               WritevData(headers_stream_, kHeadersStreamId, _, _, NO_FIN, _))
       .WillOnce(WithArgs<2, 5>(
           Invoke(this, &QuicHeadersStreamTest::SaveIovAndNotifyAckListener)));
 
   QuicConsumedData consumed_data = session_.WritevStreamData(
-      kClientDataStreamId1, MakeIOVector(data, &iov), 0, true, nullptr);
+      client_id_1_, MakeIOVector(data, &iov), 0, true, nullptr);
 
   EXPECT_EQ(consumed_data.bytes_consumed, 0u);
   EXPECT_EQ(consumed_data.fin_consumed, true);
 }
 
 TEST_P(QuicHeadersStreamTest, WritevStreamDataSendBlocked) {
-  QuicStreamId id = kClientDataStreamId1;
+  QuicStreamId id = client_id_1_;
   QuicStreamOffset offset = 0;
   struct iovec iov;
 
   // This test will issue a write that will require fragmenting into
   // multiple HTTP/2 DATA frames.  It will ensure that only 1 frame
   // will go out in the case that the underlying session becomes write
   // blocked.  Buffering is required to preserve framing, but the
   // amount of buffering is limited to one HTTP/2 data frame.
   const int kMinDataFrames = 4;
   const size_t data_len = kSpdyInitialFrameSizeLimit * kMinDataFrames + 1024;
@@ skipping 23 matching lines @@
   consumed_data = session_.WritevStreamData(id, MakeIOVector(data, &iov),
                                             offset, fin, nullptr);
 
   EXPECT_EQ(consumed_data.bytes_consumed, 0u);
   EXPECT_EQ(consumed_data.fin_consumed, false);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net