Clang format slam.

net/disk_cache/disk_cache_test_base.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/disk_cache/disk_cache_test_base.h"
 
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/threading/platform_thread.h"
@@ skipping 50 matching lines @@
       simple_cache_mode_(false),
       simple_cache_wait_for_index_(true),
       force_creation_(false),
       new_eviction_(false),
       first_cleanup_(true),
       integrity_(true),
       use_current_thread_(false),
       cache_thread_("CacheThread") {
 }
 
-DiskCacheTestWithCache::~DiskCacheTestWithCache() {}
+DiskCacheTestWithCache::~DiskCacheTestWithCache() {
+}
 
 void DiskCacheTestWithCache::InitCache() {
   if (memory_only_)
     InitMemoryCache();
   else
     InitDiskCache();
 
   ASSERT_TRUE(NULL != cache_);
   if (first_cleanup_)
     ASSERT_EQ(0, cache_->GetEntryCount());
@@ skipping 89 matching lines @@
   if (memory_only_ || !cache_impl_) {
     closure.Run();
     return;
   }
 
   net::TestCompletionCallback cb;
   int rv = cache_impl_->RunTaskForTest(closure, cb.callback());
   EXPECT_EQ(net::OK, cb.GetResult(rv));
 }
 
-int DiskCacheTestWithCache::ReadData(disk_cache::Entry* entry, int index,
-                                     int offset, net::IOBuffer* buf, int len) {
+int DiskCacheTestWithCache::ReadData(disk_cache::Entry* entry,
+                                     int index,
+                                     int offset,
+                                     net::IOBuffer* buf,
+                                     int len) {
   net::TestCompletionCallback cb;
   int rv = entry->ReadData(index, offset, buf, len, cb.callback());
   return cb.GetResult(rv);
 }
 
-int DiskCacheTestWithCache::WriteData(disk_cache::Entry* entry, int index,
-                                      int offset, net::IOBuffer* buf, int len,
+int DiskCacheTestWithCache::WriteData(disk_cache::Entry* entry,
+                                      int index,
+                                      int offset,
+                                      net::IOBuffer* buf,
+                                      int len,
                                       bool truncate) {
   net::TestCompletionCallback cb;
   int rv = entry->WriteData(index, offset, buf, len, cb.callback(), truncate);
   return cb.GetResult(rv);
 }
 
 int DiskCacheTestWithCache::ReadSparseData(disk_cache::Entry* entry,
-                                           int64 offset, net::IOBuffer* buf,
+                                           int64 offset,
+                                           net::IOBuffer* buf,
                                            int len) {
   net::TestCompletionCallback cb;
   int rv = entry->ReadSparseData(offset, buf, len, cb.callback());
   return cb.GetResult(rv);
 }
 
 int DiskCacheTestWithCache::WriteSparseData(disk_cache::Entry* entry,
                                             int64 offset,
-                                            net::IOBuffer* buf, int len) {
+                                            net::IOBuffer* buf,
+                                            int len) {
   net::TestCompletionCallback cb;
   int rv = entry->WriteSparseData(offset, buf, len, cb.callback());
   return cb.GetResult(rv);
 }
 
 void DiskCacheTestWithCache::TrimForTest(bool empty) {
   RunTaskForTest(base::Bind(&disk_cache::BackendImpl::TrimForTest,
                             base::Unretained(cache_impl_),
                             empty));
 }
 
 void DiskCacheTestWithCache::TrimDeletedListForTest(bool empty) {
   RunTaskForTest(base::Bind(&disk_cache::BackendImpl::TrimDeletedListForTest,
                             base::Unretained(cache_impl_),
                             empty));
 }
 
 void DiskCacheTestWithCache::AddDelay() {
   if (simple_cache_mode_) {
     // The simple cache uses second resolution for many timeouts, so it's safest
     // to advance by at least whole seconds before falling back into the normal
     // disk cache epsilon advance.
     const base::Time initial_time = base::Time::Now();
     do {
       base::PlatformThread::YieldCurrentThread();
-    } while (base::Time::Now() -
-             initial_time < base::TimeDelta::FromSeconds(1));
+    } while (base::Time::Now() - initial_time <
+             base::TimeDelta::FromSeconds(1));
   }
 
   base::Time initial = base::Time::Now();
   while (base::Time::Now() <= initial) {
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
   };
 }
 
 void DiskCacheTestWithCache::TearDown() {
   base::RunLoop().RunUntilIdle();
@@ skipping 69 matching lines @@
   if (size_)
     EXPECT_TRUE(cache_impl_->SetMaxSize(size_));
   if (new_eviction_)
     cache_impl_->SetNewEviction();
   cache_impl_->SetType(type_);
   cache_impl_->SetFlags(flags);
   net::TestCompletionCallback cb;
   int rv = cache_impl_->Init(cb.callback());
   ASSERT_EQ(net::OK, cb.GetResult(rv));
 }