Clang format slam.

net/quic/reliable_quic_stream_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/reliable_quic_stream.h"
 
 #include "net/quic/quic_ack_notifier.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
@@ skipping 25 matching lines @@
 
 const char kData1[] = "FooAndBar";
 const char kData2[] = "EepAndBaz";
 const size_t kDataLen = 9;
 const QuicConnectionId kStreamId = 3;
 const bool kIsServer = true;
 const bool kShouldProcessData = true;
 
 class TestStream : public ReliableQuicStream {
  public:
-  TestStream(QuicStreamId id,
-             QuicSession* session,
-             bool should_process_data)
+  TestStream(QuicStreamId id, QuicSession* session, bool should_process_data)
       : ReliableQuicStream(id, session),
         should_process_data_(should_process_data) {}
 
   virtual uint32 ProcessRawData(const char* data, uint32 data_len) OVERRIDE {
     EXPECT_NE(0u, data_len);
     DVLOG(1) << "ProcessData data_len: " << data_len;
     data_ += string(data, data_len);
     return should_process_data_ ? data_len : 0;
   }
 
@@ skipping 53 matching lines @@
   void Initialize(bool stream_should_process_data) {
     connection_ =
         new StrictMock<MockConnection>(kIsServer, supported_versions_);
     session_.reset(new StrictMock<MockSession>(connection_));
 
     // New streams rely on having the peer's flow control receive window
     // negotiated in the config.
     QuicConfigPeer::SetReceivedInitialFlowControlWindow(
         session_->config(), initial_flow_control_window_bytes_);
 
-    stream_.reset(new TestStream(kStreamId, session_.get(),
-                                 stream_should_process_data));
-    stream2_.reset(new TestStream(kStreamId + 2, session_.get(),
-                                 stream_should_process_data));
+    stream_.reset(
+        new TestStream(kStreamId, session_.get(), stream_should_process_data));
+    stream2_.reset(new TestStream(
+        kStreamId + 2, session_.get(), stream_should_process_data));
     write_blocked_list_ =
         QuicSessionPeer::GetWriteblockedStreams(session_.get());
   }
 
   bool fin_sent() { return ReliableQuicStreamPeer::FinSent(stream_.get()); }
   bool rst_sent() { return ReliableQuicStreamPeer::RstSent(stream_.get()); }
 
   void set_initial_flow_control_window_bytes(uint32 val) {
     initial_flow_control_window_bytes_ = val;
   }
 
  protected:
   MockConnection* connection_;
   scoped_ptr<MockSession> session_;
   scoped_ptr<TestStream> stream_;
   scoped_ptr<TestStream> stream2_;
   SpdyHeaderBlock headers_;
   QuicWriteBlockedList* write_blocked_list_;
   uint32 initial_flow_control_window_bytes_;
   QuicTime::Delta zero_;
   QuicVersionVector supported_versions_;
 };
 
 TEST_F(ReliableQuicStreamTest, WriteAllData) {
   Initialize(kShouldProcessData);
 
   connection_->options()->max_packet_length =
-      1 + QuicPacketCreator::StreamFramePacketOverhead(
-          connection_->version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
-          PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(
-      Return(QuicConsumedData(kDataLen, true)));
+      1 +
+      QuicPacketCreator::StreamFramePacketOverhead(connection_->version(),
+                                                   PACKET_8BYTE_CONNECTION_ID,
+                                                   !kIncludeVersion,
+                                                   PACKET_6BYTE_SEQUENCE_NUMBER,
+                                                   NOT_IN_FEC_GROUP);
+  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _))
+      .WillOnce(Return(QuicConsumedData(kDataLen, true)));
   stream_->WriteOrBufferData(kData1, false, NULL);
   EXPECT_FALSE(write_blocked_list_->HasWriteBlockedStreams());
 }
 
 TEST_F(ReliableQuicStreamTest, NoBlockingIfNoDataOrFin) {
   Initialize(kShouldProcessData);
 
   // Write no data and no fin.  If we consume nothing we should not be write
   // blocked.
   EXPECT_DFATAL(stream_->WriteOrBufferData(StringPiece(), false, NULL), "");
   EXPECT_FALSE(write_blocked_list_->HasWriteBlockedStreams());
 }
 
 TEST_F(ReliableQuicStreamTest, BlockIfOnlySomeDataConsumed) {
   Initialize(kShouldProcessData);
 
   // Write some data and no fin.  If we consume some but not all of the data,
   // we should be write blocked a not all the data was consumed.
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(
-      Return(QuicConsumedData(1, false)));
+  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _))
+      .WillOnce(Return(QuicConsumedData(1, false)));
   stream_->WriteOrBufferData(StringPiece(kData1, 2), false, NULL);
   ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
 }
 
