In QUIC version >= 38, enables random padding of size [1, 256]

net/tools/quic/quic_simple_server_session_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/tools/quic/quic_simple_server_session.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "base/macros.h"
@@ skipping 105 matching lines @@
                            alarm_factory,
                            perspective,
                            supported_versions) {}
 
   MOCK_METHOD5(
       SendStreamData,
       QuicConsumedData(
           QuicStreamId id,
           QuicIOVector iov,
           QuicStreamOffset offset,
-          bool fin,
+          StreamSendingState state,
           QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener));
 };
 
 class MockQuicSimpleServerSession : public QuicSimpleServerSession {
  public:
   MockQuicSimpleServerSession(const QuicConfig& config,
                               QuicConnection* connection,
                               QuicSession::Visitor* visitor,
                               QuicCryptoServerStream::Helper* helper,
                               const QuicCryptoServerConfig* crypto_config,
@@ skipping 346 matching lines @@
       // PUSH_PROMISED are sent for all the resources.
       EXPECT_CALL(*session_,
                   WritePushPromiseMock(kClientDataStreamId1, stream_id, _));
       if (i <= kMaxStreamsForTest) {
         // |kMaxStreamsForTest| promised responses should be sent.
         EXPECT_CALL(*session_,
                     WriteHeadersMock(stream_id, _, false, kDefaultPriority, _));
         // Since flow control window is smaller than response body, not the
         // whole body will be sent.
         if (!session_->force_hol_blocking()) {
-          EXPECT_CALL(*connection_, SendStreamData(stream_id, _, 0, false, _))
+          EXPECT_CALL(*connection_, SendStreamData(stream_id, _, 0, NO_FIN, _))
               .WillOnce(Return(
                   QuicConsumedData(kStreamFlowControlWindowSize, false)));
           EXPECT_CALL(*connection_, SendBlocked(stream_id));
         } else {
           // The forced HOL blocking encapsulates the stream data into
           // HTTP/2 DATA frames within the headers stream.  HTTP/2
           // DATA frames are limited to a max size of 16KB, so the
           // 64KB body will be fragemented into four DATA frames.
-          EXPECT_CALL(*connection_, SendStreamData(_, _, _, false, _))
+          EXPECT_CALL(*connection_, SendStreamData(_, _, _, NO_FIN, _))
               .Times(body_size / 16384)
               .WillOnce(Return(QuicConsumedData(9 + 16394, false)))
               .WillOnce(Return(QuicConsumedData(9 + 16394, false)))
               .WillOnce(Return(QuicConsumedData(9 + 16394, false)))
               .WillOnce(Return(QuicConsumedData(9 + 16394, false)));
           EXPECT_CALL(*connection_, SendBlocked(_));
         }
       }
     }
     session_->PromisePushResources(request_url, push_resources,
@@ skipping 28 matching lines @@
   // draining, a queued promised stream will become open and send push response.
   size_t num_resources = kMaxStreamsForTest + 1;
   PromisePushResources(num_resources);
   QuicStreamId next_out_going_stream_id = num_resources * 2;
 
   // After an open stream is marked draining, a new stream is expected to be
   // created and a response sent on the stream.
   EXPECT_CALL(*session_, WriteHeadersMock(next_out_going_stream_id, _, false,
                                           kDefaultPriority, _));
   EXPECT_CALL(*connection_,
-              SendStreamData(next_out_going_stream_id, _, 0, false, _))
+              SendStreamData(next_out_going_stream_id, _, 0, NO_FIN, _))
       .WillOnce(Return(QuicConsumedData(kStreamFlowControlWindowSize, false)));
   EXPECT_CALL(*connection_, SendBlocked(next_out_going_stream_id));
   session_->StreamDraining(2);
   // Number of open outgoing streams should still be the same, because a new
   // stream is opened. And the queue should be empty.
   EXPECT_EQ(kMaxStreamsForTest, session_->GetNumOpenOutgoingStreams());
 }
 
 TEST_P(QuicSimpleServerSessionServerPushTest,
        ResetPromisedStreamToCancelServerPush) {
@@ skipping 16 matching lines @@
               SendRstStream(stream_got_reset, QUIC_RST_ACKNOWLEDGEMENT, 0));
   visitor_->OnRstStream(rst);
 
   // When the first 2 streams becomes draining, the two queued up stream could
   // be created. But since one of them was marked cancelled due to RST frame,
   // only one queued resource will be sent out.
   QuicStreamId stream_not_reset = (kMaxStreamsForTest + 1) * 2;
   InSequence s;
   EXPECT_CALL(*session_, WriteHeadersMock(stream_not_reset, _, false,
                                           kDefaultPriority, _));
-  EXPECT_CALL(*connection_, SendStreamData(stream_not_reset, _, 0, false, _))
+  EXPECT_CALL(*connection_, SendStreamData(stream_not_reset, _, 0, NO_FIN, _))
       .WillOnce(Return(QuicConsumedData(kStreamFlowControlWindowSize, false)));
   EXPECT_CALL(*connection_, SendBlocked(stream_not_reset));
   EXPECT_CALL(*session_,
               WriteHeadersMock(stream_got_reset, _, false, kDefaultPriority, _))
       .Times(0);
 
   session_->StreamDraining(2);
   session_->StreamDraining(4);
 }
 
 TEST_P(QuicSimpleServerSessionServerPushTest,
        CloseStreamToHandleMorePromisedStream) {
   if (session_->force_hol_blocking()) {
     return;
   }
   // Tests that closing a open outgoing stream can trigger a promised resource
   // in the queue to be send out.
   size_t num_resources = kMaxStreamsForTest + 1;
   PromisePushResources(num_resources);
   QuicStreamId stream_to_open = num_resources * 2;
 
   // Resetting 1st open stream will close the stream and give space for extra
   // stream to be opened.
   QuicStreamId stream_got_reset = 2;
   EXPECT_CALL(*connection_,
               SendRstStream(stream_got_reset, QUIC_RST_ACKNOWLEDGEMENT, _));
   EXPECT_CALL(*session_,
               WriteHeadersMock(stream_to_open, _, false, kDefaultPriority, _));
-  EXPECT_CALL(*connection_, SendStreamData(stream_to_open, _, 0, false, _))
+  EXPECT_CALL(*connection_, SendStreamData(stream_to_open, _, 0, NO_FIN, _))
       .WillOnce(Return(QuicConsumedData(kStreamFlowControlWindowSize, false)));
 
   EXPECT_CALL(*connection_, SendBlocked(stream_to_open));
   EXPECT_CALL(owner_, OnRstStreamReceived(_)).Times(1);
   QuicRstStreamFrame rst(stream_got_reset, QUIC_STREAM_CANCELLED, 0);
   visitor_->OnRstStream(rst);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net