Land Recent QUIC Changes.

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 <vector>
 
 #include "base/basictypes.h"
@@ skipping 560 matching lines @@
 
 TEST_P(QuicSessionTest, DoNotSendGoAwayTwice) {
   EXPECT_CALL(*connection_,
               SendGoAway(QUIC_PEER_GOING_AWAY, 0u, "Going Away.")).Times(1);
   session_.SendGoAway(QUIC_PEER_GOING_AWAY, "Going Away.");
   EXPECT_TRUE(session_.goaway_sent());
   session_.SendGoAway(QUIC_PEER_GOING_AWAY, "Going Away.");
 }
 
 TEST_P(QuicSessionTest, IncreasedTimeoutAfterCryptoHandshake) {
-  // Add 1 to the connection timeout on the server side.
-  EXPECT_EQ(kDefaultInitialTimeoutSecs + 1,
+  EXPECT_EQ((FLAGS_quic_unified_timeouts ?
+             kInitialIdleTimeoutSecs : kDefaultIdleTimeoutSecs) + 1,
             QuicConnectionPeer::GetNetworkTimeout(connection_).ToSeconds());
   CryptoHandshakeMessage msg;
   session_.GetCryptoStream()->OnHandshakeMessage(msg);
   EXPECT_EQ(kMaximumIdleTimeoutSecs + 1,
             QuicConnectionPeer::GetNetworkTimeout(connection_).ToSeconds());
 }
 
 TEST_P(QuicSessionTest, RstStreamBeforeHeadersDecompressed) {
   // Send two bytes of payload.
   QuicStreamFrame data1(kClientDataStreamId1, false, 0, MakeIOVector("HT"));
@@ skipping 32 matching lines @@
 
   // Processing of second invalid stream reset should not result in the
   // connection being closed for a second time.
   QuicRstStreamFrame rst2(kLargeInvalidStreamId, QUIC_STREAM_NO_ERROR, 0);
   session_.OnRstStream(rst2);
 }
 
 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.
-  if (version() <= QUIC_VERSION_16) {
-    return;
-  }
 
   // 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, '.');
   EXPECT_FALSE(stream2->flow_controller()->IsBlocked());
   stream2->SendBody(body, false);
   EXPECT_TRUE(stream2->flow_controller()->IsBlocked());
 
   // Now complete the crypto handshake, resulting in an increased flow control
   // send window.
   CryptoHandshakeMessage msg;
   session_.GetCryptoStream()->OnHandshakeMessage(msg);
 
   // Stream is now unblocked.
   EXPECT_FALSE(stream2->flow_controller()->IsBlocked());
 }
 
 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_16 || version() > QUIC_VERSION_19) {
+  if (version() > QUIC_VERSION_19) {
     return;
   }
 
   uint32 kInvalidWindow = kDefaultFlowControlSendWindow - 1;
   QuicConfigPeer::SetReceivedInitialFlowControlWindow(session_.config(),
                                                       kInvalidWindow);
 
   EXPECT_CALL(*connection_,
               SendConnectionClose(QUIC_FLOW_CONTROL_INVALID_WINDOW)).Times(2);
   session_.OnConfigNegotiated();
@@ skipping 176 matching lines @@
 
   EXPECT_EQ(kInitialConnectionBytesConsumed + kByteOffset,
             session_.flow_controller()->bytes_consumed());
   EXPECT_EQ(kInitialConnectionHighestReceivedOffset + kByteOffset,
             session_.flow_controller()->highest_received_byte_offset());
 }
 
 TEST_P(QuicSessionTest, FlowControlWithInvalidFinalOffset) {
   // Test that if we receive a stream RST with a highest byte offset that
   // violates flow control, that we close the connection.
-  if (version() <= QUIC_VERSION_16) {
-    return;
-  }
-
   const uint64 kLargeOffset = kInitialSessionFlowControlWindowForTest + 1;
   EXPECT_CALL(*connection_,
               SendConnectionClose(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA))
       .Times(2);
 
   // Check that stream frame + FIN results in connection close.
   TestStream* stream = session_.CreateOutgoingDataStream();
   stream->Reset(QUIC_STREAM_CANCELLED);
   QuicStreamFrame frame(stream->id(), true, kLargeOffset, IOVector());
   vector<QuicStreamFrame> frames;
@@ skipping 17 matching lines @@
   // Initially both stream and connection flow control are enabled.
   TestStream* stream = session_.CreateOutgoingDataStream();
   EXPECT_TRUE(stream->flow_controller()->IsEnabled());
   EXPECT_TRUE(session_.flow_controller()->IsEnabled());
 
   // Version 18 implies that stream flow control is enabled, but connection
   // level is disabled.
   session_.OnSuccessfulVersionNegotiation(QUIC_VERSION_18);
   EXPECT_FALSE(session_.flow_controller()->IsEnabled());
   EXPECT_TRUE(stream->flow_controller()->IsEnabled());
-
-  // Version 16 means all flow control is disabled.
-  session_.OnSuccessfulVersionNegotiation(QUIC_VERSION_16);
-  EXPECT_FALSE(session_.flow_controller()->IsEnabled());
-  EXPECT_FALSE(stream->flow_controller()->IsEnabled());
 }
 
 TEST_P(QuicSessionTest, WindowUpdateUnblocksHeadersStream) {
   // Test that a flow control blocked headers stream gets unblocked on recipt of
   // a WINDOW_UPDATE frame. Regression test for b/17413860.
   if (version() < QUIC_VERSION_21) {
     return;
   }
 
   // Set the headers stream to be flow control blocked.
@@ skipping 41 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