Clang format slam.

net/url_request/test_url_fetcher_factory.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/url_request/test_url_fetcher_factory.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_fetcher_impl.h"
 #include "net/url_request/url_fetcher_response_writer.h"
 #include "net/url_request/url_request_status.h"
 
 namespace net {
 
-ScopedURLFetcherFactory::ScopedURLFetcherFactory(
-    URLFetcherFactory* factory) {
+ScopedURLFetcherFactory::ScopedURLFetcherFactory(URLFetcherFactory* factory) {
   DCHECK(!URLFetcherImpl::factory());
   URLFetcherImpl::set_factory(factory);
 }
 
 ScopedURLFetcherFactory::~ScopedURLFetcherFactory() {
   DCHECK(URLFetcherImpl::factory());
   URLFetcherImpl::set_factory(NULL);
 }
 
-TestURLFetcher::TestURLFetcher(int id,
-                               const GURL& url,
-                               URLFetcherDelegate* d)
+TestURLFetcher::TestURLFetcher(int id, const GURL& url, URLFetcherDelegate* d)
     : owner_(NULL),
       id_(id),
       original_url_(url),
       delegate_(d),
       delegate_for_tests_(NULL),
       did_receive_last_chunk_(false),
       fake_load_flags_(0),
       fake_response_code_(-1),
       fake_response_destination_(STRING),
       fake_was_fetched_via_proxy_(false),
@@ skipping 27 matching lines @@
 void TestURLFetcher::AppendChunkToUpload(const std::string& data,
                                          bool is_last_chunk) {
   DCHECK(!did_receive_last_chunk_);
   did_receive_last_chunk_ = is_last_chunk;
   chunks_.push_back(data);
   if (delegate_for_tests_)
     delegate_for_tests_->OnChunkUpload(id_);
 }
 
 void TestURLFetcher::SetLoadFlags(int load_flags) {
-  fake_load_flags_= load_flags;
+  fake_load_flags_ = load_flags;
 }
 
 int TestURLFetcher::GetLoadFlags() const {
   return fake_load_flags_;
 }
 
 void TestURLFetcher::SetReferrer(const std::string& referrer) {
 }
 
 void TestURLFetcher::SetReferrerPolicy(
@@ skipping 55 matching lines @@
 
 void TestURLFetcher::SaveResponseWithWriter(
     scoped_ptr<URLFetcherResponseWriter> response_writer) {
   if (fake_response_destination_ == STRING) {
     response_writer_ = response_writer.Pass();
     int response = response_writer_->Initialize(CompletionCallback());
     // The TestURLFetcher doesn't handle asynchronous writes.
     DCHECK_EQ(OK, response);
 
     scoped_refptr<IOBuffer> buffer(new StringIOBuffer(fake_response_string_));
-    response = response_writer_->Write(buffer.get(),
-                                       fake_response_string_.size(),
-                                       CompletionCallback());
+    response = response_writer_->Write(
+        buffer.get(), fake_response_string_.size(), CompletionCallback());
     DCHECK_EQ(static_cast<int>(fake_response_string_.size()), response);
     response = response_writer_->Finish(CompletionCallback());
     DCHECK_EQ(OK, response);
   } else {
     NOTIMPLEMENTED();
   }
 }
 
 HttpResponseHeaders* TestURLFetcher::GetResponseHeaders() const {
   return fake_response_headers_.get();
@@ skipping 40 matching lines @@
 bool TestURLFetcher::GetResponseAsString(
     std::string* out_response_string) const {
   if (fake_response_destination_ != STRING)
     return false;
 
   *out_response_string = fake_response_string_;
   return true;
 }
 
 bool TestURLFetcher::GetResponseAsFilePath(
-    bool take_ownership, base::FilePath* out_response_path) const {
+    bool take_ownership,
+    base::FilePath* out_response_path) const {
   if (fake_response_destination_ != TEMP_FILE)
     return false;
 
   *out_response_path = fake_response_file_path_;
   return true;
 }
 
-void TestURLFetcher::GetExtraRequestHeaders(
-    HttpRequestHeaders* headers) const {
+void TestURLFetcher::GetExtraRequestHeaders(HttpRequestHeaders* headers) const {
   *headers = fake_extra_request_headers_;
 }
 
 void TestURLFetcher::set_status(const URLRequestStatus& status) {
   fake_status_ = status;
 }
 
 void TestURLFetcher::set_was_fetched_via_proxy(bool flag) {
   fake_was_fetched_via_proxy_ = flag;
 }
@@ skipping 20 matching lines @@
   fake_response_destination_ = TEMP_FILE;
   fake_response_file_path_ = path;
 }
 
 TestURLFetcherFactory::TestURLFetcherFactory()
     : ScopedURLFetcherFactory(this),
       delegate_for_tests_(NULL),
       remove_fetcher_on_delete_(false) {
 }
 
-TestURLFetcherFactory::~TestURLFetcherFactory() {}
+TestURLFetcherFactory::~TestURLFetcherFactory() {
+}
 
 URLFetcher* TestURLFetcherFactory::CreateURLFetcher(
     int id,
     const GURL& url,
     URLFetcher::RequestType request_type,
     URLFetcherDelegate* d) {
   TestURLFetcher* fetcher = new TestURLFetcher(id, url, d);
   if (remove_fetcher_on_delete_)
     fetcher->set_owner(this);
   fetcher->SetDelegateForTests(delegate_for_tests_);
@@ skipping 15 matching lines @@
 void TestURLFetcherFactory::SetDelegateForTests(
     TestURLFetcherDelegateForTests* delegate_for_tests) {
   delegate_for_tests_ = delegate_for_tests;
 }
 
 FakeURLFetcher::FakeURLFetcher(const GURL& url,
                                URLFetcherDelegate* d,
                                const std::string& response_data,
                                HttpStatusCode response_code,
                                URLRequestStatus::Status status)
-    : TestURLFetcher(0, url, d),
-      weak_factory_(this) {
+    : TestURLFetcher(0, url, d), weak_factory_(this) {
   Error error = OK;
-  switch(status) {
+  switch (status) {
     case URLRequestStatus::SUCCESS:
       // |error| is initialized to OK.
       break;
     case URLRequestStatus::IO_PENDING:
       error = ERR_IO_PENDING;
       break;
     case URLRequestStatus::CANCELED:
       error = ERR_ABORTED;
       break;
     case URLRequestStatus::FAILED:
       error = ERR_FAILED;
       break;
   }
   set_status(URLRequestStatus(status, error));
   set_response_code(response_code);
   SetResponseString(response_data);
 }
 
-FakeURLFetcher::~FakeURLFetcher() {}
+FakeURLFetcher::~FakeURLFetcher() {
+}
 
 void FakeURLFetcher::Start() {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&FakeURLFetcher::RunDelegate, weak_factory_.GetWeakPtr()));
 }
 
 void FakeURLFetcher::RunDelegate() {
   delegate()->OnURLFetchComplete(this);
 }
 
 const GURL& FakeURLFetcher::GetURL() const {
   return TestURLFetcher::GetOriginalURL();
 }
 
-FakeURLFetcherFactory::FakeURLFetcherFactory(
-    URLFetcherFactory* default_factory)
+FakeURLFetcherFactory::FakeURLFetcherFactory(URLFetcherFactory* default_factory)
     : ScopedURLFetcherFactory(this),
       creator_(base::Bind(&DefaultFakeURLFetcherCreator)),
       default_factory_(default_factory) {
 }
 
 FakeURLFetcherFactory::FakeURLFetcherFactory(
     URLFetcherFactory* default_factory,
     const FakeURLFetcherCreator& creator)
     : ScopedURLFetcherFactory(this),
       creator_(creator),
       default_factory_(default_factory) {
 }
 
 scoped_ptr<FakeURLFetcher> FakeURLFetcherFactory::DefaultFakeURLFetcherCreator(
-      const GURL& url,
-      URLFetcherDelegate* delegate,
-      const std::string& response_data,
-      HttpStatusCode response_code,
-      URLRequestStatus::Status status) {
+    const GURL& url,
+    URLFetcherDelegate* delegate,
+    const std::string& response_data,
+    HttpStatusCode response_code,
+    URLRequestStatus::Status status) {
   return scoped_ptr<FakeURLFetcher>(
       new FakeURLFetcher(url, delegate, response_data, response_code, status));
 }
 
-FakeURLFetcherFactory::~FakeURLFetcherFactory() {}
+FakeURLFetcherFactory::~FakeURLFetcherFactory() {
+}
 
 URLFetcher* FakeURLFetcherFactory::CreateURLFetcher(
     int id,
     const GURL& url,
     URLFetcher::RequestType request_type,
     URLFetcherDelegate* d) {
   FakeResponseMap::const_iterator it = fake_responses_.find(url);
   if (it == fake_responses_.end()) {
     if (default_factory_ == NULL) {
       // If we don't have a baked response for that URL we return NULL.
       DLOG(ERROR) << "No baked response for URL: " << url.spec();
       return NULL;
     } else {
       return default_factory_->CreateURLFetcher(id, url, request_type, d);
     }
   }
 
   scoped_ptr<FakeURLFetcher> fake_fetcher =
-      creator_.Run(url, d, it->second.response_data,
-                   it->second.response_code, it->second.status);
+      creator_.Run(url,
+                   d,
+                   it->second.response_data,
+                   it->second.response_code,
+                   it->second.status);
   // TODO: Make URLFetcherFactory::CreateURLFetcher return a scoped_ptr
   return fake_fetcher.release();
 }
 
-void FakeURLFetcherFactory::SetFakeResponse(
-    const GURL& url,
-    const std::string& response_data,
-    HttpStatusCode response_code,
-    URLRequestStatus::Status status) {
+void FakeURLFetcherFactory::SetFakeResponse(const GURL& url,
+                                            const std::string& response_data,
+                                            HttpStatusCode response_code,
+                                            URLRequestStatus::Status status) {
   // Overwrite existing URL if it already exists.
   FakeURLResponse response;
   response.response_data = response_data;
   response.response_code = response_code;
   response.status = status;
   fake_responses_[url] = response;
 }
 
 void FakeURLFetcherFactory::ClearFakeResponses() {
   fake_responses_.clear();
 }
 
-URLFetcherImplFactory::URLFetcherImplFactory() {}
+URLFetcherImplFactory::URLFetcherImplFactory() {
+}
 
-URLFetcherImplFactory::~URLFetcherImplFactory() {}
+URLFetcherImplFactory::~URLFetcherImplFactory() {
+}
 
 URLFetcher* URLFetcherImplFactory::CreateURLFetcher(
     int id,
     const GURL& url,
     URLFetcher::RequestType request_type,
     URLFetcherDelegate* d) {
   return new URLFetcherImpl(url, request_type, d);
 }
 
 }  // namespace net