-
 TEST_F(ReliableQuicStreamTest, BlockIfFinNotConsumedWithData) {
   Initialize(kShouldProcessData);
 
   // Write some data and no fin.  If we consume all the data but not the fin,
   // we should be write blocked because the fin was not consumed.
   // (This should never actually happen as the fin should be sent out with the
   // last data)
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(
-      Return(QuicConsumedData(2, false)));
+  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _))
+      .WillOnce(Return(QuicConsumedData(2, false)));
   stream_->WriteOrBufferData(StringPiece(kData1, 2), true, NULL);
   ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
 }
 
 TEST_F(ReliableQuicStreamTest, BlockIfSoloFinNotConsumed) {
   Initialize(kShouldProcessData);
 
   // Write no data and a fin.  If we consume nothing we should be write blocked,
   // as the fin was not consumed.
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(
-      Return(QuicConsumedData(0, false)));
+  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _))
+      .WillOnce(Return(QuicConsumedData(0, false)));
   stream_->WriteOrBufferData(StringPiece(), true, NULL);
   ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
 }
 
 TEST_F(ReliableQuicStreamTest, WriteOrBufferData) {
   Initialize(kShouldProcessData);
 
   EXPECT_FALSE(write_blocked_list_->HasWriteBlockedStreams());
   connection_->options()->max_packet_length =
-      1 + QuicPacketCreator::StreamFramePacketOverhead(
-          connection_->version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
-          PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
-  EXPECT_CALL(*session_, WritevData(_, _, _, _, _)).WillOnce(
-      Return(QuicConsumedData(kDataLen - 1, false)));
+      1 +
+      QuicPacketCreator::StreamFramePacketOverhead(connection_->version(),
+                                                   PACKET_8BYTE_CONNECTION_ID,
+                                                   !kIncludeVersion,
+                                                   PACKET_6BYTE_SEQUENCE_NUMBER,
+                                                   NOT_IN_FEC_GROUP);
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _))
+      .WillOnce(Return(QuicConsumedData(kDataLen - 1, false)));
   stream_->WriteOrBufferData(kData1, false, NULL);
   EXPECT_TRUE(write_blocked_list_->HasWriteBlockedStreams());
 
   // Queue a bytes_consumed write.
   stream_->WriteOrBufferData(kData2, false, NULL);
 
   // Make sure we get the tail of the first write followed by the bytes_consumed
   InSequence s;
-  EXPECT_CALL(*session_, WritevData(_, _, _, _, _)).
-      WillOnce(Return(QuicConsumedData(1, false)));
-  EXPECT_CALL(*session_, WritevData(_, _, _, _, _)).
-      WillOnce(Return(QuicConsumedData(kDataLen - 2, false)));
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _))
+      .WillOnce(Return(QuicConsumedData(1, false)));
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _))
+      .WillOnce(Return(QuicConsumedData(kDataLen - 2, false)));
   stream_->OnCanWrite();
 
   // And finally the end of the bytes_consumed.
