Land Recent QUIC Changes until 03/02/2015.

net/quic/quic_flow_controller_test.cc

 // Copyright 2014 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_flow_controller.h"
 
 #include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
@@ skipping 26 matching lines @@
   QuicByteCount send_window_;
   QuicByteCount receive_window_;
   QuicByteCount max_receive_window_;
   scoped_ptr<QuicFlowController> flow_controller_;
   MockConnection connection_;
 };
 
 TEST_F(QuicFlowControllerTest, SendingBytes) {
   Initialize();
 
-  EXPECT_TRUE(flow_controller_->IsEnabled());
   EXPECT_FALSE(flow_controller_->IsBlocked());
   EXPECT_FALSE(flow_controller_->FlowControlViolation());
   EXPECT_EQ(send_window_, flow_controller_->SendWindowSize());
 
   // Send some bytes, but not enough to block.
   flow_controller_->AddBytesSent(send_window_ / 2);
   EXPECT_FALSE(flow_controller_->IsBlocked());
   EXPECT_EQ(send_window_ / 2, flow_controller_->SendWindowSize());
 
   // Send enough bytes to block.
@@ skipping 21 matching lines @@
       flow_controller_->AddBytesSent(send_window_ * 10),
       base::StringPrintf("Trying to send an extra %" PRIu64 " bytes",
                          send_window_ * 10));
   EXPECT_TRUE(flow_controller_->IsBlocked());
   EXPECT_EQ(0u, flow_controller_->SendWindowSize());
 }
 
 TEST_F(QuicFlowControllerTest, ReceivingBytes) {
   Initialize();
 
-  EXPECT_TRUE(flow_controller_->IsEnabled());
   EXPECT_FALSE(flow_controller_->IsBlocked());
   EXPECT_FALSE(flow_controller_->FlowControlViolation());
   EXPECT_EQ(kInitialSessionFlowControlWindowForTest,
             QuicFlowControllerPeer::ReceiveWindowSize(flow_controller_.get()));
 
   // Receive some bytes, updating highest received offset, but not enough to
   // fill flow control receive window.
   EXPECT_TRUE(
       flow_controller_->UpdateHighestReceivedOffset(1 + receive_window_ / 2));
   EXPECT_FALSE(flow_controller_->FlowControlViolation());
   EXPECT_EQ((receive_window_ / 2) - 1,
             QuicFlowControllerPeer::ReceiveWindowSize(flow_controller_.get()));
 
   // Consume enough bytes to send a WINDOW_UPDATE frame.
   EXPECT_CALL(connection_, SendWindowUpdate(stream_id_, ::testing::_)).Times(1);
 
   flow_controller_->AddBytesConsumed(1 + receive_window_ / 2);
 
   // Result is that once again we have a fully open receive window.
   EXPECT_FALSE(flow_controller_->FlowControlViolation());
   EXPECT_EQ(kInitialSessionFlowControlWindowForTest,
             QuicFlowControllerPeer::ReceiveWindowSize(flow_controller_.get()));
 }
 
 TEST_F(QuicFlowControllerTest, OnlySendBlockedFrameOncePerOffset) {
   Initialize();
 
   // Test that we don't send duplicate BLOCKED frames. We should only send one
   // BLOCKED frame at a given send window offset.
-  EXPECT_TRUE(flow_controller_->IsEnabled());
   EXPECT_FALSE(flow_controller_->IsBlocked());
   EXPECT_FALSE(flow_controller_->FlowControlViolation());
   EXPECT_EQ(send_window_, flow_controller_->SendWindowSize());
 
   // Send enough bytes to block.
   flow_controller_->AddBytesSent(send_window_);
   EXPECT_TRUE(flow_controller_->IsBlocked());
   EXPECT_EQ(0u, flow_controller_->SendWindowSize());
 
   // Expect that 2 BLOCKED frames should get sent in total.
@@ skipping 16 matching lines @@
   flow_controller_->AddBytesSent(send_window_);
   EXPECT_TRUE(flow_controller_->IsBlocked());
   EXPECT_EQ(0u, flow_controller_->SendWindowSize());
 
   // BLOCKED frame should get sent as send offset has changed.
   flow_controller_->MaybeSendBlocked();
 }
 
 }  // namespace test
 }  // namespace net