Clang format slam.

net/disk_cache/blockfile/block_files.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/block_files.h"
 
 #include "base/atomicops.h"
 #include "base/files/file_path.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
@@ skipping 117 matching lines @@
 
   // See what type of block will be available after we delete this one.
   int bits_at_end = 4 - size - index % 4;
   uint8 end_mask = (0xf << (4 - bits_at_end)) & 0xf;
   bool update_counters = (map_block & end_mask) == 0;
   uint8 new_value = map_block & ~(((1 << size) - 1) << (index % 4));
   int new_type = GetMapBlockType(new_value);
 
   disk_cache::FileLock lock(header_);
   STRESS_DCHECK((((1 << size) - 1) << (index % 8)) < 0x100);
-  uint8  to_clear = ((1 << size) - 1) << (index % 8);
+  uint8 to_clear = ((1 << size) - 1) << (index % 8);
   STRESS_DCHECK((byte_map[byte_index] & to_clear) == to_clear);
   byte_map[byte_index] &= ~to_clear;
 
   if (update_counters) {
     if (bits_at_end)
       header_->empty[bits_at_end - 1]--;
     header_->empty[new_type - 1]++;
     STRESS_DCHECK(header_->empty[bits_at_end - 1] >= 0);
   }
   base::subtle::MemoryBarrier();
   header_->num_entries--;
   STRESS_DCHECK(header_->num_entries >= 0);
   HISTOGRAM_TIMES("DiskCache.DeleteBlock", TimeTicks::Now() - start);
 }
 
 // Note that this is a simplified version of DeleteMapBlock().
 bool BlockHeader::UsedMapBlock(int index, int size) {
   if (size < 0 || size > kMaxNumBlocks)
     return false;
 
   int byte_index = index / 8;
   uint8* byte_map = reinterpret_cast<uint8*>(header_->allocation_map);
   uint8 map_block = byte_map[byte_index];
 
   if (index % 8 >= 4)
     map_block >>= 4;
 
   STRESS_DCHECK((((1 << size) - 1) << (index % 8)) < 0x100);
-  uint8  to_clear = ((1 << size) - 1) << (index % 8);
+  uint8 to_clear = ((1 << size) - 1) << (index % 8);
   return ((byte_map[byte_index] & to_clear) == to_clear);
 }
 
 void BlockHeader::FixAllocationCounters() {
   for (int i = 0; i < kMaxNumBlocks; i++) {
     header_->hints[i] = 0;
     header_->empty[i] = 0;
   }
 
   for (int i = 0; i < header_->max_entries / 32; i++) {
     uint32 map_block = header_->allocation_map[i];
 
     for (int j = 0; j < 8; j++, map_block >>= 4) {
       int type = GetMapBlockType(map_block);
       if (type)
-        header_->empty[type -1]++;
+        header_->empty[type - 1]++;
     }
   }
 }
 
 bool BlockHeader::NeedToGrowBlockFile(int block_count) const {
   bool have_space = false;
   int empty_blocks = 0;
   for (int i = 0; i < kMaxNumBlocks; i++) {
     empty_blocks += header_->empty[i] * (i + 1);
     if (i >= block_count - 1 && header_->empty[i])
@@ skipping 114 matching lines @@
   if (static_cast<unsigned int>(file_index) >= block_files_.size() ||
       !block_files_[file_index]) {
     // We need to open the file
     if (!OpenBlockFile(file_index))
       return NULL;
   }
   DCHECK_GE(block_files_.size(), static_cast<unsigned int>(file_index));
   return block_files_[file_index];
 }
 
-bool BlockFiles::CreateBlock(FileType block_type, int block_count,
+bool BlockFiles::CreateBlock(FileType block_type,
+                             int block_count,
                              Addr* block_address) {
   DCHECK(thread_checker_->CalledOnValidThread());
   DCHECK_NE(block_type, EXTERNAL);
   DCHECK_NE(block_type, BLOCK_FILES);
   DCHECK_NE(block_type, BLOCK_ENTRIES);
   DCHECK_NE(block_type, BLOCK_EVICTED);
   if (block_count < 1 || block_count > kMaxNumBlocks)
     return false;
 
   if (!init_)
@@ skipping 25 matching lines @@
     zero_buffer_ = new char[Addr::BlockSizeForFileType(BLOCK_4K) * 4];
     memset(zero_buffer_, 0, Addr::BlockSizeForFileType(BLOCK_4K) * 4);
   }
   MappedFile* file = GetFile(address);
   if (!file)
     return;
 
   Trace("DeleteBlock 0x%x", address.value());
 
   size_t size = address.BlockSize() * address.num_blocks();
-  size_t offset = address.start_block() * address.BlockSize() +
-                  kBlockHeaderSize;
+  size_t offset =
+      address.start_block() * address.BlockSize() + kBlockHeaderSize;
   if (deep)
     file->Write(zero_buffer_, size, offset);
 
   BlockHeader file_header(file);
   file_header.DeleteMapBlock(address.start_block(), address.num_blocks());
   file->Flush();
 
   if (!file_header.Header()->num_entries) {
     // This file is now empty. Let's try to delete it.
     FileType type = Addr::RequiredFileType(file_header.Header()->entry_size);
@@ skipping 50 matching lines @@
 
   BlockHeader header(file);
   bool rv = header.UsedMapBlock(address.start_block(), address.num_blocks());
   DCHECK(rv);
 
   static bool read_contents = false;
   if (read_contents) {
     scoped_ptr<char[]> buffer;
     buffer.reset(new char[Addr::BlockSizeForFileType(BLOCK_4K) * 4]);
     size_t size = address.BlockSize() * address.num_blocks();
-    size_t offset = address.start_block() * address.BlockSize() +
-                    kBlockHeaderSize;
+    size_t offset =
+        address.start_block() * address.BlockSize() + kBlockHeaderSize;
     bool ok = file->Read(buffer.get(), size, offset);
     DCHECK(ok);
   }
 
   return rv;
 #endif
 }
 
 bool BlockFiles::CreateBlockFile(int index, FileType file_type, bool force) {
   base::FilePath name = Name(index);
@@ skipping 273 matching lines @@
 }
 
 base::FilePath BlockFiles::Name(int index) {
   // The file format allows for 256 files.
   DCHECK(index < 256 && index >= 0);
   std::string tmp = base::StringPrintf("%s%d", kBlockName, index);
   return path_.AppendASCII(tmp);
 }
 
 }  // namespace disk_cache