Clang format slam.

net/tools/dump_cache/dump_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.
 
 // Performs basic inspection of the disk cache files with minimal disruption
 // to the actual files (they still may change if an error is detected on the
 // files).
 
 #include "net/tools/dump_cache/dump_files.h"
 
@@ skipping 67 matching lines @@
   scoped_ptr<int32[]> buffer(new int32[length]);
   if (!file->Read(buffer.get(), length, offset))
     return;
 
   printf("Stats:\nSignatrure: 0x%x\n", buffer[0]);
   printf("Total size: %d\n", buffer[1]);
   for (int i = 0; i < disk_cache::Stats::kDataSizesLength; i++)
     printf("Size(%d): %d\n", i, buffer[i + 2]);
 
   int64* counters = reinterpret_cast<int64*>(
-                        buffer.get() + 2 + disk_cache::Stats::kDataSizesLength);
+      buffer.get() + 2 + disk_cache::Stats::kDataSizesLength);
   for (int i = 0; i < disk_cache::Stats::MAX_COUNTER; i++)
     printf("Count(%d): %" PRId64 "\n", i, *counters++);
   printf("-------------------------\n\n");
 }
 
 // Dumps the contents of the Index-file header.
 void DumpIndexHeader(const base::FilePath& name,
                      disk_cache::CacheAddr* stats_addr) {
   disk_cache::IndexHeader header;
   if (!ReadHeader(name, reinterpret_cast<char*>(&header), sizeof(header)))
@@ skipping 50 matching lines @@
 }
 
 // Simple class that interacts with the set of cache files.
 class CacheDumper {
  public:
   explicit CacheDumper(const base::FilePath& path)
       : path_(path),
         block_files_(path),
         index_(NULL),
         current_hash_(0),
-        next_addr_(0) {
-  }
+        next_addr_(0) {}
 
   bool Init();
 
   // Reads an entry from disk. Return false when all entries have been already
   // returned.
   bool GetEntry(disk_cache::EntryStore* entry);
 
   // Loads a specific block from the block files.
   bool LoadEntry(disk_cache::CacheAddr addr, disk_cache::EntryStore* entry);
   bool LoadRankings(disk_cache::CacheAddr addr,
@@ skipping 11 matching lines @@
 };
 
 bool CacheDumper::Init() {
   if (!block_files_.Init(false)) {
     printf("Unable to init block files\n");
     return false;
   }
 
   base::FilePath index_name(path_.Append(kIndexName));
   index_file_ = new disk_cache::MappedFile;
-  index_ = reinterpret_cast<disk_cache::Index*>(
-      index_file_->Init(index_name, 0));
+  index_ =
+      reinterpret_cast<disk_cache::Index*>(index_file_->Init(index_name, 0));
   if (!index_) {
     printf("Unable to map index\n");
     return false;
   }
 
   return true;
 }
 
 bool CacheDumper::GetEntry(disk_cache::EntryStore* entry) {
   if (dumped_entries_.find(next_addr_) != dumped_entries_.end()) {
@@ skipping 128 matching lines @@
 
   return version;
 }
 
 // Dumps the headers of all files.
 int DumpHeaders(const base::FilePath& input_path) {
   base::FilePath index_name(input_path.Append(kIndexName));
   disk_cache::CacheAddr stats_addr = 0;
   DumpIndexHeader(index_name, &stats_addr);
 
-  base::FileEnumerator iter(input_path, false,
+  base::FileEnumerator iter(input_path,
+                            false,
                             base::FileEnumerator::FILES,
                             FILE_PATH_LITERAL("data_*"));
   for (base::FilePath file = iter.Next(); !file.empty(); file = iter.Next())
     DumpBlockHeader(file);
 
   DumpStats(input_path, stats_addr);
   return 0;
 }
 
 // Dumps all entries from the cache.
@@ skipping 11 matching lines @@
     DumpEntry(entry);
     disk_cache::RankingsNode rankings;
     if (dumper.LoadRankings(entry.rankings_node, &rankings))
       DumpRankings(rankings);
   }
 
   printf("Done.\n");
 
   return 0;
 }