Clang format slam.

net/http/mock_http_cache.cc

Index: net/http/mock_http_cache.cc
diff --git a/net/http/mock_http_cache.cc b/net/http/mock_http_cache.cc
index 5dbd486df0ff551c2dd6237e004edfab8d941df0..dddd6c3863b216f0e6dbc4f94f95edf31a1da4fe 100644
--- a/net/http/mock_http_cache.cc
+++ b/net/http/mock_http_cache.cc
@@ -51,8 +51,12 @@ struct MockDiskEntry::CallbackInfo {
 };
 
 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);
 }
@@ -82,9 +86,11 @@ int32 MockDiskEntry::GetDataSize(int index) const {
   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());
 
@@ -106,9 +112,12 @@ int MockDiskEntry::ReadData(
   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);
@@ -132,7 +141,9 @@ int MockDiskEntry::WriteData(
   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_)
@@ -150,8 +161,7 @@ int MockDiskEntry::ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
   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)
@@ -163,7 +173,8 @@ int MockDiskEntry::ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
   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());
@@ -198,7 +209,9 @@ int MockDiskEntry::WriteSparseData(int64 offset, net::IOBuffer* buf,
   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_)
@@ -290,8 +303,8 @@ void MockDiskEntry::CallbackLater(const net::CompletionCallback& callback,
       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
@@ -314,7 +327,9 @@ void MockDiskEntry::RunCallback(
 // 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) {
@@ -336,8 +351,11 @@ 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) {
 }
 
@@ -353,7 +371,8 @@ 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_)
@@ -457,7 +476,8 @@ int MockDiskCache::DoomEntriesSince(const base::Time initial_time,
   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;
 }
@@ -527,21 +547,21 @@ bool MockHttpCache::ReadResponseInfo(disk_cache::Entry* disk_entry,
   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);
@@ -588,7 +608,8 @@ int MockDiskCacheNoCB::CreateEntry(const std::string& key,
 //-----------------------------------------------------------------------------
 
 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;
@@ -597,16 +618,15 @@ int MockBackendNoCbFactory::CreateBackend(
 //-----------------------------------------------------------------------------
 
 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_)
@@ -614,7 +634,7 @@ int MockBlockingBackendFactory::CreateBackend(
     return Result();
   }
 
-  backend_ =  backend;
+  backend_ = backend;
   callback_ = callback;
   return net::ERR_IO_PENDING;
 }