Clang format slam.

net/tools/quic/quic_time_wait_list_manager_test.cc

Index: net/tools/quic/quic_time_wait_list_manager_test.cc
diff --git a/net/tools/quic/quic_time_wait_list_manager_test.cc b/net/tools/quic/quic_time_wait_list_manager_test.cc
index d58b4e15d297f92409622db49a6107ec6e967a50..838b24e2620e520bb1428df824b502f8658d7096 100644
--- a/net/tools/quic/quic_time_wait_list_manager_test.cc
+++ b/net/tools/quic/quic_time_wait_list_manager_test.cc
@@ -81,15 +81,17 @@ namespace {
 
 class MockFakeTimeEpollServer : public FakeTimeEpollServer {
  public:
-  MOCK_METHOD2(RegisterAlarm, void(int64 timeout_in_us,
-                                   EpollAlarmCallbackInterface* alarm));
+  MOCK_METHOD2(RegisterAlarm,
+               void(int64 timeout_in_us, EpollAlarmCallbackInterface* alarm));
 };
 
 class QuicTimeWaitListManagerTest : public ::testing::Test {
  protected:
   QuicTimeWaitListManagerTest()
-      : time_wait_list_manager_(&writer_, &visitor_,
-                                &epoll_server_, QuicSupportedVersions()),
+      : time_wait_list_manager_(&writer_,
+                                &visitor_,
+                                &epoll_server_,
+                                QuicSupportedVersions()),
         framer_(QuicSupportedVersions(), QuicTime::Zero(), true),
         connection_id_(45),
         client_address_(net::test::TestPeerIPAddress(), kTestPort),
@@ -152,9 +154,8 @@ class QuicTimeWaitListManagerTest : public ::testing::Test {
     scoped_ptr<QuicPacket> packet(
         framer_.BuildUnsizedDataPacket(header, frames).packet);
     EXPECT_TRUE(packet != NULL);
-    QuicEncryptedPacket* encrypted = framer_.EncryptPacket(ENCRYPTION_NONE,
-                                                           sequence_number,
-                                                           *packet);
+    QuicEncryptedPacket* encrypted =
+        framer_.EncryptPacket(ENCRYPTION_NONE, sequence_number, *packet);
     EXPECT_TRUE(encrypted != NULL);
     return encrypted;
   }
@@ -175,43 +176,40 @@ class ValidatePublicResetPacketPredicate
  public:
   explicit ValidatePublicResetPacketPredicate(QuicConnectionId connection_id,
                                               QuicPacketSequenceNumber number)
-      : connection_id_(connection_id), sequence_number_(number) {
-  }
+      : connection_id_(connection_id), sequence_number_(number) {}
 
   virtual bool MatchAndExplain(
       const std::tr1::tuple<const char*, int> packet_buffer,
       testing::MatchResultListener* /* listener */) const {
     FramerVisitorCapturingPublicReset visitor;
-    QuicFramer framer(QuicSupportedVersions(),
-                      QuicTime::Zero(),
-                      false);
+    QuicFramer framer(QuicSupportedVersions(), QuicTime::Zero(), false);
     framer.set_visitor(&visitor);
     QuicEncryptedPacket encrypted(std::tr1::get<0>(packet_buffer),
                                   std::tr1::get<1>(packet_buffer));
     framer.ProcessPacket(encrypted);
     QuicPublicResetPacket packet = visitor.public_reset_packet();
     return connection_id_ == packet.public_header.connection_id &&
-        packet.public_header.reset_flag && !packet.public_header.version_flag &&
-        sequence_number_ == packet.rejected_sequence_number &&
-        net::test::TestPeerIPAddress() == packet.client_address.address() &&
-        kTestPort == packet.client_address.port();
+           packet.public_header.reset_flag &&
+           !packet.public_header.version_flag &&
+           sequence_number_ == packet.rejected_sequence_number &&
+           net::test::TestPeerIPAddress() == packet.client_address.address() &&
+           kTestPort == packet.client_address.port();
   }
 
-  virtual void DescribeTo(::std::ostream* os) const { }
+  virtual void DescribeTo(::std::ostream* os) const {}
 
-  virtual void DescribeNegationTo(::std::ostream* os) const { }
+  virtual void DescribeNegationTo(::std::ostream* os) const {}
 
  private:
   QuicConnectionId connection_id_;
   QuicPacketSequenceNumber sequence_number_;
 };
 
-
 Matcher<const std::tr1::tuple<const char*, int> > PublicResetPacketEq(
     QuicConnectionId connection_id,
     QuicPacketSequenceNumber sequence_number) {
-  return MakeMatcher(new ValidatePublicResetPacketPredicate(connection_id,
-                                                            sequence_number));
+  return MakeMatcher(
+      new ValidatePublicResetPacketPredicate(connection_id, sequence_number));
 }
 
 TEST_F(QuicTimeWaitListManagerTest, CheckConnectionIdInTimeWait) {
@@ -228,9 +226,11 @@ TEST_F(QuicTimeWaitListManagerTest, SendConnectionClose) {
       new QuicEncryptedPacket(
           new char[kConnectionCloseLength], kConnectionCloseLength, true));
   const int kRandomSequenceNumber = 1;
-  EXPECT_CALL(writer_, WritePacket(_, kConnectionCloseLength,
-                                   server_address_.address(),
-                                   client_address_))
+  EXPECT_CALL(writer_,
+              WritePacket(_,
+                          kConnectionCloseLength,
+                          server_address_.address(),
+                          client_address_))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
 
   ProcessPacket(connection_id_, kRandomSequenceNumber);
@@ -239,11 +239,10 @@ TEST_F(QuicTimeWaitListManagerTest, SendConnectionClose) {
 TEST_F(QuicTimeWaitListManagerTest, SendPublicReset) {
   AddConnectionId(connection_id_);
   const int kRandomSequenceNumber = 1;
-  EXPECT_CALL(writer_, WritePacket(_, _,
-                                   server_address_.address(),
-                                   client_address_))
-      .With(Args<0, 1>(PublicResetPacketEq(connection_id_,
-                                           kRandomSequenceNumber)))
+  EXPECT_CALL(writer_,
+              WritePacket(_, _, server_address_.address(), client_address_))
+      .With(Args<0, 1>(
+          PublicResetPacketEq(connection_id_, kRandomSequenceNumber)))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
 
   ProcessPacket(connection_id_, kRandomSequenceNumber);
@@ -260,10 +259,10 @@ TEST_F(QuicTimeWaitListManagerTest, SendPublicResetWithExponentialBackOff) {
     // Send public reset with exponential back off.
     if ((sequence_number & (sequence_number - 1)) == 0) {
       EXPECT_TRUE(QuicTimeWaitListManagerPeer::ShouldSendResponse(
-                      &time_wait_list_manager_, sequence_number));
+          &time_wait_list_manager_, sequence_number));
     } else {
       EXPECT_FALSE(QuicTimeWaitListManagerPeer::ShouldSendResponse(
-                       &time_wait_list_manager_, sequence_number));
+          &time_wait_list_manager_, sequence_number));
     }
   }
 }
