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 68 matching lines @@
 };
 
 class TestStream : public QuicDataStream {
  public:
   TestStream(QuicStreamId id, QuicSession* session)
       : QuicDataStream(id, session) {
   }
 
   using ReliableQuicStream::CloseWriteSide;
 
-  virtual uint32 ProcessData(const char* data, uint32 data_len) {
+  virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE {
     return data_len;
   }
 
   void SendBody(const string& data, bool fin) {
     WriteOrBufferData(data, fin, NULL);
   }
 
   MOCK_METHOD0(OnCanWrite, void());
 };
 
@@ skipping 638 matching lines @@
   EXPECT_CALL(*connection_,
               SendWindowUpdate(
                   0, kInitialFlowControlWindowForTest + kByteOffset)).Times(1);
 
   // Reset stream locally.
   stream->Reset(QUIC_STREAM_CANCELLED);
 
   EXPECT_EQ(kByteOffset, session_.flow_controller()->bytes_consumed());
 }
 
+TEST_P(QuicSessionTest, ConnectionFlowControlAccountingFinAfterRst) {
+  // Test that when we RST the stream (and tear down stream state), and then
+  // receive a FIN from the peer, we correctly adjust our connection level flow
+  // control receive window.
+  FLAGS_enable_quic_connection_flow_control = true;
+  if (version() < QUIC_VERSION_19) {
+    return;
+  }
+
+  // Connection starts with some non-zero highest received byte offset,
+  // due to other active streams.
+  const uint64 kInitialConnectionBytesConsumed = 567;
+  const uint64 kInitialConnectionHighestReceivedOffset = 1234;
+  EXPECT_LT(kInitialConnectionBytesConsumed,
+            kInitialConnectionHighestReceivedOffset);
+  session_.flow_controller()->UpdateHighestReceivedOffset(
+      kInitialConnectionHighestReceivedOffset);
+  session_.flow_controller()->AddBytesConsumed(kInitialConnectionBytesConsumed);
+
+  // Reset our stream: this results in the stream being closed locally.
+  TestStream* stream = session_.CreateOutgoingDataStream();
+  stream->Reset(QUIC_STREAM_CANCELLED);
+
+  // Now receive a response from the peer with a FIN. We should handle this by
+  // adjusting the connection level flow control receive window to take into
+  // account the total number of bytes sent by the peer.
+  const QuicStreamOffset kByteOffset = 5678;
+  string body = "hello";
+  IOVector data = MakeIOVector(body);
+  QuicStreamFrame frame(stream->id(), true, kByteOffset, data);
+  vector<QuicStreamFrame> frames;
+  frames.push_back(frame);
+  session_.OnStreamFrames(frames);
+
+  QuicStreamOffset total_stream_bytes_sent_by_peer =
+      kByteOffset + body.length();
+  EXPECT_EQ(kInitialConnectionBytesConsumed + total_stream_bytes_sent_by_peer,
+            session_.flow_controller()->bytes_consumed());
+  EXPECT_EQ(
+      kInitialConnectionHighestReceivedOffset + total_stream_bytes_sent_by_peer,
+      session_.flow_controller()->highest_received_byte_offset());
+}
+
+TEST_P(QuicSessionTest, ConnectionFlowControlAccountingRstAfterRst) {
+  // Test that when we RST the stream (and tear down stream state), and then
+  // receive a RST from the peer, we correctly adjust our connection level flow
+  // control receive window.
+  FLAGS_enable_quic_connection_flow_control = true;
+  if (version() < QUIC_VERSION_19) {
+    return;
+  }
+
+  // Connection starts with some non-zero highest received byte offset,
+  // due to other active streams.
+  const uint64 kInitialConnectionBytesConsumed = 567;
+  const uint64 kInitialConnectionHighestReceivedOffset = 1234;
+  EXPECT_LT(kInitialConnectionBytesConsumed,
+            kInitialConnectionHighestReceivedOffset);
+  session_.flow_controller()->UpdateHighestReceivedOffset(
+      kInitialConnectionHighestReceivedOffset);
+  session_.flow_controller()->AddBytesConsumed(kInitialConnectionBytesConsumed);
+
+  // Reset our stream: this results in the stream being closed locally.
+  TestStream* stream = session_.CreateOutgoingDataStream();
+  stream->Reset(QUIC_STREAM_CANCELLED);
+
+  // Now receive a RST from the peer. We should handle this by adjusting the
+  // connection level flow control receive window to take into account the total
+  // number of bytes sent by the peer.
+  const QuicStreamOffset kByteOffset = 5678;
+  QuicRstStreamFrame rst_frame(stream->id(), QUIC_STREAM_CANCELLED,
+                               kByteOffset);
+  session_.OnRstStream(rst_frame);
+
+  EXPECT_EQ(kInitialConnectionBytesConsumed + kByteOffset,
+            session_.flow_controller()->bytes_consumed());
+  EXPECT_EQ(kInitialConnectionHighestReceivedOffset + kByteOffset,
+            session_.flow_controller()->highest_received_byte_offset());
+}
+
 TEST_P(QuicSessionTest, VersionNegotiationDisablesFlowControl) {
   ValueRestore<bool> old_stream_flag(
       &FLAGS_enable_quic_stream_flow_control_2, true);
   ValueRestore<bool> old_connection_flag(
       &FLAGS_enable_quic_connection_flow_control, true);
   if (version() < QUIC_VERSION_19) {
     return;
   }
 
   // Test that after successful version negotiation, flow control is disabled
@@ skipping 12 matching lines @@
 
   // 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