Clang format slam.

net/tools/quic/quic_time_wait_list_manager_test.cc

 // Copyright 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/tools/quic/quic_time_wait_list_manager.h"
 
 #include <errno.h>
 
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/null_encrypter.h"
@@ skipping 63 matching lines @@
       QuicTimeWaitListManager* manager,
       QuicConnectionId connection_id) {
     return manager->GetQuicVersionFromConnectionId(connection_id);
   }
 };
 
 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),
         writer_is_blocked_(false) {}
 
   virtual ~QuicTimeWaitListManagerTest() {}
 
   virtual void SetUp() {
     EXPECT_CALL(writer_, IsWriteBlocked())
         .WillRepeatedly(ReturnPointee(&writer_is_blocked_));
@@ skipping 42 matching lines @@
     header.fec_flag = false;
     header.is_in_fec_group = NOT_IN_FEC_GROUP;
     header.fec_group = 0;
     QuicStreamFrame stream_frame(1, false, 0, MakeIOVector("data"));
     QuicFrame frame(&stream_frame);
     QuicFrames frames;
     frames.push_back(frame);
     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;
   }
 
   NiceMock<MockFakeTimeEpollServer> epoll_server_;
   StrictMock<MockPacketWriter> writer_;
   StrictMock<MockQuicServerSessionVisitor> visitor_;
   QuicTimeWaitListManager time_wait_list_manager_;
   QuicFramer framer_;
   QuicConnectionId connection_id_;
   IPEndPoint server_address_;
   IPEndPoint client_address_;
   bool writer_is_blocked_;
 };
 
 class ValidatePublicResetPacketPredicate
     : public MatcherInterface<const std::tr1::tuple<const char*, int> > {
  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) {
   EXPECT_FALSE(IsConnectionIdInTimeWait(connection_id_));
   AddConnectionId(connection_id_);
   EXPECT_TRUE(IsConnectionIdInTimeWait(connection_id_));
 }
 
 TEST_F(QuicTimeWaitListManagerTest, SendConnectionClose) {
   size_t kConnectionCloseLength = 100;
   AddConnectionId(
       connection_id_,
       QuicVersionMax(),
       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);
 }
 
 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);
 }
 
 TEST_F(QuicTimeWaitListManagerTest, SendPublicResetWithExponentialBackOff) {
   AddConnectionId(connection_id_);
   for (int sequence_number = 1; sequence_number < 101; ++sequence_number) {
     if ((sequence_number & (sequence_number - 1)) == 0) {
       EXPECT_CALL(writer_, WritePacket(_, _, _, _))
           .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
     }
     ProcessPacket(connection_id_, sequence_number);
     // 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));
     }
   }
 }
 
 TEST_F(QuicTimeWaitListManagerTest, CleanUpOldConnectionIds) {
   const int kConnectionIdCount = 100;
   const int kOldConnectionIdCount = 31;
 
   // 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);
   }
 
   // Add remaining connection_ids such that their add time is
   // 2 * kTimeWaitPeriod.
   const QuicTime::Delta time_wait_period =
       QuicTimeWaitListManagerPeer::time_wait_period(&time_wait_list_manager_);
   epoll_server_.set_now_in_usec(time_wait_period.ToMicroseconds());
   for (int connection_id = kOldConnectionIdCount + 1;
        connection_id <= kConnectionIdCount;
        ++connection_id) {
     AddConnectionId(connection_id);
   }
 
   QuicTime::Delta offset = QuicTime::Delta::FromMicroseconds(39);
   // Now set the current time as time_wait_period + offset usecs.
   epoll_server_.set_now_in_usec(time_wait_period.Add(offset).ToMicroseconds());
   // 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;
   }
 }
 
 TEST_F(QuicTimeWaitListManagerTest, SendQueuedPackets) {
   QuicConnectionId connection_id = 1;
   AddConnectionId(connection_id);
   QuicPacketSequenceNumber sequence_number = 234;
   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;
   ProcessPacket(connection_id, sequence_number);
 
   // write packet should not be called since we are write blocked but the
   // should be queued.
   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();
 }
 
 TEST_F(QuicTimeWaitListManagerTest, GetQuicVersionFromMap) {
   const int kConnectionId1 = 123;
   const int kConnectionId2 = 456;
   const int kConnectionId3 = 789;
 
   AddConnectionId(kConnectionId1, QuicVersionMin(), NULL);
   AddConnectionId(kConnectionId2, QuicVersionMax(), NULL);
@@ skipping 16 matching lines @@
   AddConnectionId(connection_id_);
   EXPECT_TRUE(IsConnectionIdInTimeWait(connection_id_));
   size_t kConnectionCloseLength = 100;
   AddConnectionId(
       connection_id_,
       QuicVersionMax(),
       new QuicEncryptedPacket(
           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;
   ProcessPacket(connection_id_, kRandomSequenceNumber);
 
   const QuicTime::Delta time_wait_period =
       QuicTimeWaitListManagerPeer::time_wait_period(&time_wait_list_manager_);
 
   QuicTime::Delta offset = QuicTime::Delta::FromMicroseconds(39);
   // 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();
   EXPECT_FALSE(IsConnectionIdInTimeWait(connection_id_));
 }
 
 TEST_F(QuicTimeWaitListManagerTest, ConnectionIdsOrderedByTime) {
   // Simple randomization: the values of connection_ids are swapped based on the
   // current seconds on the clock. If the container is broken, the test will be
   // 50% flaky.
@@ skipping 16 matching lines @@
   EXPECT_CALL(epoll_server_, RegisterAlarm(_, _));
 
   time_wait_list_manager_.CleanUpOldConnectionIds();
   EXPECT_FALSE(IsConnectionIdInTimeWait(kConnectionId1));
   EXPECT_TRUE(IsConnectionIdInTimeWait(kConnectionId2));
 }
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net