@@ -274,8 +273,7 @@ TEST_F(QuicTimeWaitListManagerTest, CleanUpOldConnectionIds) {
 
   // Add connection_ids such that their expiry time is kTimeWaitPeriod_.
   epoll_server_.set_now_in_usec(0);
-  for (int connection_id = 1;
-       connection_id <= kOldConnectionIdCount;
+  for (int connection_id = 1; connection_id <= kOldConnectionIdCount;
        ++connection_id) {
     AddConnectionId(connection_id);
   }
@@ -297,17 +295,16 @@ TEST_F(QuicTimeWaitListManagerTest, CleanUpOldConnectionIds) {
   // After all the old connection_ids are cleaned up, check the next alarm
   // interval.
   int64 next_alarm_time = epoll_server_.ApproximateNowInUsec() +
-      time_wait_period.Subtract(offset).ToMicroseconds();
+                          time_wait_period.Subtract(offset).ToMicroseconds();
   EXPECT_CALL(epoll_server_, RegisterAlarm(next_alarm_time, _));
 
   time_wait_list_manager_.CleanUpOldConnectionIds();
-  for (int connection_id = 1;
-       connection_id <= kConnectionIdCount;
+  for (int connection_id = 1; connection_id <= kConnectionIdCount;
        ++connection_id) {
     EXPECT_EQ(connection_id > kOldConnectionIdCount,
               IsConnectionIdInTimeWait(connection_id))
         << "kOldConnectionIdCount: " << kOldConnectionIdCount
-        << " connection_id: " <<  connection_id;
+        << " connection_id: " << connection_id;
   }
 }
 
@@ -318,23 +315,18 @@ TEST_F(QuicTimeWaitListManagerTest, SendQueuedPackets) {
   scoped_ptr<QuicEncryptedPacket> packet(ConstructEncryptedPacket(
       ENCRYPTION_NONE, connection_id, sequence_number));
   // Let first write through.
-  EXPECT_CALL(writer_, WritePacket(_, _,
-                                   server_address_.address(),
-                                   client_address_))
-      .With(Args<0, 1>(PublicResetPacketEq(connection_id,
-                                           sequence_number)))
+  EXPECT_CALL(writer_,
+              WritePacket(_, _, server_address_.address(), client_address_))
+      .With(Args<0, 1>(PublicResetPacketEq(connection_id, sequence_number)))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, packet->length())));
   ProcessPacket(connection_id, sequence_number);
 
   // write block for the next packet.
-  EXPECT_CALL(writer_, WritePacket(_, _,
-                                   server_address_.address(),
-                                   client_address_))
-      .With(Args<0, 1>(PublicResetPacketEq(connection_id,
-                                           sequence_number)))
-      .WillOnce(DoAll(
-          Assign(&writer_is_blocked_, true),
-          Return(WriteResult(WRITE_STATUS_BLOCKED, EAGAIN))));
+  EXPECT_CALL(writer_,
+              WritePacket(_, _, server_address_.address(), client_address_))
+      .With(Args<0, 1>(PublicResetPacketEq(connection_id, sequence_number)))
+      .WillOnce(DoAll(Assign(&writer_is_blocked_, true),
+                      Return(WriteResult(WRITE_STATUS_BLOCKED, EAGAIN))));
   EXPECT_CALL(visitor_, OnWriteBlocked(&time_wait_list_manager_));
   ProcessPacket(connection_id, sequence_number);
   // 3rd packet. No public reset should be sent;
@@ -345,29 +337,23 @@ TEST_F(QuicTimeWaitListManagerTest, SendQueuedPackets) {
   QuicConnectionId other_connection_id = 2;
   AddConnectionId(other_connection_id);
   QuicPacketSequenceNumber other_sequence_number = 23423;
-  scoped_ptr<QuicEncryptedPacket> other_packet(
-      ConstructEncryptedPacket(
-          ENCRYPTION_NONE, other_connection_id, other_sequence_number));
-  EXPECT_CALL(writer_, WritePacket(_, _, _, _))
-      .Times(0);
+  scoped_ptr<QuicEncryptedPacket> other_packet(ConstructEncryptedPacket(
+      ENCRYPTION_NONE, other_connection_id, other_sequence_number));
+  EXPECT_CALL(writer_, WritePacket(_, _, _, _)).Times(0);
   EXPECT_CALL(visitor_, OnWriteBlocked(&time_wait_list_manager_));
   ProcessPacket(other_connection_id, other_sequence_number);
 
   // Now expect all the write blocked public reset packets to be sent again.
   writer_is_blocked_ = false;
-  EXPECT_CALL(writer_, WritePacket(_, _,
-                                   server_address_.address(),
-                                   client_address_))
-      .With(Args<0, 1>(PublicResetPacketEq(connection_id,
-                                           sequence_number)))
+  EXPECT_CALL(writer_,
+              WritePacket(_, _, server_address_.address(), client_address_))
+      .With(Args<0, 1>(PublicResetPacketEq(connection_id, sequence_number)))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, packet->length())));
-  EXPECT_CALL(writer_, WritePacket(_, _,
-                                   server_address_.address(),
-                                   client_address_))
-      .With(Args<0, 1>(PublicResetPacketEq(other_connection_id,
-                                           other_sequence_number)))
-      .WillOnce(Return(WriteResult(WRITE_STATUS_OK,
-                                   other_packet->length())));
+  EXPECT_CALL(writer_,
+              WritePacket(_, _, server_address_.address(), client_address_))
+      .With(Args<0, 1>(
+          PublicResetPacketEq(other_connection_id, other_sequence_number)))
+      .WillOnce(Return(WriteResult(WRITE_STATUS_OK, other_packet->length())));
   time_wait_list_manager_.OnCanWrite();
 }
 
