Clang format slam.

net/http/mock_http_cache.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/http/mock_http_cache.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
@@ skipping 33 matching lines @@
 
 //-----------------------------------------------------------------------------
 
 struct MockDiskEntry::CallbackInfo {
   scoped_refptr<MockDiskEntry> entry;
   net::CompletionCallback callback;
   int result;
 };
 
 MockDiskEntry::MockDiskEntry(const std::string& key)
-    : key_(key), doomed_(false), sparse_(false),
-      fail_requests_(false), fail_sparse_requests_(false), busy_(false),
+    : key_(key),
+      doomed_(false),
+      sparse_(false),
+      fail_requests_(false),
+      fail_sparse_requests_(false),
+      busy_(false),
       delayed_(false) {
   test_mode_ = GetTestModeForEntry(key);
 }
 
 void MockDiskEntry::Doom() {
   doomed_ = true;
 }
 
 void MockDiskEntry::Close() {
   Release();
 }
 
 std::string MockDiskEntry::GetKey() const {
   return key_;
 }
 
 base::Time MockDiskEntry::GetLastUsed() const {
   return base::Time::FromInternalValue(0);
 }
 
 base::Time MockDiskEntry::GetLastModified() const {
   return base::Time::FromInternalValue(0);
 }
 
 int32 MockDiskEntry::GetDataSize(int index) const {
   DCHECK(index >= 0 && index < kNumCacheEntryDataIndices);
   return static_cast<int32>(data_[index].size());
 }
 
