Clang format slam.

net/disk_cache/blockfile/backend_worker_v3.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/blockfile/backend_worker_v3.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 55 matching lines @@
 // Sets group for the current experiment. Returns false if the files should be
 // discarded.
 bool InitExperiment(disk_cache::IndexHeader* header, bool cache_created) {
   if (header->experiment == disk_cache::EXPERIMENT_OLD_FILE1 ||
       header->experiment == disk_cache::EXPERIMENT_OLD_FILE2) {
     // Discard current cache.
     return false;
   }
 
   if (base::FieldTrialList::FindFullName("SimpleCacheTrial") ==
-          "ExperimentControl") {
+      "ExperimentControl") {
     if (cache_created) {
       header->experiment = disk_cache::EXPERIMENT_SIMPLE_CONTROL;
       return true;
     } else if (header->experiment != disk_cache::EXPERIMENT_SIMPLE_CONTROL) {
       return false;
     }
   }
 
   header->experiment = disk_cache::NO_EXPERIMENT;
   return true;
 }
 #endif  // defined(V3_NOT_JUST_YET_READY).
 
 }  // namespace
 
 // ------------------------------------------------------------------------
 
 namespace disk_cache {
 
 BackendImplV3::Worker::Worker(const base::FilePath& path,
                               base::MessageLoopProxy* main_thread)
-      : path_(path),
-        block_files_(path),
-        init_(false) {
+    : path_(path), block_files_(path), init_(false) {
 }
 
 #if defined(V3_NOT_JUST_YET_READY)
 
 int BackendImpl::SyncInit() {
 #if defined(NET_BUILD_STRESS_CACHE)
   // Start evictions right away.
   up_ticks_ = kTrimDelay * 2;
 #endif
   DCHECK(!init_);
   if (init_)
     return net::ERR_FAILED;
 
   bool create_files = false;
   if (!InitBackingStore(&create_files)) {
     ReportError(ERR_STORAGE_ERROR);
     return net::ERR_FAILED;
   }
 
   num_refs_ = num_pending_io_ = max_refs_ = 0;
   entry_count_ = byte_count_ = 0;
 
   if (!restarted_) {
     buffer_bytes_ = 0;
     trace_object_ = TraceObject::GetTraceObject();
     // Create a recurrent timer of 30 secs.
     int timer_delay = unit_test_ ? 1000 : 30000;
     timer_.reset(new base::RepeatingTimer<BackendImpl>());
-    timer_->Start(FROM_HERE, TimeDelta::FromMilliseconds(timer_delay), this,
+    timer_->Start(FROM_HERE,
+                  TimeDelta::FromMilliseconds(timer_delay),
+                  this,
                   &BackendImpl::OnStatsTimer);
   }
 
   init_ = true;
   Trace("Init");
 
   if (data_->header.experiment != NO_EXPERIMENT &&
       cache_type_ != net::DISK_CACHE) {
     // No experiment for other caches.
     return net::ERR_FAILED;
@@ skipping 163 matching lines @@
 
   return file->SetLength(GetIndexSize(header.table_len));
 }
 
 bool BackendImpl::InitBackingStore(bool* file_created) {
   if (!base::CreateDirectory(path_))
     return false;
 
   base::FilePath index_name = path_.AppendASCII(kIndexName);
 
-  int flags = base::PLATFORM_FILE_READ |
-              base::PLATFORM_FILE_WRITE |
+  int flags = base::PLATFORM_FILE_READ | base::PLATFORM_FILE_WRITE |
               base::PLATFORM_FILE_OPEN_ALWAYS |
               base::PLATFORM_FILE_EXCLUSIVE_WRITE;
   scoped_refptr<disk_cache::File> file(new disk_cache::File(
       base::CreatePlatformFile(index_name, flags, file_created, NULL)));
 
   if (!file->IsValid())
     return false;
 
   bool ret = true;
   if (*file_created)
@@ skipping 22 matching lines @@
 
 void BackendImpl::ReportError(int error) {
   STRESS_DCHECK(!error || error == ERR_PREVIOUS_CRASH ||
                 error == ERR_CACHE_CREATED);
 
   // We transmit positive numbers, instead of direct error codes.
   DCHECK_LE(error, 0);
   CACHE_UMA(CACHE_ERROR, "Error", 0, error * -1);
 }
 
-
 bool BackendImpl::CheckIndex() {
   DCHECK(data_);
 
   size_t current_size = index_->GetLength();
   if (current_size < sizeof(Index)) {
     LOG(ERROR) << "Corrupt Index file";
     return false;
   }
 
   if (new_eviction_) {
@@ skipping 69 matching lines @@
     return false;
   }
 
   // Load the required data.
   size = address.num_blocks() * address.BlockSize();
   MappedFile* file = File(address);
   if (!file)
     return false;
 
   scoped_ptr<char[]> data(new char[size]);
-  size_t offset = address.start_block() * address.BlockSize() +
-                  kBlockHeaderSize;
+  size_t offset =
+      address.start_block() * address.BlockSize() + kBlockHeaderSize;
   if (!file->Read(data.get(), size, offset))
     return false;
 
   if (!stats_.Init(data.get(), size, address))
     return false;
   if (cache_type_ == net::DISK_CACHE && ShouldReportAgain())
     stats_.InitSizeHistogram();
   return true;
 }
 
 #endif  // defined(V3_NOT_JUST_YET_READY).
 
 int BackendImplV3::Worker::Init(const CompletionCallback& callback) {
   return net::ERR_FAILED;
 }
 
 BackendImplV3::Worker::~Worker() {
 }
 
 }  // namespace disk_cache