Clang format slam.

net/http/http_stream_parser_unittest.cc

Index: net/http/http_stream_parser_unittest.cc
diff --git a/net/http/http_stream_parser_unittest.cc b/net/http/http_stream_parser_unittest.cc
index dcaf1f3e9c3f1fdaf0592f7dae1eb50e9c00f17d..ebee782b0eb5c82c50cb7ebc142edb64f96a147c 100644
--- a/net/http/http_stream_parser_unittest.cc
+++ b/net/http/http_stream_parser_unittest.cc
@@ -99,8 +99,8 @@ TEST(HttpStreamParser, EncodeChunk_TooLargePayload) {
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_NoBody) {
   // Shouldn't be merged if upload data is non-existent.
-  ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
-      "some header", NULL));
+  ASSERT_FALSE(
+      HttpStreamParser::ShouldMergeRequestHeadersAndBody("some header", NULL));
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_EmptyBody) {
@@ -109,8 +109,8 @@ TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_EmptyBody) {
       new UploadDataStream(element_readers.Pass(), 0));
   ASSERT_EQ(OK, body->Init(CompletionCallback()));
   // Shouldn't be merged if upload data is empty.
-  ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
-      "some header", body.get()));
+  ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody("some header",
+                                                                  body.get()));
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_ChunkedBody) {
@@ -120,8 +120,8 @@ TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_ChunkedBody) {
   body->AppendChunk(payload.data(), payload.size(), true);
   ASSERT_EQ(OK, body->Init(CompletionCallback()));
   // Shouldn't be merged if upload data carries chunked data.
-  ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
-      "some header", body.get()));
+  ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody("some header",
+                                                                  body.get()));
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_FileBody) {
@@ -132,8 +132,8 @@ TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_FileBody) {
     base::ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
     base::FilePath temp_file_path;
-    ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir.path(),
-                                               &temp_file_path));
+    ASSERT_TRUE(
+        base::CreateTemporaryFileInDir(temp_dir.path(), &temp_file_path));
 
     element_readers.push_back(
         new UploadFileElementReader(base::MessageLoopProxy::current().get(),
@@ -158,29 +158,29 @@ TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_FileBody) {
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_SmallBodyInMemory) {
   ScopedVector<UploadElementReader> element_readers;
   const std::string payload = "123";
-  element_readers.push_back(new UploadBytesElementReader(
-      payload.data(), payload.size()));
+  element_readers.push_back(
+      new UploadBytesElementReader(payload.data(), payload.size()));
 
   scoped_ptr<UploadDataStream> body(
       new UploadDataStream(element_readers.Pass(), 0));
   ASSERT_EQ(OK, body->Init(CompletionCallback()));
   // Yes, should be merged if the in-memory body is small here.
-  ASSERT_TRUE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
-      "some header", body.get()));
+  ASSERT_TRUE(HttpStreamParser::ShouldMergeRequestHeadersAndBody("some header",
+                                                                 body.get()));
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_LargeBodyInMemory) {
   ScopedVector<UploadElementReader> element_readers;
   const std::string payload(10000, 'a');  // 'a' x 10000.
-  element_readers.push_back(new UploadBytesElementReader(
-      payload.data(), payload.size()));
+  element_readers.push_back(
+      new UploadBytesElementReader(payload.data(), payload.size()));
 
   scoped_ptr<UploadDataStream> body(
       new UploadDataStream(element_readers.Pass(), 0));
   ASSERT_EQ(OK, body->Init(CompletionCallback()));
   // Shouldn't be merged if the in-memory body is large here.
-  ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
-      "some header", body.get()));
+  ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody("some header",
+                                                                  body.get()));
 }
 
 // Test to ensure the HttpStreamParser state machine does not get confused
