Roll Chrome into Mojo.

net/quic/quic_session_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_session.h"
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
@@ skipping 153 matching lines @@
       return QuicSession::WritevData(id, data, offset, fin, fec_protection,
                                      ack_notifier_delegate);
     }
   }
 
   void set_writev_consumes_all_data(bool val) {
     writev_consumes_all_data_ = val;
   }
 
   QuicConsumedData SendStreamData(QuicStreamId id) {
-    return WritevData(id, IOVector(), 0, true, MAY_FEC_PROTECT, nullptr);
+    return WritevData(id, MakeIOVector("not empty"), 0, true, MAY_FEC_PROTECT,
+                      nullptr);
   }
 
   using QuicSession::PostProcessAfterData;
 
  private:
   StrictMock<TestCryptoStream> crypto_stream_;
 
   bool writev_consumes_all_data_;
 };
 
@@ skipping 444 matching lines @@
 TEST_P(QuicSessionTest, HandshakeUnblocksFlowControlBlockedStream) {
   // Test that if a stream is flow control blocked, then on receipt of the SHLO
   // containing a suitable send window offset, the stream becomes unblocked.
 
   // Ensure that Writev consumes all the data it is given (simulate no socket
   // blocking).
   session_.set_writev_consumes_all_data(true);
 
   // Create a stream, and send enough data to make it flow control blocked.
   TestStream* stream2 = session_.CreateOutgoingDataStream();
-  string body(kDefaultFlowControlSendWindow, '.');
+  string body(kMinimumFlowControlSendWindow, '.');
   EXPECT_FALSE(stream2->flow_controller()->IsBlocked());
   EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
   EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
   stream2->SendBody(body, false);
   EXPECT_TRUE(stream2->flow_controller()->IsBlocked());
   EXPECT_TRUE(session_.IsConnectionFlowControlBlocked());
   EXPECT_TRUE(session_.IsStreamFlowControlBlocked());
 
   // The handshake message will call OnCanWrite, so the stream can resume
   // writing.
@@ skipping 109 matching lines @@
 }
 
 TEST_P(QuicSessionTest, InvalidFlowControlWindowInHandshake) {
   // TODO(rjshade): Remove this test when removing QUIC_VERSION_19.
   // Test that receipt of an invalid (< default) flow control window from
   // the peer results in the connection being torn down.
   if (version() > QUIC_VERSION_19) {
     return;
   }
 
-  uint32 kInvalidWindow = kDefaultFlowControlSendWindow - 1;
+  uint32 kInvalidWindow = kMinimumFlowControlSendWindow - 1;
   QuicConfigPeer::SetReceivedInitialFlowControlWindow(session_.config(),
                                                       kInvalidWindow);
 
   EXPECT_CALL(*connection_,
               SendConnectionClose(QUIC_FLOW_CONTROL_INVALID_WINDOW)).Times(2);
   session_.OnConfigNegotiated();
 }
 
 TEST_P(QuicSessionTest, ConnectionFlowControlAccountingRstOutOfOrder) {
   // Test that when we receive an out of order stream RST we correctly adjust
@@ skipping 130 matching lines @@
             session_.flow_controller()->highest_received_byte_offset());
 }
 
 TEST_P(QuicSessionTest, InvalidStreamFlowControlWindowInHandshake) {
   // Test that receipt of an invalid (< default) stream flow control window from
   // the peer results in the connection being torn down.
   if (version() <= QUIC_VERSION_19) {
     return;
   }
 
-  uint32 kInvalidWindow = kDefaultFlowControlSendWindow - 1;
+  uint32 kInvalidWindow = kMinimumFlowControlSendWindow - 1;
   QuicConfigPeer::SetReceivedInitialStreamFlowControlWindow(session_.config(),
                                                             kInvalidWindow);
 
   EXPECT_CALL(*connection_,
               SendConnectionClose(QUIC_FLOW_CONTROL_INVALID_WINDOW));
   session_.OnConfigNegotiated();
 }
 
 TEST_P(QuicSessionTest, InvalidSessionFlowControlWindowInHandshake) {
   // Test that receipt of an invalid (< default) session flow control window
   // from the peer results in the connection being torn down.
   if (version() == QUIC_VERSION_19) {
     return;
   }
 
-  uint32 kInvalidWindow = kDefaultFlowControlSendWindow - 1;
+  uint32 kInvalidWindow = kMinimumFlowControlSendWindow - 1;
   QuicConfigPeer::SetReceivedInitialSessionFlowControlWindow(session_.config(),
                                                              kInvalidWindow);
 
   EXPECT_CALL(*connection_,
               SendConnectionClose(QUIC_FLOW_CONTROL_INVALID_WINDOW));
   session_.OnConfigNegotiated();
 }
 
 TEST_P(QuicSessionTest, FlowControlWithInvalidFinalOffset) {
   // Test that if we receive a stream RST with a highest byte offset that
@@ skipping 28 matching lines @@
   QuicHeadersStream* headers_stream =
       QuicSessionPeer::GetHeadersStream(&session_);
   QuicFlowControllerPeer::SetSendWindowOffset(headers_stream->flow_controller(),
                                               0);
   EXPECT_TRUE(headers_stream->flow_controller()->IsBlocked());
   EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
   EXPECT_TRUE(session_.IsStreamFlowControlBlocked());
 
   // Unblock the headers stream by supplying a WINDOW_UPDATE.
   QuicWindowUpdateFrame window_update_frame(headers_stream->id(),
-                                            2 * kDefaultFlowControlSendWindow);
+                                            2 * kMinimumFlowControlSendWindow);
   vector<QuicWindowUpdateFrame> frames;
   frames.push_back(window_update_frame);
   session_.OnWindowUpdateFrames(frames);
   EXPECT_FALSE(headers_stream->flow_controller()->IsBlocked());
   EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
   EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
 }
 
 TEST_P(QuicSessionTest, TooManyUnfinishedStreamsCauseConnectionClose) {
   // If a buggy/malicious peer creates too many streams that are not ended with
@@ skipping 18 matching lines @@
   }
 
   // Called after any new data is received by the session, and triggers the call
   // to close the connection.
   session_.PostProcessAfterData();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net