Landing Recent QUIC changes until 10:38 AM, Oct 17, 2016 UTC-4

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 <string>
 
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/core/quic_bug_tracker.h"
@@ skipping 242 matching lines @@
     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;
     }
     return QuicConsumedData(consumed, false);
   }
 
-  QuicConsumedData SaveIovShort(const QuicIOVector& data) {
-    const iovec* iov = data.iov;
-    int consumed = 1;
-    saved_data_.append(static_cast<char*>(iov[0].iov_base), consumed);
-    return QuicConsumedData(consumed, false);
-  }
-
   QuicConsumedData SaveIovAndNotifyAckListener(
       const QuicIOVector& data,
       QuicAckListenerInterface* ack_listener) {
     QuicConsumedData result = SaveIov(data);
     if (ack_listener) {
       ack_listener->OnPacketAcked(result.bytes_consumed,
                                   QuicTime::Delta::Zero());
     }
     return result;
   }
@@ skipping 347 matching lines @@
 
   for (int stream_num = 9; stream_num >= 0; --stream_num) {
     DVLOG(1) << "OnStreamFrame for stream " << stream_num << " offset "
              << stream_frames[stream_num].offset;
     headers_stream_->OnStreamFrame(stream_frames[stream_num]);
     connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
   }
 }
 
 TEST_P(QuicHeadersStreamTest, ProcessLargeRawData) {
+  headers_stream_->set_max_uncompressed_header_bytes(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 (bool fin : {false, true}) {
       for (SpdyPriority priority = 0; priority < 7; ++priority) {
@@ skipping 345 matching lines @@
         // Notice, acked bytes doesn't include extra bytes used by
         // HTTP/2 DATA frame headers.
         EXPECT_EQ(ack_listener->total_acked_bytes(), data_len);
       }
       saved_data_.clear();
       saved_payloads_.clear();
     }
   }
 }
 
-TEST_P(QuicHeadersStreamTest, WritevStreamDataFinOnly) {
-  FLAGS_quic_bugfix_fhol_writev_fin_only_v2 = true;
-  struct iovec iov;
-  string data;
-
-  EXPECT_CALL(session_,
-              WritevData(headers_stream_, kHeadersStreamId, _, _, false, _))
-      .WillOnce(WithArgs<2, 5>(
-          Invoke(this, &QuicHeadersStreamTest::SaveIovAndNotifyAckListener)));
-
-  QuicConsumedData consumed_data = headers_stream_->WritevStreamData(
-      kClientDataStreamId1, MakeIOVector(data, &iov), 0, true, nullptr);
-
-  EXPECT_EQ(consumed_data.bytes_consumed, 0u);
-  EXPECT_EQ(consumed_data.fin_consumed, true);
-}
-
-TEST_P(QuicHeadersStreamTest, WritevStreamDataSendBlocked) {
-  FLAGS_quic_bugfix_fhol_writev_fin_only_v2 = true;
-  QuicStreamId id = kClientDataStreamId1;
-  QuicStreamOffset offset = 0;
-  struct iovec iov;
-  string data;
-
-  // 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;
-  // Set headers stream send window large enough for data written below.
-  headers_stream_->flow_controller()->UpdateSendWindowOffset(data_len * 2 * 4);
-  test::GenerateBody(&data, data_len);
-
-  bool fin = true;
-  // So force the underlying |WritevData| to consume only 1 byte.
-  // In that case, |WritevStreamData| should consume just one
-  // HTTP/2 data frame's worth of data.
-  EXPECT_CALL(session_,
-              WritevData(headers_stream_, kHeadersStreamId, _, _, false, _))
-      .WillOnce(
-          WithArgs<2>(Invoke(this, &QuicHeadersStreamTest::SaveIovShort)));
-
-  QuicConsumedData consumed_data = headers_stream_->WritevStreamData(
-      id, MakeIOVector(data, &iov), offset, fin, nullptr);
-
-  // bytes_consumed is max HTTP/2 data frame size minus the HTTP/2
-  // data header size.
-  EXPECT_EQ(consumed_data.bytes_consumed,
-            kSpdyInitialFrameSizeLimit -
-                SpdyConstants::GetDataFrameMinimumSize(HTTP2));
-  EXPECT_EQ(consumed_data.fin_consumed, false);
-
-  // If session already blocked, then bytes_consumed should be zero.
-  consumed_data = headers_stream_->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