-  EXPECT_CALL(*session_, WritevData(_, _, _, _, _)).
-      WillOnce(Return(QuicConsumedData(2, true)));
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _))
+      .WillOnce(Return(QuicConsumedData(2, true)));
   stream_->OnCanWrite();
 }
 
 TEST_F(ReliableQuicStreamTest, ConnectionCloseAfterStreamClose) {
   Initialize(kShouldProcessData);
 
   stream_->CloseReadSide();
   stream_->CloseWriteSide();
   EXPECT_EQ(QUIC_STREAM_NO_ERROR, stream_->stream_error());
   EXPECT_EQ(QUIC_NO_ERROR, stream_->connection_error());
   stream_->OnConnectionClosed(QUIC_INTERNAL_ERROR, false);
   EXPECT_EQ(QUIC_STREAM_NO_ERROR, stream_->stream_error());
   EXPECT_EQ(QUIC_NO_ERROR, stream_->connection_error());
 }
 
 TEST_F(ReliableQuicStreamTest, RstAlwaysSentIfNoFinSent) {
   // For flow control accounting, a stream must send either a FIN or a RST frame
   // before termination.
   // Test that if no FIN has been sent, we send a RST.
 
   Initialize(kShouldProcessData);
   EXPECT_FALSE(fin_sent());
   EXPECT_FALSE(rst_sent());
 
   // Write some data, with no FIN.
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(
-      Return(QuicConsumedData(1, false)));
+  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _))
+      .WillOnce(Return(QuicConsumedData(1, false)));
   stream_->WriteOrBufferData(StringPiece(kData1, 1), false, NULL);
   EXPECT_FALSE(fin_sent());
   EXPECT_FALSE(rst_sent());
 
   // Now close the stream, and expect that we send a RST.
   EXPECT_CALL(*session_, SendRstStream(_, _, _));
   stream_->OnClose();
   EXPECT_FALSE(fin_sent());
   EXPECT_TRUE(rst_sent());
 }
 
 TEST_F(ReliableQuicStreamTest, RstNotSentIfFinSent) {
   // For flow control accounting, a stream must send either a FIN or a RST frame
   // before termination.
   // Test that if a FIN has been sent, we don't also send a RST.
 
   Initialize(kShouldProcessData);
   EXPECT_FALSE(fin_sent());
   EXPECT_FALSE(rst_sent());
 
   // Write some data, with FIN.
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(
-      Return(QuicConsumedData(1, true)));
+  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _))
+      .WillOnce(Return(QuicConsumedData(1, true)));
   stream_->WriteOrBufferData(StringPiece(kData1, 1), true, NULL);
   EXPECT_TRUE(fin_sent());
   EXPECT_FALSE(rst_sent());
 
   // Now close the stream, and expect that we do not send a RST.
   stream_->OnClose();
   EXPECT_TRUE(fin_sent());
   EXPECT_FALSE(rst_sent());
 }
 
@@ skipping 96 matching lines @@
 
   const int kFirstWriteSize = 100;
   const int kSecondWriteSize = 50;
   const int kLastWriteSize = kDataSize - kFirstWriteSize - kSecondWriteSize;
 
   // Set a large flow control send window so this doesn't interfere with test.
   stream_->flow_controller()->UpdateSendWindowOffset(kDataSize + 1);
 
   scoped_refptr<QuicAckNotifier::DelegateInterface> proxy_delegate;
 
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(DoAll(
-      WithArgs<4>(Invoke(CreateFunctor(
-          &SaveProxyAckNotifierDelegate, &proxy_delegate))),
-      Return(QuicConsumedData(kFirstWriteSize, false))));
+  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _))
+      .WillOnce(DoAll(WithArgs<4>(Invoke(CreateFunctor(
+                          &SaveProxyAckNotifierDelegate, &proxy_delegate))),
+                      Return(QuicConsumedData(kFirstWriteSize, false))));
   stream_->WriteOrBufferData(kData, false, delegate.get());
   EXPECT_TRUE(write_blocked_list_->HasWriteBlockedStreams());
 
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, proxy_delegate.get())).
-      WillOnce(
-          Return(QuicConsumedData(kSecondWriteSize, false)));
+  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, proxy_delegate.get()))
+      .WillOnce(Return(QuicConsumedData(kSecondWriteSize, false)));
   stream_->OnCanWrite();
 
   // No ack expected for an empty write.
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, proxy_delegate.get())).
-      WillOnce(
-          Return(QuicConsumedData(0, false)));
+  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, proxy_delegate.get()))
+      .WillOnce(Return(QuicConsumedData(0, false)));
   stream_->OnCanWrite();
 
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, proxy_delegate.get())).
-      WillOnce(
-          Return(QuicConsumedData(kLastWriteSize, false)));
+  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, proxy_delegate.get()))
+      .WillOnce(Return(QuicConsumedData(kLastWriteSize, false)));
   stream_->OnCanWrite();
 
   // There were two writes, so OnAckNotification is not propagated
   // until the third Ack arrives.
   proxy_delegate->OnAckNotification(1, 2, 3, 4, zero_);
   proxy_delegate->OnAckNotification(10, 20, 30, 40, zero_);
 
   // The arguments to delegate->OnAckNotification are the sum of the
   // arguments to proxy_delegate OnAckNotification calls.
   EXPECT_CALL(*delegate, OnAckNotification(111, 222, 333, 444, zero_));
