Clang format slam.

net/test/embedded_test_server/embedded_test_server.cc

 // Copyright (c) 2012 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/test/embedded_test_server/embedded_test_server.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 11 matching lines @@
 #include "net/test/embedded_test_server/http_response.h"
 
 namespace net {
 namespace test_server {
 
 namespace {
 
 class CustomHttpResponse : public HttpResponse {
  public:
   CustomHttpResponse(const std::string& headers, const std::string& contents)
-      : headers_(headers), contents_(contents) {
-  }
+      : headers_(headers), contents_(contents) {}
 
   virtual std::string ToResponseString() const OVERRIDE {
     return headers_ + "\r\n" + contents_;
   }
 
  private:
   std::string headers_;
   std::string contents_;
 
   DISALLOW_COPY_AND_ASSIGN(CustomHttpResponse);
 };
 
 // Handles |request| by serving a file from under |server_root|.
-scoped_ptr<HttpResponse> HandleFileRequest(
-    const base::FilePath& server_root,
-    const HttpRequest& request) {
+scoped_ptr<HttpResponse> HandleFileRequest(const base::FilePath& server_root,
+                                           const HttpRequest& request) {
   // This is a test-only server. Ignore I/O thread restrictions.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   // Trim the first byte ('/').
   std::string request_path(request.relative_url.substr(1));
 
   // Remove the query string if present.
   size_t query_pos = request_path.find('?');
   if (query_pos != std::string::npos)
     request_path = request_path.substr(0, query_pos);
@@ skipping 36 matching lines @@
 }
 
 HttpListenSocket::~HttpListenSocket() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void HttpListenSocket::DetachFromThread() {
   thread_checker_.DetachFromThread();
 }
 
-EmbeddedTestServer::EmbeddedTestServer()
-    : port_(-1),
-      weak_factory_(this) {
+EmbeddedTestServer::EmbeddedTestServer() : port_(-1), weak_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 EmbeddedTestServer::~EmbeddedTestServer() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (Started() && !ShutdownAndWaitUntilComplete()) {
     LOG(ERROR) << "EmbeddedTestServer failed to shut down.";
   }
 }
@@ skipping 85 matching lines @@
 void EmbeddedTestServer::ShutdownOnIOThread() {
   DCHECK(io_thread_->message_loop_proxy()->BelongsToCurrentThread());
 
   listen_socket_.reset();
   STLDeleteContainerPairSecondPointers(connections_.begin(),
                                        connections_.end());
   connections_.clear();
 }
 
 void EmbeddedTestServer::HandleRequest(HttpConnection* connection,
-                               scoped_ptr<HttpRequest> request) {
+                                       scoped_ptr<HttpRequest> request) {
   DCHECK(io_thread_->message_loop_proxy()->BelongsToCurrentThread());
 
   bool request_handled = false;
 
   for (size_t i = 0; i < request_handlers_.size(); ++i) {
     scoped_ptr<HttpResponse> response =
         request_handlers_[i].Run(*request.get());
     if (response.get()) {
       connection->SendResponse(response.Pass());
       request_handled = true;
       break;
     }
   }
 
   if (!request_handled) {
     LOG(WARNING) << "Request not handled. Returning 404: "
                  << request->relative_url;
     scoped_ptr<BasicHttpResponse> not_found_response(new BasicHttpResponse);
     not_found_response->set_code(HTTP_NOT_FOUND);
-    connection->SendResponse(
-        not_found_response.PassAs<HttpResponse>());
+    connection->SendResponse(not_found_response.PassAs<HttpResponse>());
   }
 
   // Drop the connection, since we do not support multiple requests per
   // connection.
   connections_.erase(connection->socket_.get());
   delete connection;
 }
 
 GURL EmbeddedTestServer::GetURL(const std::string& relative_url) const {
   DCHECK(Started()) << "You must start the server first.";
   DCHECK(StartsWithASCII(relative_url, "/", true /* case_sensitive */))
       << relative_url;
   return base_url_.Resolve(relative_url);
 }
 
 void EmbeddedTestServer::ServeFilesFromDirectory(
     const base::FilePath& directory) {
   RegisterRequestHandler(base::Bind(&HandleFileRequest, directory));
 }
 
 void EmbeddedTestServer::RegisterRequestHandler(
     const HandleRequestCallback& callback) {
   request_handlers_.push_back(callback);
 }
 
-void EmbeddedTestServer::DidAccept(
-    StreamListenSocket* server,
-    scoped_ptr<StreamListenSocket> connection) {
+void EmbeddedTestServer::DidAccept(StreamListenSocket* server,
+                                   scoped_ptr<StreamListenSocket> connection) {
   DCHECK(io_thread_->message_loop_proxy()->BelongsToCurrentThread());
 
-  HttpConnection* http_connection = new HttpConnection(
-      connection.Pass(),
-      base::Bind(&EmbeddedTestServer::HandleRequest,
-                 weak_factory_.GetWeakPtr()));
+  HttpConnection* http_connection =
+      new HttpConnection(connection.Pass(),
+                         base::Bind(&EmbeddedTestServer::HandleRequest,
+                                    weak_factory_.GetWeakPtr()));
   // TODO(szym): Make HttpConnection the StreamListenSocket delegate.
   connections_[http_connection->socket_.get()] = http_connection;
 }
 
 void EmbeddedTestServer::DidRead(StreamListenSocket* connection,
-                         const char* data,
-                         int length) {
+                                 const char* data,
+                                 int length) {
   DCHECK(io_thread_->message_loop_proxy()->BelongsToCurrentThread());
 
   HttpConnection* http_connection = FindConnection(connection);
   if (http_connection == NULL) {
     LOG(WARNING) << "Unknown connection.";
     return;
   }
   http_connection->ReceiveData(std::string(data, length));
 }
 
 void EmbeddedTestServer::DidClose(StreamListenSocket* connection) {
   DCHECK(io_thread_->message_loop_proxy()->BelongsToCurrentThread());
 
   HttpConnection* http_connection = FindConnection(connection);
   if (http_connection == NULL) {
     LOG(WARNING) << "Unknown connection.";
     return;
   }
   delete http_connection;
   connections_.erase(connection);
 }
 
-HttpConnection* EmbeddedTestServer::FindConnection(
-    StreamListenSocket* socket) {
+HttpConnection* EmbeddedTestServer::FindConnection(StreamListenSocket* socket) {
   DCHECK(io_thread_->message_loop_proxy()->BelongsToCurrentThread());
 
   std::map<StreamListenSocket*, HttpConnection*>::iterator it =
       connections_.find(socket);
   if (it == connections_.end()) {
     return NULL;
   }
   return it->second;
 }
 
@@ skipping 16 matching lines @@
           FROM_HERE, closure, run_loop.QuitClosure())) {
     return false;
   }
   run_loop.Run();
 
   return true;
 }
 
 }  // namespace test_server
 }  // namespace net