Landing Recent QUIC changes until Mon Apr 17 2017

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>
 #include <utility>
 
-#include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/core/spdy_utils.h"
 #include "net/quic/platform/api/quic_bug_tracker.h"
+#include "net/quic/platform/api/quic_flags.h"
 #include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/platform/api/quic_ptr_util.h"
 #include "net/quic/platform/api/quic_str_cat.h"
 #include "net/quic/platform/api/quic_string_piece.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/quic/test_tools/quic_stream_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/spdy/spdy_alt_svc_wire_format.h"
 #include "net/spdy/spdy_flags.h"
@@ skipping 283 matching lines @@
   void WriteAndExpectResponseHeaders(QuicStreamId stream_id, bool fin) {
     WriteHeadersAndCheckData(stream_id, fin, 0, false /*is_request*/);
   }
 
   void WriteHeadersAndCheckData(QuicStreamId stream_id,
                                 bool fin,
                                 SpdyPriority priority,
                                 bool is_request) {
     // Write the headers and capture the outgoing data
     EXPECT_CALL(session_,
-                WritevData(headers_stream_, kHeadersStreamId, _, _, false, _))
+                WritevData(headers_stream_, kHeadersStreamId, _, _, NO_FIN, _))
         .WillOnce(WithArgs<2>(Invoke(this, &QuicHeadersStreamTest::SaveIov)));
     QuicSpdySessionPeer::WriteHeadersImpl(
         &session_, stream_id, headers_.Clone(), fin, priority, nullptr);
 
     // Parse the outgoing data and check that it matches was was written.
     if (is_request) {
       EXPECT_CALL(visitor_,
                   OnHeaders(stream_id, kHasPriority,
                             Spdy3PriorityToHttp2Weight(priority),
                             /*parent_stream_id=*/0,
@@ skipping 95 matching lines @@
     }
   }
 }
 
 TEST_P(QuicHeadersStreamTest, WritePushPromises) {
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
     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, _, _, false, _))
+      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.
       EXPECT_CALL(visitor_,
                   OnPushPromise(stream_id, promised_stream_id, kFrameComplete));
       headers_handler_.reset(new TestHeadersHandler);
       EXPECT_CALL(visitor_, OnHeaderFrameStart(stream_id))
           .WillOnce(Return(headers_handler_.get()));
@@ skipping 84 matching lines @@
   SpdySerializedFrame frame(framer_->SerializeFrame(data));
   stream_frame_.data_buffer = frame.data();
   stream_frame_.data_length = frame.size();
   if (perspective() == Perspective::IS_CLIENT) {
     EXPECT_CALL(
         *connection_,
         CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
                         "Unsupported field of HTTP/2 SETTINGS frame: 2", _));
   }
   headers_stream_->OnStreamFrame(stream_frame_);
-  EXPECT_EQ(
-      session_.server_push_enabled(),
-      (perspective() == Perspective::IS_CLIENT && version() > QUIC_VERSION_34));
+  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);
     // Replace with "WriteHeadersAndSaveData"
     SpdySerializedFrame frame;
@@ skipping 382 matching lines @@
   // 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');
 
   for (bool fin : {true, false}) {
     for (bool use_ack_listener : {true, false}) {
       QuicReferenceCountedPointer<ForceHolAckListener> ack_listener;
       if (use_ack_listener) {
         ack_listener = new ForceHolAckListener();
       }
-      EXPECT_CALL(session_,
-                  WritevData(headers_stream_, kHeadersStreamId, _, _, false, _))
+      EXPECT_CALL(session_, WritevData(headers_stream_, kHeadersStreamId, _, _,
+                                       NO_FIN, _))
           .WillRepeatedly(WithArgs<2, 5>(Invoke(
               this, &QuicHeadersStreamTest::SaveIovAndNotifyAckListener)));
 
       QuicConsumedData consumed_data = session_.WritevStreamData(
           id, MakeIOVector(data, &iov), offset, fin, ack_listener);
 
       EXPECT_EQ(consumed_data.bytes_consumed, data_len);
       EXPECT_EQ(consumed_data.fin_consumed, fin);
       // Now process the written data with the SPDY framer, and verify
       // that the original data is unchanged.
@@ skipping 17 matching lines @@
       saved_payloads_.clear();
     }
   }
 }
 
 TEST_P(QuicHeadersStreamTest, WritevStreamDataFinOnly) {
   struct iovec iov;
   string data;
 
   EXPECT_CALL(session_,
-              WritevData(headers_stream_, kHeadersStreamId, _, _, false, _))
+              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);
 
   EXPECT_EQ(consumed_data.bytes_consumed, 0u);
   EXPECT_EQ(consumed_data.fin_consumed, true);
 }
 
@@ skipping 11 matching lines @@
   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');
 
   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, _))
+              WritevData(headers_stream_, kHeadersStreamId, _, _, NO_FIN, _))
       .WillOnce(
           WithArgs<2>(Invoke(this, &QuicHeadersStreamTest::SaveIovShort)));
 
   QuicConsumedData consumed_data = session_.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 - kDataFrameMinimumSize);
   EXPECT_EQ(consumed_data.fin_consumed, false);
 
   // If session already blocked, then bytes_consumed should be zero.
   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