Format and Refactor Flip Server.

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 14 matching lines @@
 using ::testing::InvokeWithoutArgs;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::Values;
 
 namespace {
 
 struct StringSaver {
  public:
   StringSaver() : data(NULL), size(0) {}
-  void Save() {
-    string = std::string(data, size);
-  }
+  void Save() { string = std::string(data, size); }
 
   const char* data;
   size_t size;
   std::string string;
 };
 
 class SpdyFramerVisitor : public BufferedSpdyFramerVisitorInterface {
  public:
   virtual ~SpdyFramerVisitor() {}
   MOCK_METHOD1(OnError, void(SpdyFramer::SpdyError));
   MOCK_METHOD2(OnStreamError, void(SpdyStreamId, const std::string&));
-  MOCK_METHOD7(OnSynStream, void(SpdyStreamId,
-                                 SpdyStreamId,
-                                 SpdyPriority,
-                                 uint8,
-                                 bool,
-                                 bool,
-                                 const SpdyHeaderBlock&));
+  MOCK_METHOD7(OnSynStream,
+               void(SpdyStreamId,
+                    SpdyStreamId,
+                    SpdyPriority,
+                    uint8,
+                    bool,
+                    bool,
+                    const SpdyHeaderBlock&));
   MOCK_METHOD3(OnSynStream, void(SpdyStreamId, 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_METHOD1(OnSettings, void(bool clear_persisted));
   MOCK_METHOD3(OnSetting, void(SpdySettingsIds, uint8, uint32));
@@ skipping 11 matching lines @@
                    MemoryCache* memory_cache,
                    FlipAcceptor* acceptor,
                    std::string log_prefix)
       : SMConnection(epoll_server,
                      ssl_state,
                      memory_cache,
                      acceptor,
                      log_prefix) {}
 
   MOCK_METHOD0(Cleanup, void());
-  MOCK_METHOD8(InitSMConnection, void(SMConnectionPoolInterface*,
-                                      SMInterface*,
-                                      EpollServer*,
-                                      int,
-                                      std::string,
-                                      std::string,
-                                      std::string,
-                                      bool));
+  MOCK_METHOD8(InitSMConnection,
+               void(SMConnectionPoolInterface*,
+                    SMInterface*,
+                    EpollServer*,
+                    int,
+                    std::string,
+                    std::string,
+                    std::string,
+                    bool));
 };
 
 // This class is almost SpdySM, except one function.
 // This class is the test target of tests in this file.
 class TestSpdySM : public SpdySM {
  public:
   virtual ~TestSpdySM() {}
   TestSpdySM(SMConnection* connection,
-                                   SMInterface* sm_http_interface,
-                                   EpollServer* epoll_server,
-                                   MemoryCache* memory_cache,
-                                   FlipAcceptor* acceptor,
-                                   SpdyMajorVersion version)
+             SMInterface* sm_http_interface,
+             EpollServer* epoll_server,
+             MemoryCache* memory_cache,
+             FlipAcceptor* acceptor,
+             SpdyMajorVersion version)
       : SpdySM(connection,
                sm_http_interface,
                epoll_server,
                memory_cache,
                acceptor,
                version) {}
 
   MOCK_METHOD2(FindOrMakeNewSMConnectionInterface,
                SMInterface*(const std::string&, const std::string&));
 };
@@ skipping 70 matching lines @@
 };
 
 class SpdySMProxyTest : public SpdySMTestBase {
  public:
   SpdySMProxyTest() : SpdySMTestBase(FLIP_HANDLER_PROXY) {}
   virtual ~SpdySMProxyTest() {}
 };
 
 class SpdySMServerTest : public SpdySMTestBase {
  public:
-  SpdySMServerTest(): SpdySMTestBase(FLIP_HANDLER_SPDY_SERVER) {}
+  SpdySMServerTest() : SpdySMTestBase(FLIP_HANDLER_SPDY_SERVER) {}
   virtual ~SpdySMServerTest() {}
 };
 
 INSTANTIATE_TEST_CASE_P(SpdySMProxyTest,
                         SpdySMProxyTest,
                         Values(SPDY2, SPDY3, SPDY4));
-INSTANTIATE_TEST_CASE_P(SpdySMServerTest,
-                        SpdySMServerTest,
-                        Values(SPDY2));
+INSTANTIATE_TEST_CASE_P(SpdySMServerTest, SpdySMServerTest, Values(SPDY2));
 
 TEST_P(SpdySMProxyTest, InitSMConnection) {
   {
     InSequence s;
     EXPECT_CALL(*connection_, InitSMConnection(_, _, _, _, _, _, _, _));
   }
-  interface_->InitSMConnection(NULL,
-                               NULL,
-                               epoll_server_.get(),
-                               -1,
-                               "",
-                               "",
-                               "",
-                               false);
+  interface_->InitSMConnection(
+      NULL, NULL, epoll_server_.get(), -1, "", "", "", false);
 }
 
 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"
       "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;
   {
     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, 0, false, false, block);
   ASSERT_EQ(expected, saver.string);
@@ skipping 46 matching lines @@
   SpdyHeaderBlock block;
   testing::MockFunction<void(int)> checkpoint;  // NOLINT
 
   scoped_ptr<SpdyFrame> frame(spdy_framer_->CreatePingFrame(12));
   block["method"] = "GET";
   block["url"] = "http://www.example.com/path";
   block["scheme"] = "http";
   block["version"] = "HTTP/1.0";
   {
     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, 0, false, false, block);
   checkpoint.Call(0);
@@ skipping 88 matching lines @@
 TEST_P(SpdySMProxyTest, PostAcceptHook) {
   interface_->PostAcceptHook();
 
   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_, OnSettings(false));
-    EXPECT_CALL(*spdy_framer_visitor_, OnSetting(
-        SETTINGS_MAX_CONCURRENT_STREAMS, 0u, 100u));
+    EXPECT_CALL(*spdy_framer_visitor_,
+                OnSetting(SETTINGS_MAX_CONCURRENT_STREAMS, 0u, 100u));
   }
   spdy_framer_->ProcessInput(df->data, df->size);
 }
 
 TEST_P(SpdySMProxyTest, NewStream) {
   // TODO(yhirano): SpdySM::NewStream leads to crash when
   // acceptor_->flip_handler_type_ != FLIP_HANDLER_SPDY_SERVER.
   // It should be fixed though I don't know the solution now.
 }
 
@@ skipping 23 matching lines @@
   const char* actual_data;
   size_t actual_size;
   testing::MockFunction<void(int)> checkpoint;  // NOLINT
 
   interface_->SendErrorNotFound(stream_id);
 
   ASSERT_EQ(2u, connection_->output_list()->size());
 
   {
     InSequence s;
-    EXPECT_CALL(*spdy_framer_visitor_,
-                OnSynReply(stream_id, false, _))
+    EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(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_,
                 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);
@@ skipping 199 matching lines @@
   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_,
                 OnStreamFrameData(stream_id, _, _, false))
-        .WillOnce(DoAll(SaveArg<1>(&actual_data),
-                        SaveArg<2>(&actual_size)));
+        .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";
+  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),
@@ skipping 106 matching lines @@
   const char* actual_data;
   size_t actual_size;
   testing::MockFunction<void(int)> checkpoint;  // NOLINT
 
   interface_->NewStream(stream_id, 0, "nonexistingfile");
 
   ASSERT_EQ(2u, connection_->output_list()->size());
 
   {
     InSequence s;
-    EXPECT_CALL(*spdy_framer_visitor_,
-                OnSynReply(stream_id, false, _))
+    EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(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_,
                 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