Clang format slam.

net/test/spawned_test_server/spawner_communicator.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/spawned_test_server/spawner_communicator.h"
 
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/supports_user_data.h"
 #include "base/test/test_timeouts.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "net/base/net_util.h"
 #include "net/base/request_priority.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_test_util.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
 GURL GenerateSpawnerCommandURL(const std::string& command, uint16 port) {
   // Always performs HTTP request for sending command to the spawner server.
-  return GURL(base::StringPrintf("%s:%u/%s", "http://127.0.0.1", port,
-                                 command.c_str()));
+  return GURL(base::StringPrintf(
+      "%s:%u/%s", "http://127.0.0.1", port, command.c_str()));
 }
 
 int kBufferSize = 2048;
 
 // A class to hold all data needed to send a command to spawner server.
 class SpawnerRequestData : public base::SupportsUserData::Data {
  public:
   SpawnerRequestData(int id, int* result_code, std::string* data_received)
       : request_id_(id),
         buf_(new IOBuffer(kBufferSize)),
@@ skipping 56 matching lines @@
 };
 
 }  // namespace
 
 SpawnerCommunicator::SpawnerCommunicator(uint16 port)
     : io_thread_("spawner_communicator"),
       event_(false, false),
       port_(port),
       next_id_(0),
       weak_factory_(this),
-      is_running_(false) {}
+      is_running_(false) {
+}
 
 SpawnerCommunicator::~SpawnerCommunicator() {
   DCHECK(!is_running_);
 }
 
 void SpawnerCommunicator::WaitForResponse() {
   DCHECK_NE(base::MessageLoop::current(), io_thread_.message_loop());
   event_.Wait();
   event_.Reset();
 }
@@ skipping 29 matching lines @@
     std::string* data_received) {
   if (!result_code || !data_received)
     return;
   // Start the communicator thread to talk to test server spawner.
   StartIOThread();
   DCHECK(io_thread_.message_loop());
 
   // Since the method will be blocked until SpawnerCommunicator gets result
   // from the spawner server or timed-out. It's safe to use base::Unretained
   // when using base::Bind.
-  io_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
-      &SpawnerCommunicator::SendCommandAndWaitForResultOnIOThread,
-      base::Unretained(this), command, post_data, result_code, data_received));
+  io_thread_.message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&SpawnerCommunicator::SendCommandAndWaitForResultOnIOThread,
+                 base::Unretained(this),
+                 command,
+                 post_data,
+                 result_code,
+                 data_received));
   WaitForResponse();
 }
 
 void SpawnerCommunicator::SendCommandAndWaitForResultOnIOThread(
     const std::string& command,
     const std::string& post_data,
     int* result_code,
     std::string* data_received) {
   base::MessageLoop* loop = io_thread_.message_loop();
   DCHECK(loop);
   DCHECK_EQ(base::MessageLoop::current(), loop);
 
   // Prepare the URLRequest for sending the command.
   DCHECK(!cur_request_.get());
   context_.reset(new TestURLRequestContext);
   cur_request_ = context_->CreateRequest(
       GenerateSpawnerCommandURL(command, port_), DEFAULT_PRIORITY, this, NULL);
   DCHECK(cur_request_);
   int current_request_id = ++next_id_;
-  SpawnerRequestData* data = new SpawnerRequestData(current_request_id,
-                                                    result_code,
-                                                    data_received);
+  SpawnerRequestData* data =
+      new SpawnerRequestData(current_request_id, result_code, data_received);
   DCHECK(data);
   cur_request_->SetUserData(this, data);
 
   if (post_data.empty()) {
     cur_request_->set_method("GET");
   } else {
     cur_request_->set_method("POST");
     scoped_ptr<UploadElementReader> reader(
         UploadOwnedBytesElementReader::CreateWithString(post_data));
-    cur_request_->set_upload(make_scoped_ptr(
-        UploadDataStream::CreateWithReader(reader.Pass(), 0)));
+    cur_request_->set_upload(
+        make_scoped_ptr(UploadDataStream::CreateWithReader(reader.Pass(), 0)));
     net::HttpRequestHeaders headers;
     headers.SetHeader(net::HttpRequestHeaders::kContentType,
                       "application/json");
     cur_request_->SetExtraRequestHeaders(headers);
   }
 
   // Post a task to timeout this request if it takes too long.
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&SpawnerCommunicator::OnTimeout,
@@ skipping 120 matching lines @@
   }
 }
 
 bool SpawnerCommunicator::StartServer(const std::string& arguments,
                                       uint16* port) {
   *port = 0;
   // Send the start command to spawner server to start the Python test server
   // on remote machine.
   std::string server_return_data;
   int result_code;
-  SendCommandAndWaitForResult("start", arguments, &result_code,
-                              &server_return_data);
+  SendCommandAndWaitForResult(
+      "start", arguments, &result_code, &server_return_data);
   if (OK != result_code || server_return_data.empty())
     return false;
 
   // Check whether the data returned from spawner server is JSON-formatted.
   scoped_ptr<base::Value> value(base::JSONReader::Read(server_return_data));
   if (!value.get() || !value->IsType(base::Value::TYPE_DICTIONARY)) {
     LOG(ERROR) << "Invalid server data: " << server_return_data.c_str();
     return false;
   }
 
@@ skipping 26 matching lines @@
   std::string server_return_data;
   int result_code;
   SendCommandAndWaitForResult("kill", "", &result_code, &server_return_data);
   Shutdown();
   if (OK != result_code || server_return_data != "killed")
     return false;
   return true;
 }
 
 }  // namespace net