Clang format slam.

net/disk_cache/simple/simple_index_file.cc

 // Copyright (c) 2013 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/simple/simple_index_file.h"
 
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/files/memory_mapped_file.h"
@@ skipping 28 matching lines @@
 // Used in histograms. Please only add new values at the end.
 enum IndexFileState {
   INDEX_STATE_CORRUPT = 0,
   INDEX_STATE_STALE = 1,
   INDEX_STATE_FRESH = 2,
   INDEX_STATE_FRESH_CONCURRENT_UPDATES = 3,
   INDEX_STATE_MAX = 4,
 };
 
 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.
 enum IndexInitMethod {
   INITIALIZE_METHOD_RECOVERED = 0,
   INITIALIZE_METHOD_LOADED = 1,
   INITIALIZE_METHOD_NEWCACHE = 2,
   INITIALIZE_METHOD_MAX = 3,
 };
 
 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) {
   int bytes_written = base::WriteFile(
       file_name, static_cast<const char*>(pickle->data()), pickle->size());
   if (bytes_written != implicit_cast<int>(pickle->size())) {
     base::DeleteFile(file_name, /* recursive = */ false);
     return false;
   }
   return true;
@@ skipping 30 matching lines @@
   // guaranteed to be more accurate than mtime. It is no worse though.
   last_used_time = file_info.last_accessed;
 #endif
   if (last_used_time.is_null())
     last_used_time = file_info.last_modified;
 
   int64 file_size = file_info.size;
   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);
   }
 }
 
 }  // namespace
 
-SimpleIndexLoadResult::SimpleIndexLoadResult() : did_load(false),
-                                                 flush_required(false) {
+SimpleIndexLoadResult::SimpleIndexLoadResult()
+    : did_load(false), flush_required(false) {
 }
 
 SimpleIndexLoadResult::~SimpleIndexLoadResult() {
 }
 
 void SimpleIndexLoadResult::Reset() {
   did_load = false;
   flush_required = false;
   entries.clear();
 }
 
 // static
 const char SimpleIndexFile::kIndexFileName[] = "the-real-index";
 // static
 const char SimpleIndexFile::kIndexDirectory[] = "index-dir";
 // static
 const char SimpleIndexFile::kTempIndexFileName[] = "temp-index";
 
 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);
   pickle->WriteUInt64(magic_number_);
   pickle->WriteUInt32(version_);
   pickle->WriteUInt64(number_of_entries_);
   pickle->WriteUInt64(cache_size_);
 }
 
 // static
 bool SimpleIndexFile::SerializeFinalData(base::Time cache_modified,
                                          Pickle* pickle) {
   if (!pickle->WriteInt64(cache_modified.ToInternalValue()))
     return false;
   SimpleIndexFile::PickleHeader* header_p = pickle->headerT<PickleHeader>();
   header_p->crc = CalculatePickleCRC(*pickle);
   return true;
 }
 
 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,
                                       const base::FilePath& cache_directory,
                                       const base::FilePath& index_filename,
                                       const base::FilePath& temp_index_filename,
                                       scoped_ptr<Pickle> pickle,
                                       const base::TimeTicks& start_time,
                                       bool app_on_background) {
   // There is a chance that the index containing all the necessary data about
@@ skipping 17 matching lines @@
       return;
     }
   }
 
   // Atomically rename the temporary index file to become the real one.
   bool result = base::ReplaceFile(temp_index_filename, index_filename, NULL);
   DCHECK(result);
 
   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),
       cache_directory_(cache_directory),
       index_file_(cache_directory_.AppendASCII(kIndexDirectory)
                       .AppendASCII(kIndexFileName)),
       temp_index_file_(cache_directory_.AppendASCII(kIndexDirectory)
                            .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);
 }
 
 void SimpleIndexFile::WriteToDisk(const SimpleIndex::EntrySet& entry_set,
                                   uint64 cache_size,
                                   const base::TimeTicks& start,
                                   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
 void SimpleIndexFile::SyncLoadIndexEntries(
     net::CacheType cache_type,
     base::Time cache_last_modified,
     const base::FilePath& cache_directory,
     const base::FilePath& index_file_path,
     SimpleIndexLoadResult* out_result) {
   // Load the index and find its age.
@@ skipping 17 matching lines @@
       }
       UmaRecordIndexInitMethod(INITIALIZE_METHOD_LOADED, cache_type);
       return;
     }
     UmaRecordIndexFileState(INDEX_STATE_STALE, cache_type);
   }
 
   // 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());
   }
 }
 
 // static
 void SimpleIndexFile::SyncLoadFromDisk(const base::FilePath& index_filename,
                                        base::Time* out_last_cache_seen_by_index,
                                        SimpleIndexLoadResult* out_result) {
   out_result->Reset();
 
@@ skipping 15 matching lines @@
 }
 
 // static
 scoped_ptr<Pickle> SimpleIndexFile::Serialize(
     const SimpleIndexFile::IndexMetadata& index_metadata,
     const SimpleIndex::EntrySet& entries) {
   scoped_ptr<Pickle> pickle(new Pickle(sizeof(SimpleIndexFile::PickleHeader)));
 
   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());
   }
   return pickle.Pass();
 }
 
 // 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);
 
   out_result->Reset();
   SimpleIndex::EntrySet* entries = &out_result->entries;
 
   Pickle pickle(data, data_len);
   if (!pickle.data()) {
     LOG(WARNING) << "Corrupt Simple Index File.";
@@ skipping 43 matching lines @@
     entries->clear();
     return;
   }
   DCHECK(out_cache_last_modified);
   *out_cache_last_modified = base::Time::FromInternalValue(cache_last_modified);
 
   out_result->did_load = true;
 }
 
 // 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();
   SimpleIndex::EntrySet* entries = &out_result->entries;
 
   const bool did_succeed = TraverseCacheDirectory(
       cache_directory, base::Bind(&ProcessEntryFile, entries));
   if (!did_succeed) {
     LOG(ERROR) << "Could not reconstruct index from disk";
     return;
   }
   out_result->did_load = true;
   // When we restore from disk we write the merged index file to disk right
   // away, this might save us from having to restore again next time.
   out_result->flush_required = true;
 }
 
 // static
 bool SimpleIndexFile::LegacyIsIndexFileStale(
     base::Time cache_last_modified,
     const base::FilePath& index_file_path) {
   base::Time index_mtime;
   if (!simple_util::GetMTime(index_file_path, &index_mtime))
     return true;
   return index_mtime < cache_last_modified;
 }
 
 }  // namespace disk_cache