Clang format slam.

net/server/http_server_unittest.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 <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
@@ skipping 72 matching lines @@
       return ERR_TIMED_OUT;
     return connect_result_;
   }
 
   void Send(const std::string& data) {
     write_buffer_ =
         new DrainableIOBuffer(new StringIOBuffer(data), data.length());
     Write();
   }
 
-  bool Read(std::string* message) {
-    return Read(message, 1);
-  }
+  bool Read(std::string* message) { return Read(message, 1); }
 
   bool Read(std::string* message, int expected_bytes) {
     int total_bytes_received = 0;
     message->clear();
     while (total_bytes_received < expected_bytes) {
       net::TestCompletionCallback callback;
       ReadInternal(callback.callback());
       int bytes_received = callback.WaitForResult();
       if (bytes_received <= 0)
         return false;
@@ skipping 21 matching lines @@
 
   void OnWrite(int result) {
     ASSERT_GT(result, 0);
     write_buffer_->DidConsume(result);
     if (write_buffer_->BytesRemaining())
       Write();
   }
 
   void ReadInternal(const net::CompletionCallback& callback) {
     read_buffer_ = new IOBufferWithSize(kMaxExpectedResponseLength);
-    int result = socket_->Read(read_buffer_,
-                               kMaxExpectedResponseLength,
-                               callback);
+    int result =
+        socket_->Read(read_buffer_, kMaxExpectedResponseLength, callback);
     if (result != ERR_IO_PENDING)
       callback.Run(result);
   }
 
   scoped_refptr<IOBufferWithSize> read_buffer_;
   scoped_refptr<DrainableIOBuffer> write_buffer_;
   scoped_ptr<TCPClientSocket> socket_;
   int connect_result_;
 };
 
 }  // namespace
 
-class HttpServerTest : public testing::Test,
-                       public HttpServer::Delegate {
+class HttpServerTest : public testing::Test, public HttpServer::Delegate {
  public:
   HttpServerTest() : quit_after_request_count_(0) {}
 
   virtual void SetUp() OVERRIDE {
     TCPListenSocketFactory socket_factory("127.0.0.1", 0);
     server_ = new HttpServer(socket_factory, this);
     ASSERT_EQ(OK, server_->GetLocalAddress(&server_address_));
   }
 
   virtual void OnHttpRequest(int connection_id,
@@ skipping 47 matching lines @@
 
 TEST_F(HttpServerTest, Request) {
   TestHttpClient client;
   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
   client.Send("GET /test HTTP/1.1\r\n\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(1));
   ASSERT_EQ("GET", GetRequest(0).method);
   ASSERT_EQ("/test", GetRequest(0).path);
   ASSERT_EQ("", GetRequest(0).data);
   ASSERT_EQ(0u, GetRequest(0).headers.size());
-  ASSERT_TRUE(StartsWithASCII(GetRequest(0).peer.ToString(),
-                              "127.0.0.1",
-                              true));
+  ASSERT_TRUE(
+      StartsWithASCII(GetRequest(0).peer.ToString(), "127.0.0.1", true));
 }
 
 TEST_F(HttpServerTest, RequestWithHeaders) {
   TestHttpClient client;
   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
   const char* kHeaders[][3] = {
       {"Header", ": ", "1"},
       {"HeaderWithNoWhitespace", ":", "1"},
       {"HeaderWithWhitespace", "   :  \t   ", "1 1 1 \t  "},
       {"HeaderWithColon", ": ", "1:1"},
@@ skipping 108 matching lines @@
 
   virtual void Accept() OVERRIDE { NOTREACHED(); }
 
  private:
   virtual ~MockStreamListenSocket() {}
 };
 
 }  // namespace
 
 TEST_F(HttpServerTest, RequestWithBodySplitAcrossPackets) {
-  StreamListenSocket* socket =
-      new MockStreamListenSocket(server_.get());
+  StreamListenSocket* socket = new MockStreamListenSocket(server_.get());
   server_->DidAccept(NULL, make_scoped_ptr(socket));
   std::string body("body");
   std::string request_text = base::StringPrintf(
       "GET /test HTTP/1.1\r\n"
       "SomeHeader: 1\r\n"
       "Content-Length: %" PRIuS "\r\n\r\n%s",
       body.length(),
       body.c_str());
   server_->DidRead(socket, request_text.c_str(), request_text.length() - 2);
   ASSERT_EQ(0u, requests_.size());
@@ skipping 39 matching lines @@
 
   ASSERT_EQ(client_connection_id, GetConnectionId(2));
   server_->Send200(client_connection_id, "Content for /test3", "text/plain");
   std::string response3;
   ASSERT_TRUE(client.Read(&response3));
   ASSERT_TRUE(StartsWithASCII(response3, "HTTP/1.1 200 OK", true));
   ASSERT_TRUE(EndsWith(response3, "Content for /test3", true));
 }
 
 }  // namespace net