Land Recent QUIC Changes.

net/quic/quic_data_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/quic_data_stream.h"
 
 #include "net/quic/quic_ack_notifier.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
@@ skipping 264 matching lines @@
     size_t bytes_read = stream_->Readv(vec, 2);
     ASSERT_EQ(2u, bytes_read) << i;
     ASSERT_EQ(data.data()[i], buffer1[0]) << i;
     ASSERT_EQ(data.data()[i + 1], buffer2[0]) << i;
   }
 }
 
 TEST_P(QuicDataStreamTest, StreamFlowControlBlocked) {
   // Tests that we send a BLOCKED frame to the peer when we attempt to write,
   // but are flow control blocked.
-  if (GetParam() < QUIC_VERSION_17) {
+  if (GetParam() <= QUIC_VERSION_16) {
     return;
   }
 
   Initialize(kShouldProcessData);
 
   // Set a small flow control limit.
   const uint64 kWindow = 36;
   QuicFlowControllerPeer::SetSendWindowOffset(stream_->flow_controller(),
                                               kWindow);
   EXPECT_EQ(kWindow, QuicFlowControllerPeer::SendWindowOffset(
@@ skipping 17 matching lines @@
   // And we should have queued the overflowed data.
   EXPECT_EQ(kOverflow,
             ReliableQuicStreamPeer::SizeOfQueuedData(stream_.get()));
 }
 
 TEST_P(QuicDataStreamTest, StreamFlowControlNoWindowUpdateIfNotConsumed) {
   // The flow control receive window decreases whenever we add new bytes to the
   // sequencer, whether they are consumed immediately or buffered. However we
   // only send WINDOW_UPDATE frames based on increasing number of bytes
   // consumed.
-  if (GetParam() < QUIC_VERSION_17) {
+  if (GetParam() <= QUIC_VERSION_16) {
     return;
   }
 
   // Don't process data - it will be buffered instead.
   Initialize(!kShouldProcessData);
 
   // Expect no WINDOW_UPDATE frames to be sent.
   EXPECT_CALL(*connection_, SendWindowUpdate(_, _)).Times(0);
 
   // Set a small flow control receive window.
@@ skipping 26 matching lines @@
   stream_->OnStreamFrame(frame2);
   EXPECT_EQ(
       kWindow - (2 * kWindow / 3),
       QuicFlowControllerPeer::ReceiveWindowSize(stream_->flow_controller()));
 }
 
 TEST_P(QuicDataStreamTest, StreamFlowControlWindowUpdate) {
   // Tests that on receipt of data, the stream updates its receive window offset
   // appropriately, and sends WINDOW_UPDATE frames when its receive window drops
   // too low.
-  if (GetParam() < QUIC_VERSION_17) {
+  if (GetParam() <= QUIC_VERSION_16) {
     return;
   }
 
   Initialize(kShouldProcessData);
 
   // Set a small flow control limit.
   const uint64 kWindow = 36;
   QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(),
                                                  kWindow);
   QuicFlowControllerPeer::SetMaxReceiveWindow(stream_->flow_controller(),
@@ skipping 83 matching lines @@
                                       session_->flow_controller()) +
                                       1 + kWindow / 2));
   QuicStreamFrame frame3(kClientDataStreamId1, false, (kWindow / 4),
                          MakeIOVector("a"));
   stream_->OnStreamFrame(frame3);
 }
 
 TEST_P(QuicDataStreamTest, StreamFlowControlViolation) {
   // Tests that on if the peer sends too much data (i.e. violates the flow
   // control protocol), then we terminate the connection.
-  if (GetParam() < QUIC_VERSION_17) {
+  if (GetParam() <= QUIC_VERSION_16) {
     return;
   }
 
   // Stream should not process data, so that data gets buffered in the
   // sequencer, triggering flow control limits.
   Initialize(!kShouldProcessData);
 
   // Set a small flow control limit.
   const uint64 kWindow = 50;
   QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(),
@@ skipping 47 matching lines @@
   QuicStreamFrame frame(kClientDataStreamId1, false, 0, MakeIOVector(body));
 
   EXPECT_CALL(*connection_,
               SendConnectionClose(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA));
   stream_->OnStreamFrame(frame);
 }
 
 TEST_P(QuicDataStreamTest, StreamFlowControlFinNotBlocked) {
   // An attempt to write a FIN with no data should not be flow control blocked,
   // even if the send window is 0.
-  if (GetParam() < QUIC_VERSION_17) {
+  if (GetParam() <= QUIC_VERSION_16) {
     return;
   }
 
   Initialize(kShouldProcessData);
 
   // Set a flow control limit of zero.
   QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(), 0);
   EXPECT_EQ(0u, QuicFlowControllerPeer::ReceiveWindowOffset(
                     stream_->flow_controller()));
 
   // Send a frame with a FIN but no data. This should not be blocked.
   string body = "";
   bool fin = true;
 
   EXPECT_CALL(*connection_, SendBlocked(kClientDataStreamId1)).Times(0);
   EXPECT_CALL(*session_, WritevData(kClientDataStreamId1, _, _, _, _, _))
       .WillOnce(Return(QuicConsumedData(0, fin)));
 
   stream_->WriteOrBufferData(body, fin, NULL);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net