@@ -404,10 +390,11 @@ TEST_F(QuicTimeWaitListManagerTest, AddConnectionIdTwice) {
           new char[kConnectionCloseLength], kConnectionCloseLength, true));
   EXPECT_TRUE(IsConnectionIdInTimeWait(connection_id_));
 
-  EXPECT_CALL(writer_, WritePacket(_,
-                                   kConnectionCloseLength,
-                                   server_address_.address(),
-                                   client_address_))
+  EXPECT_CALL(writer_,
+              WritePacket(_,
+                          kConnectionCloseLength,
+                          server_address_.address(),
+                          client_address_))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
 
   const int kRandomSequenceNumber = 1;
@@ -420,8 +407,8 @@ TEST_F(QuicTimeWaitListManagerTest, AddConnectionIdTwice) {
   // Now set the current time as time_wait_period + offset usecs.
   epoll_server_.set_now_in_usec(time_wait_period.Add(offset).ToMicroseconds());
   // After the connection_ids are cleaned up, check the next alarm interval.
-  int64 next_alarm_time = epoll_server_.ApproximateNowInUsec() +
-      time_wait_period.ToMicroseconds();
+  int64 next_alarm_time =
+      epoll_server_.ApproximateNowInUsec() + time_wait_period.ToMicroseconds();
 
   EXPECT_CALL(epoll_server_, RegisterAlarm(next_alarm_time, _));
   time_wait_list_manager_.CleanUpOldConnectionIds();