Clang format slam.

net/quic/congestion_control/pacing_sender_test.cc

 // Copyright (c) 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/congestion_control/pacing_sender.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/test_tools/mock_clock.h"
@@ skipping 17 matching lines @@
                                         QuicTime::Delta::FromMilliseconds(1))) {
     // Pick arbitrary time.
     clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(9));
   }
 
   virtual ~PacingSenderTest() {}
 
   void CheckPacketIsSentImmediately() {
     // In order for the packet to be sendable, the underlying sender must
     // permit it to be sent immediately.
-    EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
-                                             HAS_RETRANSMITTABLE_DATA))
+    EXPECT_CALL(*mock_sender_,
+                TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA))
         .WillOnce(Return(zero_time_));
     // Verify that the packet can be sent immediately.
-    EXPECT_EQ(zero_time_,
-              pacing_sender_->TimeUntilSend(clock_.Now(),
-                                            HAS_RETRANSMITTABLE_DATA));
+    EXPECT_EQ(
+        zero_time_,
+        pacing_sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
 
     // Actually send the packet.
     EXPECT_CALL(*mock_sender_,
-                OnPacketSent(clock_.Now(), sequence_number_, kMaxPacketSize,
+                OnPacketSent(clock_.Now(),
+                             sequence_number_,
+                             kMaxPacketSize,
                              HAS_RETRANSMITTABLE_DATA));
-    pacing_sender_->OnPacketSent(clock_.Now(), sequence_number_++,
+    pacing_sender_->OnPacketSent(clock_.Now(),
+                                 sequence_number_++,
                                  kMaxPacketSize,
                                  HAS_RETRANSMITTABLE_DATA);
   }
 
   void CheckAckIsSentImmediately() {
     // In order for the ack to be sendable, the underlying sender must
     // permit it to be sent immediately.
-    EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
-                                             NO_RETRANSMITTABLE_DATA))
+    EXPECT_CALL(*mock_sender_,
+                TimeUntilSend(clock_.Now(), NO_RETRANSMITTABLE_DATA))
         .WillOnce(Return(zero_time_));
     // Verify that the ACK can be sent immediately.
-    EXPECT_EQ(zero_time_,
-              pacing_sender_->TimeUntilSend(clock_.Now(),
-                                            NO_RETRANSMITTABLE_DATA));
+    EXPECT_EQ(
+        zero_time_,
+        pacing_sender_->TimeUntilSend(clock_.Now(), NO_RETRANSMITTABLE_DATA));
 
     // Actually send the packet.
     EXPECT_CALL(*mock_sender_,
-                OnPacketSent(clock_.Now(), sequence_number_, kMaxPacketSize,
+                OnPacketSent(clock_.Now(),
+                             sequence_number_,
+                             kMaxPacketSize,
                              NO_RETRANSMITTABLE_DATA));
-    pacing_sender_->OnPacketSent(clock_.Now(), sequence_number_++,
+    pacing_sender_->OnPacketSent(clock_.Now(),
+                                 sequence_number_++,
                                  kMaxPacketSize,
                                  NO_RETRANSMITTABLE_DATA);
   }
 
   void CheckPacketIsDelayed(QuicTime::Delta delay) {
     // In order for the packet to be sendable, the underlying sender must
     // permit it to be sent immediately.
-    EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
-                                             HAS_RETRANSMITTABLE_DATA))
+    EXPECT_CALL(*mock_sender_,
+                TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA))
         .WillOnce(Return(zero_time_));
     // Verify that the packet is delayed.
-    EXPECT_EQ(delay.ToMicroseconds(),
-              pacing_sender_->TimeUntilSend(
-                  clock_.Now(), HAS_RETRANSMITTABLE_DATA).ToMicroseconds());
+    EXPECT_EQ(
+        delay.ToMicroseconds(),
+        pacing_sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA)
+            .ToMicroseconds());
   }
 
   const QuicTime::Delta zero_time_;
   const QuicTime::Delta infinite_time_;
   MockClock clock_;
   QuicPacketSequenceNumber sequence_number_;
   StrictMock<MockSendAlgorithm>* mock_sender_;
   scoped_ptr<PacingSender> pacing_sender_;
 };
 
 TEST_F(PacingSenderTest, NoSend) {
-  EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
-                                           HAS_RETRANSMITTABLE_DATA))
+  EXPECT_CALL(*mock_sender_,
+              TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA))
       .WillOnce(Return(infinite_time_));
-  EXPECT_EQ(infinite_time_,
-            pacing_sender_->TimeUntilSend(clock_.Now(),
-                                          HAS_RETRANSMITTABLE_DATA));
+  EXPECT_EQ(
+      infinite_time_,
+      pacing_sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
 }
 
 TEST_F(PacingSenderTest, SendNow) {
-  EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
-                                           HAS_RETRANSMITTABLE_DATA))
+  EXPECT_CALL(*mock_sender_,
+              TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA))
       .WillOnce(Return(zero_time_));
-  EXPECT_EQ(zero_time_,
-            pacing_sender_->TimeUntilSend(clock_.Now(),
-                                          HAS_RETRANSMITTABLE_DATA));
+  EXPECT_EQ(
+      zero_time_,
+      pacing_sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
 }
 
 TEST_F(PacingSenderTest, VariousSending) {
   // Configure bandwith of 1 packet per 2 ms, for which the pacing rate
   // will be 1 packet per 1 ms.
   EXPECT_CALL(*mock_sender_, BandwidthEstimate())
       .WillRepeatedly(Return(QuicBandwidth::FromBytesAndTimeDelta(
           kMaxPacketSize, QuicTime::Delta::FromMilliseconds(2))));
 
   // Send a whole pile of packets, and verify that they are not paced.
-  for (int i = 0 ; i < 1000; ++i) {
+  for (int i = 0; i < 1000; ++i) {
     CheckPacketIsSentImmediately();
   }
 
   // Now update the RTT and verify that packets are actually paced.
   EXPECT_CALL(*mock_sender_, OnRttUpdated(1));
   pacing_sender_->OnRttUpdated(1);
 
   CheckPacketIsSentImmediately();
   CheckPacketIsSentImmediately();
   CheckPacketIsSentImmediately();
@@ skipping 21 matching lines @@
   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 
   // Wake up early, but after enough time has passed to permit a send.
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
   CheckPacketIsSentImmediately();
   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 }
 
 }  // namespace test
 }  // namespace net