Clang format slam.

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/strings/stringprintf.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/test_tools/quic_flow_controller_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using base::StringPrintf;
 
 namespace net {
 namespace test {
 
 using ::testing::_;
 
 class QuicFlowControllerTest : public ::testing::Test {
  public:
   QuicFlowControllerTest()
       : stream_id_(1234),
         send_window_(100),
         receive_window_(200),
         max_receive_window_(200),
         version_(QuicVersionMax()),
-        old_flag_(&FLAGS_enable_quic_stream_flow_control_2, true) {
-  }
+        old_flag_(&FLAGS_enable_quic_stream_flow_control_2, true) {}
 
   void Initialize() {
-    flow_controller_.reset(new QuicFlowController(version_, stream_id_, false,
-                                                  send_window_, receive_window_,
+    flow_controller_.reset(new QuicFlowController(version_,
+                                                  stream_id_,
+                                                  false,
+                                                  send_window_,
+                                                  receive_window_,
                                                   max_receive_window_));
   }
 
   void set_version(QuicVersion version) { version_ = version; }
 
  protected:
   QuicStreamId stream_id_;
   uint64 send_window_;
   uint64 receive_window_;
   uint64 max_receive_window_;
@@ skipping 28 matching lines @@
   // Update the send window, and verify this has unblocked.
   EXPECT_TRUE(flow_controller_->UpdateSendWindowOffset(2 * send_window_));
   EXPECT_FALSE(flow_controller_->IsBlocked());
   EXPECT_EQ(send_window_, flow_controller_->SendWindowSize());
 
   // Updating with a smaller offset doesn't change anything.
   EXPECT_FALSE(flow_controller_->UpdateSendWindowOffset(send_window_ / 10));
   EXPECT_EQ(send_window_, flow_controller_->SendWindowSize());
 
   // Try to send more bytes, violating flow control.
-  EXPECT_DFATAL(
-      flow_controller_->AddBytesSent(send_window_ * 10),
-      StringPrintf("Trying to send an extra %d bytes",
-                   static_cast<int>(send_window_ * 10)));
+  EXPECT_DFATAL(flow_controller_->AddBytesSent(send_window_ * 10),
+                StringPrintf("Trying to send an extra %d bytes",
+                             static_cast<int>(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());
@@ skipping 23 matching lines @@
 
   // Should not be enabled, and should not report as blocked.
   EXPECT_FALSE(flow_controller_->IsEnabled());
   EXPECT_FALSE(flow_controller_->IsBlocked());
   EXPECT_FALSE(flow_controller_->FlowControlViolation());
 
   // Any attempts to add/remove bytes should have no effect.
   EXPECT_EQ(send_window_, flow_controller_->SendWindowSize());
   EXPECT_EQ(send_window_,
             QuicFlowControllerPeer::SendWindowOffset(flow_controller_.get()));
-  EXPECT_EQ(receive_window_, QuicFlowControllerPeer::ReceiveWindowOffset(
-                                 flow_controller_.get()));
+  EXPECT_EQ(
+      receive_window_,
+      QuicFlowControllerPeer::ReceiveWindowOffset(flow_controller_.get()));
   flow_controller_->AddBytesSent(123);
   flow_controller_->AddBytesConsumed(456);
   flow_controller_->AddBytesBuffered(789);
   flow_controller_->RemoveBytesBuffered(321);
   EXPECT_EQ(send_window_, flow_controller_->SendWindowSize());
   EXPECT_EQ(send_window_,
             QuicFlowControllerPeer::SendWindowOffset(flow_controller_.get()));
-  EXPECT_EQ(receive_window_, QuicFlowControllerPeer::ReceiveWindowOffset(
-                                 flow_controller_.get()));
+  EXPECT_EQ(
+      receive_window_,
+      QuicFlowControllerPeer::ReceiveWindowOffset(flow_controller_.get()));
 
   // Any attempt to change offset should have no effect.
   EXPECT_EQ(send_window_, flow_controller_->SendWindowSize());
   EXPECT_EQ(send_window_,
             QuicFlowControllerPeer::SendWindowOffset(flow_controller_.get()));
   flow_controller_->UpdateSendWindowOffset(send_window_ + 12345);
   EXPECT_EQ(send_window_, flow_controller_->SendWindowSize());
   EXPECT_EQ(send_window_,
             QuicFlowControllerPeer::SendWindowOffset(flow_controller_.get()));
 
@@ skipping 58 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(&connection);
 }
 
 }  // namespace test
 }  // namespace net