@@ skipping 11 matching lines @@
   const int kDataSize = 16 * 1024;
   const string kData(kDataSize, 'a');
 
   const int kInitialWriteSize = 100;
 
   // Set a large flow control send window so this doesn't interfere with test.
   stream_->flow_controller()->UpdateSendWindowOffset(kDataSize + 1);
 
   scoped_refptr<QuicAckNotifier::DelegateInterface> proxy_delegate;
 
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(DoAll(
-      WithArgs<4>(Invoke(CreateFunctor(
-          &SaveProxyAckNotifierDelegate, &proxy_delegate))),
-      Return(QuicConsumedData(kInitialWriteSize, false))));
+  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _))
+      .WillOnce(DoAll(WithArgs<4>(Invoke(CreateFunctor(
+                          &SaveProxyAckNotifierDelegate, &proxy_delegate))),
+                      Return(QuicConsumedData(kInitialWriteSize, false))));
   stream_->WriteOrBufferData(kData, false, delegate.get());
   EXPECT_TRUE(write_blocked_list_->HasWriteBlockedStreams());
 
   // Handle the ack of the first write.
   proxy_delegate->OnAckNotification(1, 2, 3, 4, zero_);
   proxy_delegate = NULL;
 
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(DoAll(
-      WithArgs<4>(Invoke(CreateFunctor(
-          &SaveProxyAckNotifierDelegate, &proxy_delegate))),
-      Return(QuicConsumedData(kDataSize - kInitialWriteSize, false))));
+  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(
+      DoAll(WithArgs<4>(Invoke(
+                CreateFunctor(&SaveProxyAckNotifierDelegate, &proxy_delegate))),
+            Return(QuicConsumedData(kDataSize - kInitialWriteSize, false))));
   stream_->OnCanWrite();
 
   // Handle the ack for the second write.
   EXPECT_CALL(*delegate, OnAckNotification(101, 202, 303, 404, zero_));
   proxy_delegate->OnAckNotification(100, 200, 300, 400, zero_);
 }
 
 // Verify delegate behavior when WriteOrBufferData does not buffer.
 TEST_F(ReliableQuicStreamTest, WriteAndBufferDataWithAckNotiferNoBuffer) {
   Initialize(kShouldProcessData);
 
   scoped_refptr<MockAckNotifierDelegate> delegate(
       new StrictMock<MockAckNotifierDelegate>);
 
   scoped_refptr<QuicAckNotifier::DelegateInterface> proxy_delegate;
 
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(DoAll(
-      WithArgs<4>(Invoke(CreateFunctor(
-          &SaveProxyAckNotifierDelegate, &proxy_delegate))),
-      Return(QuicConsumedData(kDataLen, true))));
+  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _))
+      .WillOnce(DoAll(WithArgs<4>(Invoke(CreateFunctor(
+                          &SaveProxyAckNotifierDelegate, &proxy_delegate))),
+                      Return(QuicConsumedData(kDataLen, true))));
   stream_->WriteOrBufferData(kData1, true, delegate.get());
   EXPECT_FALSE(write_blocked_list_->HasWriteBlockedStreams());
 
   // Handle the ack.
   EXPECT_CALL(*delegate, OnAckNotification(1, 2, 3, 4, zero_));
   proxy_delegate->OnAckNotification(1, 2, 3, 4, zero_);
 }
 
 // Verify delegate behavior when WriteOrBufferData buffers all the data.
 TEST_F(ReliableQuicStreamTest, BufferOnWriteAndBufferDataWithAckNotifer) {
   Initialize(kShouldProcessData);
 
   scoped_refptr<MockAckNotifierDelegate> delegate(
       new StrictMock<MockAckNotifierDelegate>);
 
   scoped_refptr<QuicAckNotifier::DelegateInterface> proxy_delegate;
 
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(
-      Return(QuicConsumedData(0, false)));
+  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _))
+      .WillOnce(Return(QuicConsumedData(0, false)));
   stream_->WriteOrBufferData(kData1, true, delegate.get());
   EXPECT_TRUE(write_blocked_list_->HasWriteBlockedStreams());
 
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(DoAll(
-      WithArgs<4>(Invoke(CreateFunctor(
-          &SaveProxyAckNotifierDelegate, &proxy_delegate))),
-      Return(QuicConsumedData(kDataLen, true))));
+  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _))
+      .WillOnce(DoAll(WithArgs<4>(Invoke(CreateFunctor(
+                          &SaveProxyAckNotifierDelegate, &proxy_delegate))),
+                      Return(QuicConsumedData(kDataLen, true))));
   stream_->OnCanWrite();
 
   // Handle the ack.
   EXPECT_CALL(*delegate, OnAckNotification(1, 2, 3, 4, zero_));
   proxy_delegate->OnAckNotification(1, 2, 3, 4, zero_);
 }
 
 // Verify delegate behavior when WriteOrBufferData when the FIN is
 // sent out in a different packet.
 TEST_F(ReliableQuicStreamTest, WriteAndBufferDataWithAckNotiferOnlyFinRemains) {
   Initialize(kShouldProcessData);
 
   scoped_refptr<MockAckNotifierDelegate> delegate(
       new StrictMock<MockAckNotifierDelegate>);
 
   scoped_refptr<QuicAckNotifier::DelegateInterface> proxy_delegate;
 
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(DoAll(
-      WithArgs<4>(Invoke(CreateFunctor(
-          &SaveProxyAckNotifierDelegate, &proxy_delegate))),
-      Return(QuicConsumedData(kDataLen, false))));
+  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _))
+      .WillOnce(DoAll(WithArgs<4>(Invoke(CreateFunctor(
+                          &SaveProxyAckNotifierDelegate, &proxy_delegate))),
+                      Return(QuicConsumedData(kDataLen, false))));
   stream_->WriteOrBufferData(kData1, true, delegate.get());
   EXPECT_TRUE(write_blocked_list_->HasWriteBlockedStreams());
 
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(DoAll(
-      WithArgs<4>(Invoke(CreateFunctor(
-          &SaveProxyAckNotifierDelegate, &proxy_delegate))),
-      Return(QuicConsumedData(0, true))));
+  EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _))
+      .WillOnce(DoAll(WithArgs<4>(Invoke(CreateFunctor(
+                          &SaveProxyAckNotifierDelegate, &proxy_delegate))),
+                      Return(QuicConsumedData(0, true))));
   stream_->OnCanWrite();
 
   // Handle the acks.
   proxy_delegate->OnAckNotification(1, 2, 3, 4, zero_);
   EXPECT_CALL(*delegate, OnAckNotification(11, 22, 33, 44, zero_));
   proxy_delegate->OnAckNotification(10, 20, 30, 40, zero_);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net