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 613 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_17) {
+  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, '.');
@@ skipping 212 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_17) {
+  if (version() <= QUIC_VERSION_16) {
     return;
   }
   ValueRestore<bool> old_flag(&FLAGS_enable_quic_connection_flow_control_2,
                               true);
 
   const uint64 kLargeOffset = kInitialSessionFlowControlWindowForTest + 1;
   EXPECT_CALL(*connection_,
               SendConnectionClose(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA))
       .Times(2);
 
@@ skipping 19 matching lines @@
   ValueRestore<bool> old_flag(&FLAGS_enable_quic_connection_flow_control_2,
                               true);
   // Test that after successful version negotiation, flow control is disabled
   // appropriately at both the connection and stream level.
 
   // 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 17 implies that stream flow control is enabled, but connection
+  // Version 18 implies that stream flow control is enabled, but connection
   // level is disabled.
-  session_.OnSuccessfulVersionNegotiation(QUIC_VERSION_17);
+  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());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net