Land Recent QUIC Changes.

net/quic/reliable_quic_stream_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/reliable_quic_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 103 matching lines @@
     session_.reset(new StrictMock<MockSession>(connection_));
 
     // New streams rely on having the peer's flow control receive window
     // negotiated in the config.
     QuicConfigPeer::SetReceivedInitialFlowControlWindow(
         session_->config(), initial_flow_control_window_bytes_);
 
     stream_.reset(new TestStream(kHeadersStreamId, session_.get(),
                                  stream_should_process_data));
     write_blocked_list_ =
-        QuicSessionPeer::GetWriteblockedStreams(session_.get());
+        QuicSessionPeer::GetWriteBlockedStreams(session_.get());
   }
 
   bool fin_sent() { return ReliableQuicStreamPeer::FinSent(stream_.get()); }
   bool rst_sent() { return ReliableQuicStreamPeer::RstSent(stream_.get()); }
 
   void set_initial_flow_control_window_bytes(uint32 val) {
     initial_flow_control_window_bytes_ = val;
   }
 
   bool HasWriteBlockedStreams() {
@@ skipping 11 matching lines @@
   QuicTime::Delta zero_;
   QuicVersionVector supported_versions_;
 };
 
 TEST_F(ReliableQuicStreamTest, WriteAllData) {
   Initialize(kShouldProcessData);
 
   connection_->options()->max_packet_length =
       1 + QuicPacketCreator::StreamFramePacketOverhead(
               connection_->version(), PACKET_8BYTE_CONNECTION_ID,
-              !kIncludeVersion, PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
+              !kIncludeVersion, PACKET_6BYTE_SEQUENCE_NUMBER, 0u,
+              NOT_IN_FEC_GROUP);
   EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _))
       .WillOnce(Return(QuicConsumedData(kDataLen, true)));
   stream_->WriteOrBufferData(kData1, false, NULL);
   EXPECT_FALSE(HasWriteBlockedStreams());
 }
 
 TEST_F(ReliableQuicStreamTest, NoBlockingIfNoDataOrFin) {
   Initialize(kShouldProcessData);
 
   // Write no data and no fin.  If we consume nothing we should not be write
@@ skipping 37 matching lines @@
   ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
 }
 
 TEST_F(ReliableQuicStreamTest, WriteOrBufferData) {
   Initialize(kShouldProcessData);
 
   EXPECT_FALSE(HasWriteBlockedStreams());
   connection_->options()->max_packet_length =
       1 + QuicPacketCreator::StreamFramePacketOverhead(
           connection_->version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
-          PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
+          PACKET_6BYTE_SEQUENCE_NUMBER, 0u, NOT_IN_FEC_GROUP);
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _)).WillOnce(
       Return(QuicConsumedData(kDataLen - 1, false)));
   stream_->WriteOrBufferData(kData1, false, NULL);
   EXPECT_TRUE(HasWriteBlockedStreams());
 
   // Queue a bytes_consumed write.
   stream_->WriteOrBufferData(kData2, false, NULL);
 
   // Make sure we get the tail of the first write followed by the bytes_consumed
   InSequence s;
@@ skipping 93 matching lines @@
 TEST_F(ReliableQuicStreamTest, StreamFlowControlMultipleWindowUpdates) {
   ValueRestore<bool> old_flag(&FLAGS_enable_quic_stream_flow_control_2, true);
   set_initial_flow_control_window_bytes(1000);
 
   Initialize(kShouldProcessData);
 
   // If we receive multiple WINDOW_UPDATES (potentially out of order), then we
   // want to make sure we latch the largest offset we see.
 
   // Initially should be default.
-  EXPECT_EQ(initial_flow_control_window_bytes_,
-            QuicFlowControllerPeer::SendWindowOffset(
-                stream_.get()->flow_controller()));
+  EXPECT_EQ(
+      initial_flow_control_window_bytes_,
+      QuicFlowControllerPeer::SendWindowOffset(stream_->flow_controller()));
 
   // Check a single WINDOW_UPDATE results in correct offset.
   QuicWindowUpdateFrame window_update_1(stream_->id(), 1234);
   stream_->OnWindowUpdateFrame(window_update_1);
-  EXPECT_EQ(window_update_1.byte_offset,
-            QuicFlowControllerPeer::SendWindowOffset(
-                stream_.get()->flow_controller()));
+  EXPECT_EQ(
+      window_update_1.byte_offset,
+      QuicFlowControllerPeer::SendWindowOffset(stream_->flow_controller()));
 
   // Now send a few more WINDOW_UPDATES and make sure that only the largest is
   // remembered.
   QuicWindowUpdateFrame window_update_2(stream_->id(), 1);
   QuicWindowUpdateFrame window_update_3(stream_->id(), 9999);
   QuicWindowUpdateFrame window_update_4(stream_->id(), 5678);
   stream_->OnWindowUpdateFrame(window_update_2);
   stream_->OnWindowUpdateFrame(window_update_3);
   stream_->OnWindowUpdateFrame(window_update_4);
-  EXPECT_EQ(window_update_3.byte_offset,
-            QuicFlowControllerPeer::SendWindowOffset(
-                stream_.get()->flow_controller()));
+  EXPECT_EQ(
+      window_update_3.byte_offset,
+      QuicFlowControllerPeer::SendWindowOffset(stream_->flow_controller()));
 }
 
 TEST_F(ReliableQuicStreamTest, StreamFlowControlShouldNotBlockInLessThanQ017) {
   // TODO(rjshade): Remove this test when we no longer have any versions <
   //                QUIC_VERSION_17.
   ValueRestore<bool> old_flag(&FLAGS_enable_quic_stream_flow_control_2, true);
 
   // Make sure we are using a version which does not support flow control.
   QuicVersion kTestQuicVersions[] = {QUIC_VERSION_16};
   QuicVersionVector versions;
@@ skipping 188 matching lines @@
 
   // Handle the acks.
   proxy_delegate->OnAckNotification(1, 2, 3, 4, zero_);
   EXPECT_CALL(*delegate, OnAckNotification(11, 22, 33, 44, zero_));
   proxy_delegate->OnAckNotification(10, 20, 30, 40, zero_);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net