Format and Refactor Flip Server.

net/tools/flip_server/http_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/http_interface.h"
 
 #include <list>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
@@ skipping 22 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));
 };
 
 class FlipHttpSMTest : public ::testing::Test {
  public:
   explicit FlipHttpSMTest(FlipHandlerType type = FLIP_HANDLER_PROXY) {
     SSLState* ssl_state = NULL;
     mock_another_interface_.reset(new MockSMInterface);
     memory_cache_.reset(new MemoryCache);
     acceptor_.reset(new FlipAcceptor(type,
                                      "127.0.0.1",
@@ skipping 99 matching lines @@
   interface_->ResetForNewConnection();
 }
 
 TEST_F(FlipHttpSMTest, InitSMConnection) {
   EXPECT_CALL(*connection_, InitSMConnection(_, _, _, _, _, _, _, _));
 
   interface_->InitSMConnection(NULL, NULL, NULL, 0, "", "", "", false);
 }
 
 TEST_F(FlipHttpSMTest, ProcessReadInput) {
-  std::string data = "HTTP/1.1 200 OK\r\n"
+  std::string data =
+      "HTTP/1.1 200 OK\r\n"
       "Content-Length: 14\r\n\r\n"
       "hello, world\r\n";
-  testing::MockFunction<void(int)> checkpoint;
+  testing::MockFunction<void(int)> checkpoint;  // NOLINT
   {
     InSequence s;
     EXPECT_CALL(*mock_another_interface_, SendSynReply(_, _));
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(*mock_another_interface_, SendDataFrame(_, _, _, _, _));
     EXPECT_CALL(*mock_another_interface_, SendEOF(_));
   }
 
   ASSERT_EQ(BalsaFrameEnums::READING_HEADER_AND_FIRSTLINE,
             interface_->spdy_framer()->ParseState());
@@ skipping 14 matching lines @@
 
   ASSERT_EQ(1u, connection_->output_list()->size());
   std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
   DataFrame* df = *i++;
   ASSERT_EQ(data, StringPiece(df->data, df->size));
   ASSERT_EQ(connection_->output_list()->end(), i);
 }
 
 TEST_F(FlipHttpSMTest, Reset) {
   std::string data = "HTTP/1.1 200 OK\r\n\r\n";
-  testing::MockFunction<void(int)> checkpoint;
+  testing::MockFunction<void(int)> checkpoint;  // NOLINT
   {
     InSequence s;
     EXPECT_CALL(*mock_another_interface_, SendSynReply(_, _));
     EXPECT_CALL(checkpoint, Call(0));
   }
 
   ASSERT_EQ(BalsaFrameEnums::READING_HEADER_AND_FIRSTLINE,
             interface_->spdy_framer()->ParseState());
 
   interface_->ProcessReadInput(data.data(), data.size());
   checkpoint.Call(0);
   ASSERT_FALSE(interface_->MessageFullyRead());
   ASSERT_EQ(BalsaFrameEnums::READING_UNTIL_CLOSE,
             interface_->spdy_framer()->ParseState());
 
   interface_->Reset();
   ASSERT_EQ(BalsaFrameEnums::READING_HEADER_AND_FIRSTLINE,
             interface_->spdy_framer()->ParseState());
 }
 
 TEST_F(FlipHttpSMTest, ResetForNewConnection) {
   std::string data = "HTTP/1.1 200 OK\r\n\r\n";
-  testing::MockFunction<void(int)> checkpoint;
+  testing::MockFunction<void(int)> checkpoint;  // NOLINT
   {
     InSequence s;
     EXPECT_CALL(*mock_another_interface_, SendSynReply(_, _));
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(*mock_another_interface_, SendEOF(_));
     EXPECT_CALL(*mock_another_interface_, ResetForNewInterface(_));
   }
 
   ASSERT_EQ(BalsaFrameEnums::READING_HEADER_AND_FIRSTLINE,
             interface_->spdy_framer()->ParseState());
@@ skipping 15 matching lines @@
     BalsaHeaders headers;
     std::string filename = "foobar";
     memory_cache_->InsertFile(&headers, filename, "");
   }
 
   interface_->NewStream(stream_id, 1, "foobar");
   ASSERT_TRUE(HasStream(stream_id));
 }
 
 TEST_F(FlipHttpSMTest, NewStreamError) {
-  std::string syn_reply = "HTTP/1.1 404 Not Found\r\n"
+  std::string syn_reply =
+      "HTTP/1.1 404 Not Found\r\n"
       "transfer-encoding: chunked\r\n\r\n";
   std::string body = "e\r\npage not found\r\n";
   uint32 stream_id = 4;
 
   ASSERT_FALSE(HasStream(stream_id));
   interface_->NewStream(stream_id, 1, "foobar");
 
   ASSERT_EQ(3u, connection_->output_list()->size());
   std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
   DataFrame* df = *i++;
   ASSERT_EQ(syn_reply, StringPiece(df->data, df->size));
   df = *i++;
   ASSERT_EQ(body, StringPiece(df->data, df->size));
   df = *i++;
   ASSERT_EQ("0\r\n\r\n", StringPiece(df->data, df->size));
   ASSERT_FALSE(HasStream(stream_id));
 }
 
 TEST_F(FlipHttpSMTest, SendErrorNotFound) {
-  std::string syn_reply = "HTTP/1.1 404 Not Found\r\n"
+  std::string syn_reply =
+      "HTTP/1.1 404 Not Found\r\n"
       "transfer-encoding: chunked\r\n\r\n";
   std::string body = "e\r\npage not found\r\n";
   uint32 stream_id = 13;
   MemCacheIter mci;
   mci.stream_id = stream_id;
 
   {
     BalsaHeaders headers;
     std::string filename = "foobar";
     memory_cache_->InsertFile(&headers, filename, "");
     mci.file_data = memory_cache_->GetFileData(filename);
   }
 
   interface_->AddToOutputOrder(mci);
   ASSERT_TRUE(HasStream(stream_id));
   interface_->SendErrorNotFound(stream_id);
 
   ASSERT_EQ(3u, connection_->output_list()->size());
   std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
   DataFrame* df = *i++;
   ASSERT_EQ(syn_reply, StringPiece(df->data, df->size));
   df = *i++;
   ASSERT_EQ(body, StringPiece(df->data, df->size));
   df = *i++;
   ASSERT_EQ("0\r\n\r\n", StringPiece(df->data, df->size));
   ASSERT_FALSE(HasStream(stream_id));
 }
 
 TEST_F(FlipHttpSMTest, SendSynStream) {
-  std::string expected = "GET / HTTP/1.0\r\n"
+  std::string expected =
+      "GET / HTTP/1.0\r\n"
       "key1: value1\r\n\r\n";
   BalsaHeaders headers;
   headers.SetResponseFirstlineFromStringPieces("GET", "/path", "HTTP/1.0");
   headers.AppendHeader("key1", "value1");
   interface_->SendSynStream(18, headers);
 
   // TODO(yhirano): Is this behavior correct?
   ASSERT_EQ(0u, connection_->output_list()->size());
 }
 
 TEST_F(FlipHttpSMTest, SendSynReply) {
-  std::string expected = "HTTP/1.1 200 OK\r\n"
+  std::string expected =
+      "HTTP/1.1 200 OK\r\n"
       "key1: value1\r\n\r\n";
   BalsaHeaders headers;
   headers.SetResponseFirstlineFromStringPieces("HTTP/1.1", "200", "OK");
   headers.AppendHeader("key1", "value1");
   interface_->SendSynReply(18, headers);
 
   ASSERT_EQ(1u, connection_->output_list()->size());
   DataFrame* df = connection_->output_list()->front();
   ASSERT_EQ(expected, StringPiece(df->data, df->size));
 }
@@ skipping 62 matching lines @@
 TEST_F(FlipHttpSMHttpTest, ProcessHeaders) {
   BalsaVisitorInterface* visitor = interface_.get();
   {
     BalsaHeaders headers;
     std::string filename = "GET_/path/file";
     memory_cache_->InsertFile(&headers, filename, "");
   }
 
   BalsaHeaders headers;
   headers.AppendHeader("Host", "example.com");
-  headers.SetRequestFirstlineFromStringPieces("GET",
-                                              "/path/file",
-                                              "HTTP/1.0");
+  headers.SetRequestFirstlineFromStringPieces("GET", "/path/file", "HTTP/1.0");
   uint32 stream_id = 133;
   interface_->SetStreamID(stream_id);
   ASSERT_FALSE(HasStream(stream_id));
   visitor->ProcessHeaders(headers);
   ASSERT_TRUE(HasStream(stream_id));
 }
 
 TEST_F(FlipHttpSMHttpTest, MessageDone) {
   BalsaVisitorInterface* visitor = interface_.get();
   {
@@ skipping 53 matching lines @@
   }
   interface_->SendEOF(32);
   ASSERT_EQ(1u, connection_->output_list()->size());
   DataFrame* df = connection_->output_list()->front();
   ASSERT_EQ("0\r\n\r\n", StringPiece(df->data, df->size));
 }
 
 }  // namespace
 
 }  // namespace net