Clang format slam.

net/disk_cache/simple/simple_index_file.cc

Index: net/disk_cache/simple/simple_index_file.cc
diff --git a/net/disk_cache/simple/simple_index_file.cc b/net/disk_cache/simple/simple_index_file.cc
index 0b375f4a6cc5ed5f864c94354623e552aa8afce2..fd7d75105b0bcdf8ac4b6ff110457cee6666b30f 100644
--- a/net/disk_cache/simple/simple_index_file.cc
+++ b/net/disk_cache/simple/simple_index_file.cc
@@ -46,8 +46,8 @@ enum IndexFileState {
 };
 
 void UmaRecordIndexFileState(IndexFileState state, net::CacheType cache_type) {
-  SIMPLE_CACHE_UMA(ENUMERATION,
-                   "IndexFileStateOnLoad", cache_type, state, INDEX_STATE_MAX);
+  SIMPLE_CACHE_UMA(
+      ENUMERATION, "IndexFileStateOnLoad", cache_type, state, INDEX_STATE_MAX);
 }
 
 // Used in histograms. Please only add new values at the end.
@@ -61,8 +61,10 @@ enum IndexInitMethod {
 void UmaRecordIndexInitMethod(IndexInitMethod method,
                               net::CacheType cache_type) {
   SIMPLE_CACHE_UMA(ENUMERATION,
-                   "IndexInitializeMethod", cache_type,
-                   method, INITIALIZE_METHOD_MAX);
+                   "IndexInitializeMethod",
+                   cache_type,
+                   method,
+                   INITIALIZE_METHOD_MAX);
 }
 
 bool WritePickleFile(Pickle* pickle, const base::FilePath& file_name) {
@@ -113,9 +115,7 @@ void ProcessEntryFile(SimpleIndex::EntrySet* entries,
   SimpleIndex::EntrySet::iterator it = entries->find(hash_key);
   if (it == entries->end()) {
     SimpleIndex::InsertInEntrySet(
-        hash_key,
-        EntryMetadata(last_used_time, file_size),
-        entries);
+        hash_key, EntryMetadata(last_used_time, file_size), entries);
   } else {
     // Summing up the total size of the entry through all the *_[0-1] files
     it->second.SetEntrySize(it->second.GetEntrySize() + file_size);
@@ -124,8 +124,8 @@ void ProcessEntryFile(SimpleIndex::EntrySet* entries,
 
 }  // namespace
 
-SimpleIndexLoadResult::SimpleIndexLoadResult() : did_load(false),
-                                                 flush_required(false) {
+SimpleIndexLoadResult::SimpleIndexLoadResult()
+    : did_load(false), flush_required(false) {
 }
 
 SimpleIndexLoadResult::~SimpleIndexLoadResult() {
@@ -148,14 +148,16 @@ SimpleIndexFile::IndexMetadata::IndexMetadata()
     : magic_number_(kSimpleIndexMagicNumber),
       version_(kSimpleVersion),
       number_of_entries_(0),
-      cache_size_(0) {}
+      cache_size_(0) {
+}
 
-SimpleIndexFile::IndexMetadata::IndexMetadata(
-    uint64 number_of_entries, uint64 cache_size)
+SimpleIndexFile::IndexMetadata::IndexMetadata(uint64 number_of_entries,
+                                              uint64 cache_size)
     : magic_number_(kSimpleIndexMagicNumber),
       version_(kSimpleVersion),
       number_of_entries_(number_of_entries),
-      cache_size_(cache_size) {}
+      cache_size_(cache_size) {
+}
 
 void SimpleIndexFile::IndexMetadata::Serialize(Pickle* pickle) const {
   DCHECK(pickle);
@@ -177,10 +179,8 @@ bool SimpleIndexFile::SerializeFinalData(base::Time cache_modified,
 
 bool SimpleIndexFile::IndexMetadata::Deserialize(PickleIterator* it) {
   DCHECK(it);
-  return it->ReadUInt64(&magic_number_) &&
-      it->ReadUInt32(&version_) &&
-      it->ReadUInt64(&number_of_entries_)&&
-      it->ReadUInt64(&cache_size_);
+  return it->ReadUInt64(&magic_number_) && it->ReadUInt32(&version_) &&
+         it->ReadUInt64(&number_of_entries_) && it->ReadUInt64(&cache_size_);
 }
 
 void SimpleIndexFile::SyncWriteToDisk(net::CacheType cache_type,
@@ -218,26 +218,26 @@ void SimpleIndexFile::SyncWriteToDisk(net::CacheType cache_type,
 
   if (app_on_background) {
     SIMPLE_CACHE_UMA(TIMES,
-                     "IndexWriteToDiskTime.Background", cache_type,
+                     "IndexWriteToDiskTime.Background",
+                     cache_type,
                      (base::TimeTicks::Now() - start_time));
   } else {
     SIMPLE_CACHE_UMA(TIMES,
-                     "IndexWriteToDiskTime.Foreground", cache_type,
+                     "IndexWriteToDiskTime.Foreground",
+                     cache_type,
                      (base::TimeTicks::Now() - start_time));
   }
 }
 
 bool SimpleIndexFile::IndexMetadata::CheckIndexMetadata() {
   return number_of_entries_ <= kMaxEntiresInIndex &&
-      magic_number_ == kSimpleIndexMagicNumber &&
-      version_ == kSimpleVersion;
+         magic_number_ == kSimpleIndexMagicNumber && version_ == kSimpleVersion;
 }
 
-SimpleIndexFile::SimpleIndexFile(
-    base::SingleThreadTaskRunner* cache_thread,
-    base::TaskRunner* worker_pool,
-    net::CacheType cache_type,
-    const base::FilePath& cache_directory)
+SimpleIndexFile::SimpleIndexFile(base::SingleThreadTaskRunner* cache_thread,
+                                 base::TaskRunner* worker_pool,
+                                 net::CacheType cache_type,
+                                 const base::FilePath& cache_directory)
     : cache_thread_(cache_thread),
       worker_pool_(worker_pool),
       cache_type_(cache_type),
@@ -248,15 +248,18 @@ SimpleIndexFile::SimpleIndexFile(
                            .AppendASCII(kTempIndexFileName)) {
 }
 
-SimpleIndexFile::~SimpleIndexFile() {}
+SimpleIndexFile::~SimpleIndexFile() {
+}
 
 void SimpleIndexFile::LoadIndexEntries(base::Time cache_last_modified,
                                        const base::Closure& callback,
                                        SimpleIndexLoadResult* out_result) {
   base::Closure task = base::Bind(&SimpleIndexFile::SyncLoadIndexEntries,
                                   cache_type_,
-                                  cache_last_modified, cache_directory_,
-                                  index_file_, out_result);
+                                  cache_last_modified,
+                                  cache_directory_,
+                                  index_file_,
+                                  out_result);
   worker_pool_->PostTaskAndReply(FROM_HERE, task, callback);
 }
 
@@ -266,15 +269,15 @@ void SimpleIndexFile::WriteToDisk(const SimpleIndex::EntrySet& entry_set,
                                   bool app_on_background) {
   IndexMetadata index_metadata(entry_set.size(), cache_size);
   scoped_ptr<Pickle> pickle = Serialize(index_metadata, entry_set);
-  cache_thread_->PostTask(FROM_HERE, base::Bind(
-      &SimpleIndexFile::SyncWriteToDisk,
-      cache_type_,
-      cache_directory_,
-      index_file_,
-      temp_index_file_,
-      base::Passed(&pickle),
-      base::TimeTicks::Now(),
-      app_on_background));
+  cache_thread_->PostTask(FROM_HERE,
+                          base::Bind(&SimpleIndexFile::SyncWriteToDisk,
+                                     cache_type_,
+                                     cache_directory_,
+                                     index_file_,
+                                     temp_index_file_,
+                                     base::Passed(&pickle),
+                                     base::TimeTicks::Now(),
+                                     app_on_background));
 }
 
 // static
@@ -312,16 +315,19 @@ void SimpleIndexFile::SyncLoadIndexEntries(
   // Reconstruct the index by scanning the disk for entries.
   const base::TimeTicks start = base::TimeTicks::Now();
   SyncRestoreFromDisk(cache_directory, index_file_path, out_result);
-  SIMPLE_CACHE_UMA(MEDIUM_TIMES, "IndexRestoreTime", cache_type,
+  SIMPLE_CACHE_UMA(MEDIUM_TIMES,
+                   "IndexRestoreTime",
+                   cache_type,
                    base::TimeTicks::Now() - start);
-  SIMPLE_CACHE_UMA(COUNTS, "IndexEntriesRestored", cache_type,
-                   out_result->entries.size());
+  SIMPLE_CACHE_UMA(
+      COUNTS, "IndexEntriesRestored", cache_type, out_result->entries.size());
   if (index_file_existed) {
     UmaRecordIndexInitMethod(INITIALIZE_METHOD_RECOVERED, cache_type);
   } else {
     UmaRecordIndexInitMethod(INITIALIZE_METHOD_NEWCACHE, cache_type);
     SIMPLE_CACHE_UMA(COUNTS,
-                     "IndexCreatedEntryCount", cache_type,
+                     "IndexCreatedEntryCount",
+                     cache_type,
                      out_result->entries.size());
   }
 }
@@ -357,7 +363,8 @@ scoped_ptr<Pickle> SimpleIndexFile::Serialize(
 
   index_metadata.Serialize(pickle.get());
   for (SimpleIndex::EntrySet::const_iterator it = entries.begin();
-       it != entries.end(); ++it) {
+       it != entries.end();
+       ++it) {
     pickle->WriteUInt64(it->first);
     it->second.Serialize(pickle.get());
   }
@@ -365,7 +372,8 @@ scoped_ptr<Pickle> SimpleIndexFile::Serialize(
 }
 
 // static
-void SimpleIndexFile::Deserialize(const char* data, int data_len,
+void SimpleIndexFile::Deserialize(const char* data,
+                                  int data_len,
                                   base::Time* out_cache_last_modified,
                                   SimpleIndexLoadResult* out_result) {
   DCHECK(data);
@@ -429,10 +437,9 @@ void SimpleIndexFile::Deserialize(const char* data, int data_len,
 }
 
 // static
-void SimpleIndexFile::SyncRestoreFromDisk(
-    const base::FilePath& cache_directory,
-    const base::FilePath& index_file_path,
-    SimpleIndexLoadResult* out_result) {
+void SimpleIndexFile::SyncRestoreFromDisk(const base::FilePath& cache_directory,
+                                          const base::FilePath& index_file_path,
+                                          SimpleIndexLoadResult* out_result) {
   VLOG(1) << "Simple Cache Index is being restored from disk.";
   base::DeleteFile(index_file_path, /* recursive = */ false);
   out_result->Reset();