@@ -196,15 +196,15 @@ TEST(HttpStreamParser, AsyncChunkAndAsyncSocket) {
   static const char kChunk3[] = "Test 3";
 
   MockWrite writes[] = {
-    MockWrite(ASYNC, 0,
-              "GET /one.html HTTP/1.1\r\n"
-              "Host: localhost\r\n"
-              "Transfer-Encoding: chunked\r\n"
-              "Connection: keep-alive\r\n\r\n"),
-    MockWrite(ASYNC, 1, "7\r\nChunk 1\r\n"),
-    MockWrite(ASYNC, 2, "8\r\nChunky 2\r\n"),
-    MockWrite(ASYNC, 3, "6\r\nTest 3\r\n"),
-    MockWrite(ASYNC, 4, "0\r\n\r\n"),
+      MockWrite(ASYNC,
+                0,
+                "GET /one.html HTTP/1.1\r\n"
+                "Host: localhost\r\n"
+                "Transfer-Encoding: chunked\r\n"
+                "Connection: keep-alive\r\n\r\n"),
+      MockWrite(ASYNC, 1, "7\r\nChunk 1\r\n"),
+      MockWrite(ASYNC, 2, "8\r\nChunky 2\r\n"),
+      MockWrite(ASYNC, 3, "6\r\nTest 3\r\n"), MockWrite(ASYNC, 4, "0\r\n\r\n"),
   };
 
   // The size of the response body, as reflected in the Content-Length of the
@@ -212,18 +212,17 @@ TEST(HttpStreamParser, AsyncChunkAndAsyncSocket) {
   static const int kBodySize = 8;
 
   MockRead reads[] = {
-    MockRead(ASYNC, 5, "HTTP/1.1 200 OK\r\n"),
-    MockRead(ASYNC, 6, "Content-Length: 8\r\n\r\n"),
-    MockRead(ASYNC, 7, "one.html"),
-    MockRead(SYNCHRONOUS, 0, 8),  // EOF
+      MockRead(ASYNC, 5, "HTTP/1.1 200 OK\r\n"),
+      MockRead(ASYNC, 6, "Content-Length: 8\r\n\r\n"),
+      MockRead(ASYNC, 7, "one.html"), MockRead(SYNCHRONOUS, 0, 8),  // EOF
   };
 
   UploadDataStream upload_stream(UploadDataStream::CHUNKED, 0);
   upload_stream.AppendChunk(kChunk1, arraysize(kChunk1) - 1, false);
   ASSERT_EQ(OK, upload_stream.Init(CompletionCallback()));
 
-  DeterministicSocketData data(reads, arraysize(reads),
-                               writes, arraysize(writes));
+  DeterministicSocketData data(
+      reads, arraysize(reads), writes, arraysize(writes));
   data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
 
   scoped_ptr<DeterministicMockTCPClientSocket> transport(
@@ -256,8 +255,10 @@ TEST(HttpStreamParser, AsyncChunkAndAsyncSocket) {
   HttpResponseInfo response_info;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
-  rv = parser.SendRequest("GET /one.html HTTP/1.1\r\n", request_headers,
-                          &response_info, callback.callback());
+  rv = parser.SendRequest("GET /one.html HTTP/1.1\r\n",
+                          request_headers,
+                          &response_info,
+                          callback.callback());
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   // Complete the initial request write. Additionally, this should enqueue the
@@ -324,46 +325,43 @@ TEST(HttpStreamParser, AsyncChunkAndAsyncSocket) {
 
 TEST(HttpStreamParser, TruncatedHeaders) {
   MockRead truncated_status_reads[] = {
-    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 20"),
-    MockRead(SYNCHRONOUS, 0, 2),  // EOF
+      MockRead(SYNCHRONOUS, 1, "HTTP/1.1 20"),
+      MockRead(SYNCHRONOUS, 0, 2),  // EOF
   };
 
   MockRead truncated_after_status_reads[] = {
-    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 Ok\r\n"),
-    MockRead(SYNCHRONOUS, 0, 2),  // EOF
+      MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 Ok\r\n"),
+      MockRead(SYNCHRONOUS, 0, 2),  // EOF
   };
 
   MockRead truncated_in_header_reads[] = {
-    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 Ok\r\nHead"),
-    MockRead(SYNCHRONOUS, 0, 2),  // EOF
+      MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 Ok\r\nHead"),
+      MockRead(SYNCHRONOUS, 0, 2),  // EOF
   };
 
   MockRead truncated_after_header_reads[] = {
-    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 Ok\r\nHeader: foo\r\n"),
-    MockRead(SYNCHRONOUS, 0, 2),  // EOF
+      MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 Ok\r\nHeader: foo\r\n"),
+      MockRead(SYNCHRONOUS, 0, 2),  // EOF
   };
 
   MockRead truncated_after_final_newline_reads[] = {
-    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 Ok\r\nHeader: foo\r\n\r"),
-    MockRead(SYNCHRONOUS, 0, 2),  // EOF
+      MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 Ok\r\nHeader: foo\r\n\r"),
+      MockRead(SYNCHRONOUS, 0, 2),  // EOF
   };
 
   MockRead not_truncated_reads[] = {
-    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 Ok\r\nHeader: foo\r\n\r\n"),
-    MockRead(SYNCHRONOUS, 0, 2),  // EOF
+      MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 Ok\r\nHeader: foo\r\n\r\n"),
+      MockRead(SYNCHRONOUS, 0, 2),  // EOF
   };
 
   MockRead* reads[] = {
-    truncated_status_reads,
-    truncated_after_status_reads,
-    truncated_in_header_reads,
-    truncated_after_header_reads,
-    truncated_after_final_newline_reads,
-    not_truncated_reads,
+      truncated_status_reads,              truncated_after_status_reads,
+      truncated_in_header_reads,           truncated_after_header_reads,
+      truncated_after_final_newline_reads, not_truncated_reads,
   };
 
   MockWrite writes[] = {
-    MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n\r\n"),
+      MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n\r\n"),
   };
 
   enum {
@@ -408,8 +406,10 @@ TEST(HttpStreamParser, TruncatedHeaders) {
 
       HttpRequestHeaders request_headers;
       HttpResponseInfo response_info;
-      rv = parser.SendRequest("GET / HTTP/1.1\r\n", request_headers,
-                              &response_info, callback.callback());
+      rv = parser.SendRequest("GET / HTTP/1.1\r\n",
+                              request_headers,
+                              &response_info,
+                              callback.callback());
       ASSERT_EQ(OK, rv);
 
       rv = parser.ReadResponseHeaders(callback.callback());
@@ -433,20 +433,21 @@ TEST(HttpStreamParser, TruncatedHeaders) {
 // follows remains in the buffer.
 TEST(HttpStreamParser, Websocket101Response) {
   MockRead reads[] = {
-    MockRead(SYNCHRONOUS, 1,
-             "HTTP/1.1 101 Switching Protocols\r\n"
-             "Upgrade: websocket\r\n"
-             "Connection: Upgrade\r\n"
-             "\r\n"
-             "a fake websocket frame"),
+      MockRead(SYNCHRONOUS,
+               1,
+               "HTTP/1.1 101 Switching Protocols\r\n"
+               "Upgrade: websocket\r\n"
+               "Connection: Upgrade\r\n"
+               "\r\n"
+               "a fake websocket frame"),
   };
 
   MockWrite writes[] = {
-    MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n\r\n"),
+      MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n\r\n"),
   };
 
-  DeterministicSocketData data(reads, arraysize(reads),
-                               writes, arraysize(writes));
+  DeterministicSocketData data(
+      reads, arraysize(reads), writes, arraysize(writes));
   data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
   data.SetStop(2);
 
@@ -473,8 +474,10 @@ TEST(HttpStreamParser, Websocket101Response) {
 
   HttpRequestHeaders request_headers;
   HttpResponseInfo response_info;
-  rv = parser.SendRequest("GET / HTTP/1.1\r\n", request_headers,
-                          &response_info, callback.callback());
+  rv = parser.SendRequest("GET / HTTP/1.1\r\n",
+                          request_headers,
+                          &response_info,
+                          callback.callback());
   ASSERT_EQ(OK, rv);
 
   rv = parser.ReadResponseHeaders(callback.callback());
@@ -484,17 +487,17 @@ TEST(HttpStreamParser, Websocket101Response) {
   EXPECT_TRUE(response_info.headers->HasHeaderValue("Connection", "Upgrade"));
   EXPECT_TRUE(response_info.headers->HasHeaderValue("Upgrade", "websocket"));
   EXPECT_EQ(read_buffer->capacity(), read_buffer->offset());
-  EXPECT_EQ("a fake websocket frame",
-            base::StringPiece(read_buffer->StartOfBuffer(),
-                              read_buffer->capacity()));
+  EXPECT_EQ(
+      "a fake websocket frame",
+      base::StringPiece(read_buffer->StartOfBuffer(), read_buffer->capacity()));
 }
 
 // Helper class for constructing HttpStreamParser and running GET requests.
 class SimpleGetRunner {
  public:
   SimpleGetRunner() : read_buffer_(new GrowableIOBuffer), sequence_number_(0) {
-    writes_.push_back(MockWrite(
-        SYNCHRONOUS, sequence_number_++, "GET / HTTP/1.1\r\n\r\n"));
+    writes_.push_back(
+        MockWrite(SYNCHRONOUS, sequence_number_++, "GET / HTTP/1.1\r\n\r\n"));
   }
 
   HttpStreamParser* parser() { return parser_.get(); }
@@ -539,8 +542,10 @@ class SimpleGetRunner {
     parser_.reset(new HttpStreamParser(
         socket_handle_.get(), &request_info_, read_buffer(), BoundNetLog()));
 
-    rv = parser_->SendRequest("GET / HTTP/1.1\r\n", request_headers_,
-                              &response_info_, callback.callback());
+    rv = parser_->SendRequest("GET / HTTP/1.1\r\n",
+                              request_headers_,
+                              &response_info_,
+                              callback.callback());
     ASSERT_EQ(OK, rv);
   }
 
@@ -595,7 +600,8 @@ TEST(HttpStreamParser, ReceivedBytesNoHeaders) {
 // Test basic case where there is no keep-alive or extra data from the socket,
 // and the entire response is received in a single read.
 TEST(HttpStreamParser, ReceivedBytesNormal) {
-  std::string headers = "HTTP/1.1 200 OK\r\n"
+  std::string headers =
+      "HTTP/1.1 200 OK\r\n"
       "Content-Length: 7\r\n\r\n";
   std::string body = "content";
   std::string response = headers + body;
@@ -616,7 +622,8 @@ TEST(HttpStreamParser, ReceivedBytesNormal) {
 // Test that bytes that represent "next" response are not counted
 // as current response "received_bytes".
 TEST(HttpStreamParser, ReceivedBytesExcludesNextResponse) {
-  std::string headers = "HTTP/1.1 200 OK\r\n"
+  std::string headers =
+      "HTTP/1.1 200 OK\r\n"
       "Content-Length:  8\r\n\r\n";
   std::string body = "content8";
   std::string response = headers + body;
@@ -647,7 +654,8 @@ TEST(HttpStreamParser, ReceivedBytesExcludesNextResponse) {
 // We setup user read buffer so it fully accepts the beginnig of response
 // body, but it is larger that remaining part of body.
 TEST(HttpStreamParser, ReceivedBytesMultiReadExcludesNextResponse) {
-  std::string headers = "HTTP/1.1 200 OK\r\n"
+  std::string headers =
+      "HTTP/1.1 200 OK\r\n"
       "Content-Length: 36\r\n\r\n";
   int64 user_buf_len = 32;
   std::string body_start = std::string(user_buf_len, '#');
@@ -679,7 +687,8 @@ TEST(HttpStreamParser, ReceivedBytesMultiReadExcludesNextResponse) {
 // In this case read buffer contains two responses. We expect that only
 // bytes that correspond to the first one are taken into account.
 TEST(HttpStreamParser, ReceivedBytesFromReadBufExcludesNextResponse) {
-  std::string headers = "HTTP/1.1 200 OK\r\n"
+  std::string headers =
+      "HTTP/1.1 200 OK\r\n"
       "Content-Length: 7\r\n\r\n";
   std::string body = "content";
   std::string response = headers + body;
@@ -726,7 +735,8 @@ TEST(HttpStreamParser, ReceivedBytesUseReadBuf) {
 // Test the case when the resulting read_buf contains both unused bytes and
 // bytes ejected by chunked-encoding filter.
 TEST(HttpStreamParser, ReceivedBytesChunkedTransferExcludesNextResponse) {
-  std::string response = "HTTP/1.1 200 OK\r\n"
+  std::string response =
+      "HTTP/1.1 200 OK\r\n"
       "Transfer-Encoding: chunked\r\n\r\n"
       "7\r\nChunk 1\r\n"
       "8\r\nChunky 2\r\n"
@@ -751,9 +761,11 @@ TEST(HttpStreamParser, ReceivedBytesChunkedTransferExcludesNextResponse) {
 // We feed data into 4-bytes reads. Also we set length of read
 // buffer to 5-bytes to test all possible buffer misaligments.
 TEST(HttpStreamParser, ReceivedBytesMultipleReads) {
-  std::string headers = "HTTP/1.1 200 OK\r\n"
+  std::string headers =
+      "HTTP/1.1 200 OK\r\n"
       "Content-Length: 33\r\n\r\n";
-  std::string body = "foo bar baz\r\n"
+  std::string body =
+      "foo bar baz\r\n"
       "sputnik mir babushka";
   std::string response = headers + body;
 
@@ -780,7 +792,8 @@ TEST(HttpStreamParser, ReceivedBytesMultipleReads) {
 // Test that "continue" HTTP header is counted as "received_bytes".
 TEST(HttpStreamParser, ReceivedBytesIncludesContinueHeader) {
   std::string status100 = "HTTP/1.1 100 OK\r\n\r\n";
-  std::string headers = "HTTP/1.1 200 OK\r\n"
+  std::string headers =
+      "HTTP/1.1 200 OK\r\n"
       "Content-Length: 7\r\n\r\n";
   int64 headers_size = status100.size() + headers.size();
   std::string body = "content";