Clang format slam.

net/tools/flip_server/spdy_interface_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/flip_server/spdy_interface.h"
 
 #include <list>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_piece.h"
@@ skipping 36 matching lines @@
   MOCK_METHOD6(OnSynStream,
                void(SpdyStreamId,
                     SpdyStreamId,
                     SpdyPriority,
                     bool,
                     bool,
                     const SpdyHeaderBlock&));
   MOCK_METHOD3(OnSynReply, void(SpdyStreamId, bool, const SpdyHeaderBlock&));
   MOCK_METHOD3(OnHeaders, void(SpdyStreamId, bool, const SpdyHeaderBlock&));
   MOCK_METHOD3(OnDataFrameHeader, void(SpdyStreamId, size_t, bool));
-  MOCK_METHOD4(OnStreamFrameData, void(SpdyStreamId,
-                                       const char*,
-                                       size_t,
-                                       bool));
+  MOCK_METHOD4(OnStreamFrameData,
+               void(SpdyStreamId, const char*, size_t, bool));
   MOCK_METHOD1(OnSettings, void(bool clear_persisted));
   MOCK_METHOD3(OnSetting, void(SpdySettingsIds, uint8, uint32));
   MOCK_METHOD2(OnPing, void(SpdyPingId unique_id, bool is_ack));
   MOCK_METHOD2(OnRstStream, void(SpdyStreamId, SpdyRstStreamStatus));
   MOCK_METHOD2(OnGoAway, void(SpdyStreamId, SpdyGoAwayStatus));
   MOCK_METHOD2(OnWindowUpdate, void(SpdyStreamId, uint32));
   MOCK_METHOD2(OnPushPromise, void(SpdyStreamId, SpdyStreamId));
 };
 
 class FakeSMConnection : public SMConnection {
@@ skipping 142 matching lines @@
 
 TEST_P(SpdySMProxyTest, OnSynStream_SPDY2) {
   if (GetParam() != SPDY2) {
     // This test case is for SPDY2.
     return;
   }
   BufferedSpdyFramerVisitorInterface* visitor = interface_.get();
   scoped_ptr<MockSMInterface> mock_interface(new MockSMInterface);
   uint32 stream_id = 92;
   uint32 associated_id = 43;
-  std::string expected = "GET /path HTTP/1.0\r\n"
+  std::string expected =
+      "GET /path HTTP/1.0\r\n"
       "Host: 127.0.0.1\r\n"
       "hoge: fuga\r\n\r\n";
   SpdyHeaderBlock block;
   block["method"] = "GET";
   block["url"] = "/path";
   block["scheme"] = "http";
   block["version"] = "HTTP/1.0";
   block["hoge"] = "fuga";
   StringSaver saver;
   {
@@ skipping 13 matching lines @@
 
 TEST_P(SpdySMProxyTest, OnSynStream) {
   if (GetParam() == SPDY2) {
     // This test case is not for SPDY2.
     return;
   }
   BufferedSpdyFramerVisitorInterface* visitor = interface_.get();
   scoped_ptr<MockSMInterface> mock_interface(new MockSMInterface);
   uint32 stream_id = 92;
   uint32 associated_id = 43;
-  std::string expected = "GET /path HTTP/1.1\r\n"
+  std::string expected =
+      "GET /path HTTP/1.1\r\n"
       "Host: 127.0.0.1\r\n"
       "foo: bar\r\n\r\n";
   SpdyHeaderBlock block;
   block[":method"] = "GET";
   block[":host"] = "www.example.com";
   block[":path"] = "/path";
   block[":scheme"] = "http";
   block["foo"] = "bar";
   StringSaver saver;
   {
     InSequence s;
-    EXPECT_CALL(*interface_,
-                FindOrMakeNewSMConnectionInterface(_, _))
+    EXPECT_CALL(*interface_, FindOrMakeNewSMConnectionInterface(_, _))
         .WillOnce(Return(mock_interface.get()));
     EXPECT_CALL(*mock_interface, SetStreamID(stream_id));
     EXPECT_CALL(*mock_interface, ProcessWriteInput(_, _))
         .WillOnce(DoAll(SaveArg<0>(&saver.data),
                         SaveArg<1>(&saver.size),
                         InvokeWithoutArgs(&saver, &StringSaver::Save),
                         Return(0)));
   }
   visitor->OnSynStream(stream_id, associated_id, 0, false, false, block);
   ASSERT_EQ(expected, saver.string);
@@ skipping 45 matching lines @@
   testing::MockFunction<void(int)> checkpoint;  // NOLINT
 
   scoped_ptr<SpdyFrame> frame(spdy_framer_->CreatePingFrame(12, false));
   block[":method"] = "GET";
   block[":host"] = "www.example.com";
   block[":path"] = "/path";
   block[":scheme"] = "http";
   block["foo"] = "bar";
   {
     InSequence s;
-    EXPECT_CALL(*interface_,
-                FindOrMakeNewSMConnectionInterface(_, _))
+    EXPECT_CALL(*interface_, FindOrMakeNewSMConnectionInterface(_, _))
         .WillOnce(Return(mock_interface.get()));
     EXPECT_CALL(*mock_interface, SetStreamID(stream_id));
     EXPECT_CALL(*mock_interface, ProcessWriteInput(_, _)).Times(1);
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(*mock_interface,
                 ProcessWriteInput(frame->data(), frame->size())).Times(1);
   }
 
   visitor->OnSynStream(stream_id, associated_id, 0, false, false, block);
   checkpoint.Call(0);
@@ skipping 118 matching lines @@
   {
     InSequence s;
     if (GetParam() < SPDY4) {
       EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(stream_id, false, _))
           .WillOnce(SaveArg<2>(&actual_header_block));
     } else {
       EXPECT_CALL(*spdy_framer_visitor_, OnHeaders(stream_id, false, _))
           .WillOnce(SaveArg<2>(&actual_header_block));
     }
     EXPECT_CALL(checkpoint, Call(0));
+    EXPECT_CALL(*spdy_framer_visitor_, OnDataFrameHeader(stream_id, _, true));
     EXPECT_CALL(*spdy_framer_visitor_,
-                OnDataFrameHeader(stream_id, _, true));
-    EXPECT_CALL(*spdy_framer_visitor_,
-                OnStreamFrameData(stream_id, _, _, false)).Times(1)
-        .WillOnce(DoAll(SaveArg<1>(&actual_data),
-                        SaveArg<2>(&actual_size)));
+                OnStreamFrameData(stream_id, _, _, false))
+        .Times(1)
+        .WillOnce(DoAll(SaveArg<1>(&actual_data), SaveArg<2>(&actual_size)));
     EXPECT_CALL(*spdy_framer_visitor_,
                 OnStreamFrameData(stream_id, NULL, 0, true)).Times(1);
   }
 
   std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
   DataFrame* df = *i++;
   spdy_framer_->ProcessInput(df->data, df->size);
   checkpoint.Call(0);
   df = *i++;
   spdy_framer_->ProcessInput(df->data, df->size);
@@ skipping 16 matching lines @@
   size_t actual_size;
   testing::MockFunction<void(int)> checkpoint;  // NOLINT
 
   interface_->SendErrorNotFound(stream_id);
 
   ASSERT_EQ(2u, connection_->output_list()->size());
 
   {
     InSequence s;
     if (GetParam() < SPDY4) {
-      EXPECT_CALL(*spdy_framer_visitor_,
-                  OnSynReply(stream_id, false, _))
+      EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(stream_id, false, _))
           .WillOnce(SaveArg<2>(&actual_header_block));
     } else {
-      EXPECT_CALL(*spdy_framer_visitor_,
-                  OnHeaders(stream_id, false, _))
+      EXPECT_CALL(*spdy_framer_visitor_, OnHeaders(stream_id, false, _))
           .WillOnce(SaveArg<2>(&actual_header_block));
     }
     EXPECT_CALL(checkpoint, Call(0));
+    EXPECT_CALL(*spdy_framer_visitor_, OnDataFrameHeader(stream_id, _, true));
     EXPECT_CALL(*spdy_framer_visitor_,
-                OnDataFrameHeader(stream_id, _, true));
-    EXPECT_CALL(*spdy_framer_visitor_,
-                OnStreamFrameData(stream_id, _, _, false)).Times(1)
-        .WillOnce(DoAll(SaveArg<1>(&actual_data),
-                        SaveArg<2>(&actual_size)));
+                OnStreamFrameData(stream_id, _, _, false))
+        .Times(1)
+        .WillOnce(DoAll(SaveArg<1>(&actual_data), SaveArg<2>(&actual_size)));
     EXPECT_CALL(*spdy_framer_visitor_,
                 OnStreamFrameData(stream_id, NULL, 0, true)).Times(1);
   }
 
   std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
   DataFrame* df = *i++;
   spdy_framer_->ProcessInput(df->data, df->size);
   checkpoint.Call(0);
   df = *i++;
   spdy_framer_->ProcessInput(df->data, df->size);