-int MockDiskEntry::ReadData(
-    int index, int offset, net::IOBuffer* buf, int buf_len,
-    const net::CompletionCallback& callback) {
+int MockDiskEntry::ReadData(int index,
+                            int offset,
+                            net::IOBuffer* buf,
+                            int buf_len,
+                            const net::CompletionCallback& callback) {
   DCHECK(index >= 0 && index < kNumCacheEntryDataIndices);
   DCHECK(!callback.is_null());
 
   if (fail_requests_)
     return net::ERR_CACHE_READ_FAILURE;
 
   if (offset < 0 || offset > static_cast<int>(data_[index].size()))
     return net::ERR_FAILED;
   if (static_cast<size_t>(offset) == data_[index].size())
     return 0;
 
   int num = std::min(buf_len, static_cast<int>(data_[index].size()) - offset);
   memcpy(buf->data(), &data_[index][offset], num);
 
   if (MockHttpCache::GetTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_READ)
     return num;
 
   CallbackLater(callback, num);
   return net::ERR_IO_PENDING;
 }
 
-int MockDiskEntry::WriteData(
-    int index, int offset, net::IOBuffer* buf, int buf_len,
-    const net::CompletionCallback& callback, bool truncate) {
+int MockDiskEntry::WriteData(int index,
+                             int offset,
+                             net::IOBuffer* buf,
+                             int buf_len,
+                             const net::CompletionCallback& callback,
+                             bool truncate) {
   DCHECK(index >= 0 && index < kNumCacheEntryDataIndices);
   DCHECK(!callback.is_null());
   DCHECK(truncate);
 
   if (fail_requests_) {
     CallbackLater(callback, net::ERR_CACHE_READ_FAILURE);
     return net::ERR_IO_PENDING;
   }
 
   if (offset < 0 || offset > static_cast<int>(data_[index].size()))
     return net::ERR_FAILED;
 
   data_[index].resize(offset + buf_len);
   if (buf_len)
     memcpy(&data_[index][offset], buf->data(), buf_len);
 
   if (MockHttpCache::GetTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_WRITE)
     return buf_len;
 
   CallbackLater(callback, buf_len);
   return net::ERR_IO_PENDING;
 }
 
-int MockDiskEntry::ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
+int MockDiskEntry::ReadSparseData(int64 offset,
+                                  net::IOBuffer* buf,
+                                  int buf_len,
                                   const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   if (fail_sparse_requests_)
     return net::ERR_NOT_IMPLEMENTED;
   if (!sparse_ || busy_)
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
   if (offset < 0)
     return net::ERR_FAILED;
 
   if (fail_requests_)
     return net::ERR_CACHE_READ_FAILURE;
 
   DCHECK(offset < kint32max);
   int real_offset = static_cast<int>(offset);
   if (!buf_len)
     return 0;
 
-  int num = std::min(static_cast<int>(data_[1].size()) - real_offset,
-                     buf_len);
+  int num = std::min(static_cast<int>(data_[1].size()) - real_offset, buf_len);
   memcpy(buf->data(), &data_[1][real_offset], num);
 
   if (MockHttpCache::GetTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_READ)
     return num;
 
   CallbackLater(callback, num);
   busy_ = true;
   delayed_ = false;
   return net::ERR_IO_PENDING;
 }
 
-int MockDiskEntry::WriteSparseData(int64 offset, net::IOBuffer* buf,
+int MockDiskEntry::WriteSparseData(int64 offset,
+                                   net::IOBuffer* buf,
                                    int buf_len,
                                    const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   if (fail_sparse_requests_)
     return net::ERR_NOT_IMPLEMENTED;
   if (busy_)
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
   if (!sparse_) {
     if (data_[1].size())
       return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
@@ skipping 14 matching lines @@
     data_[1].resize(real_offset + buf_len);
 
   memcpy(&data_[1][real_offset], buf->data(), buf_len);
   if (MockHttpCache::GetTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_WRITE)
     return buf_len;
 
   CallbackLater(callback, buf_len);
   return net::ERR_IO_PENDING;
 }
 
-int MockDiskEntry::GetAvailableRange(int64 offset, int len, int64* start,
+int MockDiskEntry::GetAvailableRange(int64 offset,
+                                     int len,
+                                     int64* start,
                                      const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   if (!sparse_ || busy_)
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
   if (offset < 0)
     return net::ERR_FAILED;
 
   if (fail_requests_)
     return net::ERR_CACHE_READ_FAILURE;
 
@@ skipping 71 matching lines @@
 // leveraging the fact that this class is reference counted.
 void MockDiskEntry::CallbackLater(const net::CompletionCallback& callback,
                                   int result) {
   if (ignore_callbacks_)
     return StoreAndDeliverCallbacks(true, this, callback, result);
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&MockDiskEntry::RunCallback, this, callback, result));
 }
 
-void MockDiskEntry::RunCallback(
-    const net::CompletionCallback& callback, int result) {
+void MockDiskEntry::RunCallback(const net::CompletionCallback& callback,
+                                int result) {
   if (busy_) {
     // This is kind of hacky, but controlling the behavior of just this entry
     // from a test is sort of complicated.  What we really want to do is
     // delay the delivery of a sparse IO operation a little more so that the
     // request start operation (async) will finish without seeing the end of
     // this operation (already posted to the message loop)... and without
     // just delaying for n mS (which may cause trouble with slow bots).  So
     // we re-post this operation (all async sparse IO operations will take two
     // trips through the message loop instead of one).
     if (!delayed_) {
       delayed_ = true;
       return CallbackLater(callback, result);
     }
   }
   busy_ = false;
   callback.Run(result);
 }
 
 // When |store| is true, stores the callback to be delivered later; otherwise
 // delivers any callback previously stored.
 // Static.
 void MockDiskEntry::StoreAndDeliverCallbacks(
-    bool store, MockDiskEntry* entry, const net::CompletionCallback& callback,
+    bool store,
+    MockDiskEntry* entry,
+    const net::CompletionCallback& callback,
     int result) {
   static std::vector<CallbackInfo> callback_list;
   if (store) {
     CallbackInfo c = {entry, callback, result};
     callback_list.push_back(c);
   } else {
     for (size_t i = 0; i < callback_list.size(); i++) {
       CallbackInfo& c = callback_list[i];
       c.entry->CallbackLater(c.callback, c.result);
     }
     callback_list.clear();
   }
 }
 
 // Statics.
 bool MockDiskEntry::cancel_ = false;
 bool MockDiskEntry::ignore_callbacks_ = false;
 
 //-----------------------------------------------------------------------------
 
 MockDiskCache::MockDiskCache()
-    : open_count_(0), create_count_(0), fail_requests_(false),
-      soft_failures_(false), double_create_check_(true),
+    : open_count_(0),
+      create_count_(0),
+      fail_requests_(false),
+      soft_failures_(false),
+      double_create_check_(true),
       fail_sparse_requests_(false) {
 }
 
 MockDiskCache::~MockDiskCache() {
   ReleaseAll();
 }
 
 net::CacheType MockDiskCache::GetCacheType() const {
   return net::DISK_CACHE;
 }
 
 int32 MockDiskCache::GetEntryCount() const {
   return static_cast<int32>(entries_.size());
 }
 
-int MockDiskCache::OpenEntry(const std::string& key, disk_cache::Entry** entry,
+int MockDiskCache::OpenEntry(const std::string& key,
+                             disk_cache::Entry** entry,
                              const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   if (fail_requests_)
     return net::ERR_CACHE_OPEN_FAILURE;
 
   EntryMap::iterator it = entries_.find(key);
   if (it == entries_.end())
     return net::ERR_CACHE_OPEN_FAILURE;
 
   if (it->second->is_doomed()) {
@@ skipping 83 matching lines @@
                                       const base::Time end_time,
                                       const net::CompletionCallback& callback) {
   return net::ERR_NOT_IMPLEMENTED;
 }
 
 int MockDiskCache::DoomEntriesSince(const base::Time initial_time,
                                     const net::CompletionCallback& callback) {
   return net::ERR_NOT_IMPLEMENTED;
 }
 
-int MockDiskCache::OpenNextEntry(void** iter, disk_cache::Entry** next_entry,
+int MockDiskCache::OpenNextEntry(void** iter,
+                                 disk_cache::Entry** next_entry,
                                  const net::CompletionCallback& callback) {
   return net::ERR_NOT_IMPLEMENTED;
 }
 
 void MockDiskCache::EndEnumeration(void** iter) {
 }
 
 void MockDiskCache::GetStats(
     std::vector<std::pair<std::string, std::string> >* stats) {
 }
@@ skipping 49 matching lines @@
                                      net::HttpResponseInfo* response_info,
                                      bool* response_truncated) {
   int size = disk_entry->GetDataSize(0);
 
   net::TestCompletionCallback cb;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(size));
   int rv = disk_entry->ReadData(0, 0, buffer.get(), size, cb.callback());
   rv = cb.GetResult(rv);
   EXPECT_EQ(size, rv);
 
-  return net::HttpCache::ParseResponseInfo(buffer->data(), size,
-                                           response_info,
-                                           response_truncated);
+  return net::HttpCache::ParseResponseInfo(
+      buffer->data(), size, response_info, response_truncated);
 }
 
 bool MockHttpCache::WriteResponseInfo(
-    disk_cache::Entry* disk_entry, const net::HttpResponseInfo* response_info,
-    bool skip_transient_headers, bool response_truncated) {
+    disk_cache::Entry* disk_entry,
+    const net::HttpResponseInfo* response_info,
+    bool skip_transient_headers,
+    bool response_truncated) {
   Pickle pickle;
-  response_info->Persist(
-      &pickle, skip_transient_headers, response_truncated);
+  response_info->Persist(&pickle, skip_transient_headers, response_truncated);
 
   net::TestCompletionCallback cb;
-  scoped_refptr<net::WrappedIOBuffer> data(new net::WrappedIOBuffer(
-      reinterpret_cast<const char*>(pickle.data())));
+  scoped_refptr<net::WrappedIOBuffer> data(
+      new net::WrappedIOBuffer(reinterpret_cast<const char*>(pickle.data())));
   int len = static_cast<int>(pickle.size());
 
   int rv = disk_entry->WriteData(0, 0, data.get(), len, cb.callback(), true);
   rv = cb.GetResult(rv);
   return (rv == len);
 }
 
 bool MockHttpCache::OpenBackendEntry(const std::string& key,
                                      disk_cache::Entry** entry) {
   net::TestCompletionCallback cb;
@@ skipping 26 matching lines @@
 
 int MockDiskCacheNoCB::CreateEntry(const std::string& key,
                                    disk_cache::Entry** entry,
                                    const net::CompletionCallback& callback) {
   return net::ERR_IO_PENDING;
 }
 
 //-----------------------------------------------------------------------------
 
 int MockBackendNoCbFactory::CreateBackend(
-    net::NetLog* net_log, scoped_ptr<disk_cache::Backend>* backend,
+    net::NetLog* net_log,
+    scoped_ptr<disk_cache::Backend>* backend,
     const net::CompletionCallback& callback) {
   backend->reset(new MockDiskCacheNoCB());
   return net::OK;
 }
 
 //-----------------------------------------------------------------------------
 
 MockBlockingBackendFactory::MockBlockingBackendFactory()
-    : backend_(NULL),
-      block_(true),
-      fail_(false) {
+    : backend_(NULL), block_(true), fail_(false) {
 }
 
 MockBlockingBackendFactory::~MockBlockingBackendFactory() {
 }
 
 int MockBlockingBackendFactory::CreateBackend(
-    net::NetLog* net_log, scoped_ptr<disk_cache::Backend>* backend,
+    net::NetLog* net_log,
+    scoped_ptr<disk_cache::Backend>* backend,
     const net::CompletionCallback& callback) {
   if (!block_) {
     if (!fail_)
       backend->reset(new MockDiskCache());
     return Result();
   }
 
-  backend_ =  backend;
+  backend_ = backend;
   callback_ = callback;
   return net::ERR_IO_PENDING;
 }
 
 void MockBlockingBackendFactory::FinishCreation() {
   block_ = false;
   if (!callback_.is_null()) {
     if (!fail_)
       backend_->reset(new MockDiskCache());
     net::CompletionCallback cb = callback_;
     callback_.Reset();
     cb.Run(Result());  // This object can be deleted here.
   }
 }