Clang format slam.

net/quic/quic_session_test.cc

 // Copyright (c) 2012 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_session.h"
 
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 25 matching lines @@
 
 namespace net {
 namespace test {
 namespace {
 
 const QuicPriority kHighestPriority = 0;
 const QuicPriority kSomeMiddlePriority = 3;
 
 class TestCryptoStream : public QuicCryptoStream {
  public:
-  explicit TestCryptoStream(QuicSession* session)
-      : QuicCryptoStream(session) {
-  }
+  explicit TestCryptoStream(QuicSession* session) : QuicCryptoStream(session) {}
 
   virtual void OnHandshakeMessage(
       const CryptoHandshakeMessage& message) OVERRIDE {
     encryption_established_ = true;
     handshake_confirmed_ = true;
     CryptoHandshakeMessage msg;
     string error_details;
     session()->config()->SetInitialFlowControlWindowToSend(
         kInitialFlowControlWindowForTest);
     session()->config()->ToHandshakeMessage(&msg);
-    const QuicErrorCode error = session()->config()->ProcessPeerHello(
-        msg, CLIENT, &error_details);
+    const QuicErrorCode error =
+        session()->config()->ProcessPeerHello(msg, CLIENT, &error_details);
     EXPECT_EQ(QUIC_NO_ERROR, error);
     session()->OnConfigNegotiated();
     session()->OnCryptoHandshakeEvent(QuicSession::HANDSHAKE_CONFIRMED);
   }
 
   MOCK_METHOD0(OnCanWrite, void());
 };
 
 class TestStream : public QuicDataStream {
  public:
   TestStream(QuicStreamId id, QuicSession* session)
-      : QuicDataStream(id, session) {
-  }
+      : QuicDataStream(id, session) {}
 
   using ReliableQuicStream::CloseWriteSide;
 
   virtual uint32 ProcessData(const char* data, uint32 data_len) {
     return data_len;
   }
 
   void SendBody(const string& data, bool fin) {
     WriteOrBufferData(data, fin, NULL);
   }
 
   MOCK_METHOD0(OnCanWrite, void());
 };
 
 // Poor man's functor for use as callback in a mock.
 class StreamBlocker {
  public:
   StreamBlocker(QuicSession* session, QuicStreamId stream_id)
-      : session_(session),
-        stream_id_(stream_id) {
-  }
+      : session_(session), stream_id_(stream_id) {}
 
   void MarkWriteBlocked() {
     session_->MarkWriteBlocked(stream_id_, kSomeMiddlePriority);
   }
 
  private:
   QuicSession* const session_;
   const QuicStreamId stream_id_;
 };
 
 class TestSession : public QuicSession {
  public:
   explicit TestSession(QuicConnection* connection)
       : QuicSession(connection, DefaultQuicConfig()),
         crypto_stream_(this),
-        writev_consumes_all_data_(false) {
-  }
+        writev_consumes_all_data_(false) {}
 
   virtual TestCryptoStream* GetCryptoStream() OVERRIDE {
     return &crypto_stream_;
   }
 
   virtual TestStream* CreateOutgoingDataStream() OVERRIDE {
     TestStream* stream = new TestStream(GetNextStreamId(), this);
     ActivateStream(stream);
     return stream;
   }
@@ skipping 13 matching lines @@
   virtual QuicConsumedData WritevData(
       QuicStreamId id,
       const IOVector& data,
       QuicStreamOffset offset,
       bool fin,
       QuicAckNotifier::DelegateInterface* ack_notifier_delegate) OVERRIDE {
     // Always consumes everything.
     if (writev_consumes_all_data_) {
       return QuicConsumedData(data.TotalBufferSize(), fin);
     } else {
-      return QuicSession::WritevData(id, data, offset, fin,
-                                     ack_notifier_delegate);
+      return QuicSession::WritevData(
+          id, data, offset, fin, ack_notifier_delegate);
     }
   }
 
   void set_writev_consumes_all_data(bool val) {
     writev_consumes_all_data_ = val;
   }
 
   QuicConsumedData SendStreamData() {
     return WritevData(5, IOVector(), 0, true, NULL);
   }
@@ skipping 54 matching lines @@
   }
 
   QuicVersion version() const { return connection_->version(); }
 
   MockConnection* connection_;
   TestSession session_;
   set<QuicStreamId> closed_streams_;
   SpdyHeaderBlock headers_;
 };
 
-INSTANTIATE_TEST_CASE_P(Tests, QuicSessionTest,
+INSTANTIATE_TEST_CASE_P(Tests,
+                        QuicSessionTest,
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
 TEST_P(QuicSessionTest, PeerAddress) {
   EXPECT_EQ(IPEndPoint(Loopback4(), kTestPort), session_.peer_address());
 }
 
 TEST_P(QuicSessionTest, IsCryptoHandshakeConfirmed) {
   EXPECT_FALSE(session_.IsCryptoHandshakeConfirmed());
   CryptoHandshakeMessage message;
   session_.GetCryptoStream()->OnHandshakeMessage(message);
@@ skipping 53 matching lines @@
 TEST_P(QuicSessionTest, StreamIdTooLarge) {
   QuicStreamId stream_id = 5;
   session_.GetIncomingDataStream(stream_id);
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_STREAM_ID));
   session_.GetIncomingDataStream(stream_id + kMaxStreamIdDelta + 2);
 }
 
 TEST_P(QuicSessionTest, DecompressionError) {
   QuicHeadersStream* stream = QuicSessionPeer::GetHeadersStream(&session_);
   const unsigned char data[] = {
-    0x80, 0x03, 0x00, 0x01,  // SPDY/3 SYN_STREAM frame
-    0x00, 0x00, 0x00, 0x25,  // flags/length
-    0x00, 0x00, 0x00, 0x05,  // stream id
-    0x00, 0x00, 0x00, 0x00,  // associated stream id
-    0x00, 0x00,
-    'a',  'b',  'c',  'd'    // invalid compressed data
+      0x80, 0x03, 0x00, 0x01,  // SPDY/3 SYN_STREAM frame
+      0x00, 0x00, 0x00, 0x25,  // flags/length
+      0x00, 0x00, 0x00, 0x05,  // stream id
+      0x00, 0x00, 0x00, 0x00,  // associated stream id
+      0x00, 0x00, 'a',  'b',
+      'c',  'd'  // invalid compressed data
   };
   EXPECT_CALL(*connection_,
               SendConnectionCloseWithDetails(QUIC_INVALID_HEADERS_STREAM_DATA,
                                              "SPDY framing error."));
-  stream->ProcessRawData(reinterpret_cast<const char*>(data),
-                         arraysize(data));
+  stream->ProcessRawData(reinterpret_cast<const char*>(data), arraysize(data));
 }
 
 TEST_P(QuicSessionTest, DebugDFatalIfMarkingClosedStreamWriteBlocked) {
   TestStream* stream2 = session_.CreateOutgoingDataStream();
   // Close the stream.
   stream2->Reset(QUIC_BAD_APPLICATION_PAYLOAD);
   // TODO(rtenneti): enable when chromium supports EXPECT_DEBUG_DFATAL.
   /*
   QuicStreamId kClosedStreamId = stream2->id();
   EXPECT_DEBUG_DFATAL(
@@ skipping 41 matching lines @@
   QuicConnectionPeer::SetSendAlgorithm(session_.connection(), send_algorithm);
 
   TestStream* stream2 = session_.CreateOutgoingDataStream();
   TestStream* stream4 = session_.CreateOutgoingDataStream();
   TestStream* stream6 = session_.CreateOutgoingDataStream();
 
   session_.MarkWriteBlocked(stream2->id(), kSomeMiddlePriority);
   session_.MarkWriteBlocked(stream6->id(), kSomeMiddlePriority);
   session_.MarkWriteBlocked(stream4->id(), kSomeMiddlePriority);
 
-
-  EXPECT_CALL(*send_algorithm, TimeUntilSend(_, _)).WillRepeatedly(
-      Return(QuicTime::Delta::Zero()));
-  EXPECT_CALL(*send_algorithm, GetCongestionWindow()).WillOnce(
-      Return(kMaxPacketSize * 10));
-  EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(IgnoreResult(
-      InvokeWithoutArgs(&session_, &TestSession::SendStreamData)));
-  EXPECT_CALL(*stream6, OnCanWrite()).WillOnce(IgnoreResult(
-      InvokeWithoutArgs(&session_, &TestSession::SendStreamData)));
-  EXPECT_CALL(*stream4, OnCanWrite()).WillOnce(IgnoreResult(
-      InvokeWithoutArgs(&session_, &TestSession::SendStreamData)));
-  MockPacketWriter* writer =
-      static_cast<MockPacketWriter*>(
-          QuicConnectionPeer::GetWriter(session_.connection()));
-  EXPECT_CALL(*writer, WritePacket(_, _, _, _)).WillOnce(
-                  Return(WriteResult(WRITE_STATUS_OK, 0)));
+  EXPECT_CALL(*send_algorithm, TimeUntilSend(_, _))
+      .WillRepeatedly(Return(QuicTime::Delta::Zero()));
+  EXPECT_CALL(*send_algorithm, GetCongestionWindow())
+      .WillOnce(Return(kMaxPacketSize * 10));
+  EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(
+      IgnoreResult(InvokeWithoutArgs(&session_, &TestSession::SendStreamData)));
+  EXPECT_CALL(*stream6, OnCanWrite()).WillOnce(
+      IgnoreResult(InvokeWithoutArgs(&session_, &TestSession::SendStreamData)));
+  EXPECT_CALL(*stream4, OnCanWrite()).WillOnce(
+      IgnoreResult(InvokeWithoutArgs(&session_, &TestSession::SendStreamData)));
+  MockPacketWriter* writer = static_cast<MockPacketWriter*>(
+      QuicConnectionPeer::GetWriter(session_.connection()));
+  EXPECT_CALL(*writer, WritePacket(_, _, _, _))
+      .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
   EXPECT_CALL(*send_algorithm, OnPacketSent(_, _, _, _));
   session_.OnCanWrite();
   EXPECT_FALSE(session_.HasPendingWrites());
 }
 
 TEST_P(QuicSessionTest, OnCanWriteCongestionControlBlocks) {
   InSequence s;
 
   // Drive congestion control manually.
   MockSendAlgorithm* send_algorithm = new StrictMock<MockSendAlgorithm>;
   QuicConnectionPeer::SetSendAlgorithm(session_.connection(), send_algorithm);
 
   TestStream* stream2 = session_.CreateOutgoingDataStream();
   TestStream* stream4 = session_.CreateOutgoingDataStream();
   TestStream* stream6 = session_.CreateOutgoingDataStream();
 
   session_.MarkWriteBlocked(stream2->id(), kSomeMiddlePriority);
   session_.MarkWriteBlocked(stream6->id(), kSomeMiddlePriority);
   session_.MarkWriteBlocked(stream4->id(), kSomeMiddlePriority);
 
   StreamBlocker stream2_blocker(&session_, stream2->id());
-  EXPECT_CALL(*send_algorithm, TimeUntilSend(_, _)).WillOnce(Return(
-      QuicTime::Delta::Zero()));
+  EXPECT_CALL(*send_algorithm, TimeUntilSend(_, _))
+      .WillOnce(Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(*stream2, OnCanWrite());
-  EXPECT_CALL(*send_algorithm, TimeUntilSend(_, _)).WillOnce(Return(
-      QuicTime::Delta::Zero()));
+  EXPECT_CALL(*send_algorithm, TimeUntilSend(_, _))
+      .WillOnce(Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(*stream6, OnCanWrite());
-  EXPECT_CALL(*send_algorithm, TimeUntilSend(_, _)).WillOnce(Return(
-      QuicTime::Delta::Infinite()));
+  EXPECT_CALL(*send_algorithm, TimeUntilSend(_, _))
+      .WillOnce(Return(QuicTime::Delta::Infinite()));
   // stream4->OnCanWrite is not called.
 
   session_.OnCanWrite();
   EXPECT_TRUE(session_.HasPendingWrites());
 
   // Still congestion-control blocked.
-  EXPECT_CALL(*send_algorithm, TimeUntilSend(_, _)).WillOnce(Return(
-      QuicTime::Delta::Infinite()));
+  EXPECT_CALL(*send_algorithm, TimeUntilSend(_, _))
+      .WillOnce(Return(QuicTime::Delta::Infinite()));
   session_.OnCanWrite();
   EXPECT_TRUE(session_.HasPendingWrites());
 
   // stream4->OnCanWrite is called once the connection stops being
   // congestion-control blocked.
-  EXPECT_CALL(*send_algorithm, TimeUntilSend(_, _)).WillOnce(Return(
-      QuicTime::Delta::Zero()));
+  EXPECT_CALL(*send_algorithm, TimeUntilSend(_, _))
+      .WillOnce(Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(*stream4, OnCanWrite());
   session_.OnCanWrite();
   EXPECT_FALSE(session_.HasPendingWrites());
 }
 
 TEST_P(QuicSessionTest, BufferedHandshake) {
   EXPECT_FALSE(session_.HasPendingHandshake());  // Default value.
 
   // Test that blocking other streams does not change our status.
   TestStream* stream2 = session_.CreateOutgoingDataStream();
@@ skipping 56 matching lines @@
   session_.OnCanWrite();
   EXPECT_FALSE(session_.HasPendingWrites());
 }
 
 TEST_P(QuicSessionTest, SendGoAway) {
   EXPECT_CALL(*connection_,
               SendGoAway(QUIC_PEER_GOING_AWAY, 0u, "Going Away."));
   session_.SendGoAway(QUIC_PEER_GOING_AWAY, "Going Away.");
   EXPECT_TRUE(session_.goaway_sent());
 
-  EXPECT_CALL(*connection_,
-              SendRstStream(3u, QUIC_STREAM_PEER_GOING_AWAY, 0)).Times(0);
+  EXPECT_CALL(*connection_, SendRstStream(3u, QUIC_STREAM_PEER_GOING_AWAY, 0))
+      .Times(0);
   EXPECT_TRUE(session_.GetIncomingDataStream(3u));
 }
 
 TEST_P(QuicSessionTest, DoNotSendGoAwayTwice) {
-  EXPECT_CALL(*connection_,
-              SendGoAway(QUIC_PEER_GOING_AWAY, 0u, "Going Away.")).Times(1);
+  EXPECT_CALL(*connection_, SendGoAway(QUIC_PEER_GOING_AWAY, 0u, "Going Away."))
+      .Times(1);
   session_.SendGoAway(QUIC_PEER_GOING_AWAY, "Going Away.");
   EXPECT_TRUE(session_.goaway_sent());
   session_.SendGoAway(QUIC_PEER_GOING_AWAY, "Going Away.");
 }
 
 TEST_P(QuicSessionTest, IncreasedTimeoutAfterCryptoHandshake) {
   EXPECT_EQ(kDefaultInitialTimeoutSecs,
             QuicConnectionPeer::GetNetworkTimeout(connection_).ToSeconds());
   CryptoHandshakeMessage msg;
   session_.GetCryptoStream()->OnHandshakeMessage(msg);
@@ skipping 91 matching lines @@
       session_.config()->ProcessPeerHello(msg, CLIENT, &error_details);
   EXPECT_EQ(QUIC_NO_ERROR, error);
 
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_FLOW_CONTROL_ERROR));
   session_.OnConfigNegotiated();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net