@@ skipping 152 matching lines @@
   size_t actual_size;
 
   interface_->SendDataFrame(stream_id, "hello", 5, flags, true);
 
   ASSERT_EQ(1u, connection_->output_list()->size());
   std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
   DataFrame* df = *i++;
 
   {
     InSequence s;
-    EXPECT_CALL(*spdy_framer_visitor_,
-                OnDataFrameHeader(stream_id, _, false));
+    EXPECT_CALL(*spdy_framer_visitor_, OnDataFrameHeader(stream_id, _, false));
     EXPECT_CALL(*spdy_framer_visitor_,
                 OnStreamFrameData(stream_id, _, _, false))
         .WillOnce(DoAll(SaveArg<1>(&actual_data), SaveArg<2>(&actual_size)));
   }
 
   spdy_framer_->ProcessInput(df->data, df->size);
   ASSERT_EQ(1, spdy_framer_->frames_received());
   ASSERT_EQ("hello", StringPiece(actual_data, actual_size));
 }
 
 TEST_P(SpdySMProxyTest, SendLongDataFrame) {
   uint32 stream_id = 133;
   SpdyDataFlags flags = DATA_FLAG_NONE;
   const char* actual_data;
   size_t actual_size;
 
   std::string data = std::string(kSpdySegmentSize, 'a') +
                      std::string(kSpdySegmentSize, 'b') + "c";
   interface_->SendDataFrame(stream_id, data.data(), data.size(), flags, true);
 
   {
     InSequence s;
     for (int i = 0; i < 3; ++i) {
-        EXPECT_CALL(*spdy_framer_visitor_,
-                    OnDataFrameHeader(stream_id, _, false));
-        EXPECT_CALL(*spdy_framer_visitor_,
-                    OnStreamFrameData(stream_id, _, _, false))
-            .WillOnce(DoAll(SaveArg<1>(&actual_data),
-                            SaveArg<2>(&actual_size)));
+      EXPECT_CALL(*spdy_framer_visitor_,
+                  OnDataFrameHeader(stream_id, _, false));
+      EXPECT_CALL(*spdy_framer_visitor_,
+                  OnStreamFrameData(stream_id, _, _, false))
+          .WillOnce(DoAll(SaveArg<1>(&actual_data), SaveArg<2>(&actual_size)));
     }
   }
 
   ASSERT_EQ(3u, connection_->output_list()->size());
   std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
   DataFrame* df = *i++;
   spdy_framer_->ProcessInput(df->data, df->size);
   ASSERT_EQ(std::string(kSpdySegmentSize, 'a'),
             StringPiece(actual_data, actual_size));
 
@@ skipping 103 matching lines @@
   {
     InSequence s;
     if (GetParam() < SPDY4) {
       EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(stream_id, false, _))
           .WillOnce(SaveArg<2>(&actual_header_block));
     } else {
       EXPECT_CALL(*spdy_framer_visitor_, OnHeaders(stream_id, false, _))
           .WillOnce(SaveArg<2>(&actual_header_block));
     }
     EXPECT_CALL(checkpoint, Call(0));
+    EXPECT_CALL(*spdy_framer_visitor_, OnDataFrameHeader(stream_id, _, true));
     EXPECT_CALL(*spdy_framer_visitor_,
-                OnDataFrameHeader(stream_id, _, true));
-    EXPECT_CALL(*spdy_framer_visitor_,
-                OnStreamFrameData(stream_id, _, _, false)).Times(1)
-        .WillOnce(DoAll(SaveArg<1>(&actual_data),
-                        SaveArg<2>(&actual_size)));
+                OnStreamFrameData(stream_id, _, _, false))
+        .Times(1)
+        .WillOnce(DoAll(SaveArg<1>(&actual_data), SaveArg<2>(&actual_size)));
     EXPECT_CALL(*spdy_framer_visitor_,
                 OnStreamFrameData(stream_id, NULL, 0, true)).Times(1);
   }
 
   std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
   DataFrame* df = *i++;
   spdy_framer_->ProcessInput(df->data, df->size);
   checkpoint.Call(0);
   df = *i++;
   spdy_framer_->ProcessInput(df->data, df->size);
 
   ASSERT_EQ(2, spdy_framer_->frames_received());
   ASSERT_EQ(2u, actual_header_block.size());
   ASSERT_EQ("404 Not Found", actual_header_block["status"]);
   ASSERT_EQ("HTTP/1.1", actual_header_block["version"]);
   ASSERT_EQ("wtf?", StringPiece(actual_data, actual_size));
 }
 
 }  // namespace
 
 }  // namespace net