Clang format slam.

net/quic/congestion_control/pacing_sender_test.cc

Index: net/quic/congestion_control/pacing_sender_test.cc
diff --git a/net/quic/congestion_control/pacing_sender_test.cc b/net/quic/congestion_control/pacing_sender_test.cc
index 19e8e5110457c2e27e2805dca12b49bf812dabe5..bda63fe2622f320989475dfe6884052ed12ee34b 100644
--- a/net/quic/congestion_control/pacing_sender_test.cc
+++ b/net/quic/congestion_control/pacing_sender_test.cc
@@ -35,19 +35,22 @@ class PacingSenderTest : public ::testing::Test {
   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);
   }
@@ -55,19 +58,22 @@ class PacingSenderTest : public ::testing::Test {
   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);
   }
@@ -75,13 +81,14 @@ class PacingSenderTest : public ::testing::Test {
   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_;
@@ -93,21 +100,21 @@ class PacingSenderTest : public ::testing::Test {
 };
 
 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) {
@@ -118,7 +125,7 @@ TEST_F(PacingSenderTest, VariousSending) {
           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();
   }