Clang format slam.

net/disk_cache/blockfile/rankings.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/rankings.h"
 
 #include "base/metrics/histogram.h"
 #include "net/disk_cache/blockfile/backend_impl.h"
 #include "net/disk_cache/blockfile/disk_format.h"
 #include "net/disk_cache/blockfile/entry_impl.h"
 #include "net/disk_cache/blockfile/errors.h"
 #include "net/disk_cache/blockfile/histogram_macros.h"
 #include "net/disk_cache/blockfile/stress_support.h"
 
 // Provide a BackendImpl object to macros from histogram_macros.h.
 #define CACHE_UMA_BACKEND_IMPL_OBJ backend_
 
 using base::Time;
 using base::TimeTicks;
 
 namespace disk_cache {
 // This is used by crash_cache.exe to generate unit test files.
 NET_EXPORT_PRIVATE RankCrashes g_rankings_crash = NO_CRASH;
 }
 
 namespace {
 
-enum Operation {
-  INSERT = 1,
-  REMOVE
-};
+enum Operation { INSERT = 1, REMOVE };
 
 // This class provides a simple lock for the LRU list of rankings. Whenever an
 // entry is to be inserted or removed from the list, a transaction object should
 // be created to keep track of the operation. If the process crashes before
 // finishing the operation, the transaction record (stored as part of the user
 // data on the file header) can be used to finish the operation.
 class Transaction {
  public:
   // addr is the cache addres of the node being inserted or removed. We want to
   // avoid having the compiler doing optimizations on when to read or write
   // from user_data because it is the basis of the crash detection. Maybe
   // volatile is not enough for that, but it should be a good hint.
-  Transaction(volatile disk_cache::LruData* data, disk_cache::Addr addr,
-              Operation op, int list);
+  Transaction(volatile disk_cache::LruData* data,
+              disk_cache::Addr addr,
+              Operation op,
+              int list);
   ~Transaction();
+
  private:
   volatile disk_cache::LruData* data_;
   DISALLOW_COPY_AND_ASSIGN(Transaction);
 };
 
 Transaction::Transaction(volatile disk_cache::LruData* data,
-                         disk_cache::Addr addr, Operation op, int list)
+                         disk_cache::Addr addr,
+                         Operation op,
+                         int list)
     : data_(data) {
   DCHECK(!data_->transaction);
   DCHECK(addr.is_initialized());
   data_->operation = op;
   data_->operation_list = list;
   data_->transaction = addr.value();
 }
 
 Transaction::~Transaction() {
   DCHECK(data_->transaction);
   data_->transaction = 0;
   data_->operation = 0;
   data_->operation_list = 0;
 }
 
 // Code locations that can generate crashes.
 enum CrashLocation {
-  ON_INSERT_1, ON_INSERT_2, ON_INSERT_3, ON_INSERT_4, ON_REMOVE_1, ON_REMOVE_2,
-  ON_REMOVE_3, ON_REMOVE_4, ON_REMOVE_5, ON_REMOVE_6, ON_REMOVE_7, ON_REMOVE_8
+  ON_INSERT_1,
+  ON_INSERT_2,
+  ON_INSERT_3,
+  ON_INSERT_4,
+  ON_REMOVE_1,
+  ON_REMOVE_2,
+  ON_REMOVE_3,
+  ON_REMOVE_4,
+  ON_REMOVE_5,
+  ON_REMOVE_6,
+  ON_REMOVE_7,
+  ON_REMOVE_8
 };
 
 #ifndef NDEBUG
 void TerminateSelf() {
 #if defined(OS_WIN)
   // Windows does more work on _exit() than we would like, so we force exit.
   TerminateProcess(GetCurrentProcess(), 0);
 #elif defined(OS_POSIX)
   // On POSIX, _exit() will terminate the process with minimal cleanup,
   // and it is cleaner than killing.
@@ skipping 103 matching lines @@
   base::Time now = base::Time::Now();
   node->Data()->last_used = now.ToInternalValue();
   if (modified)
     node->Data()->last_modified = now.ToInternalValue();
 }
 
 }  // namespace
 
 namespace disk_cache {
 
-Rankings::ScopedRankingsBlock::ScopedRankingsBlock() : rankings_(NULL) {}
+Rankings::ScopedRankingsBlock::ScopedRankingsBlock() : rankings_(NULL) {
+}
 
 Rankings::ScopedRankingsBlock::ScopedRankingsBlock(Rankings* rankings)
-    : rankings_(rankings) {}
+    : rankings_(rankings) {
+}
 
-Rankings::ScopedRankingsBlock::ScopedRankingsBlock(
-    Rankings* rankings, CacheRankingsBlock* node)
-    : scoped_ptr<CacheRankingsBlock>(node), rankings_(rankings) {}
+Rankings::ScopedRankingsBlock::ScopedRankingsBlock(Rankings* rankings,
+                                                   CacheRankingsBlock* node)
+    : scoped_ptr<CacheRankingsBlock>(node), rankings_(rankings) {
+}
 
 Rankings::Iterator::Iterator(Rankings* rankings) {
   memset(this, 0, sizeof(Iterator));
   my_rankings = rankings;
 }
 
 Rankings::Iterator::~Iterator() {
   for (int i = 0; i < 3; i++)
     ScopedRankingsBlock(my_rankings, nodes[i]);
 }
 
-Rankings::Rankings() : init_(false) {}
+Rankings::Rankings() : init_(false) {
+}
 
-Rankings::~Rankings() {}
+Rankings::~Rankings() {
+}
 
 bool Rankings::Init(BackendImpl* backend, bool count_lists) {
   DCHECK(!init_);
   if (init_)
     return false;
 
   backend_ = backend;
   control_data_ = backend_->GetLruData();
   count_lists_ = count_lists;
 
@@ skipping 20 matching lines @@
   Trace("Insert 0x%x l %d", node->address().value(), list);
   DCHECK(node->HasData());
   Addr& my_head = heads_[list];
   Addr& my_tail = tails_[list];
   Transaction lock(control_data_, node->address(), INSERT, list);
   CacheRankingsBlock head(backend_->File(my_head), my_head);
   if (my_head.is_initialized()) {
     if (!GetRanking(&head))
       return;
 
-    if (head.Data()->prev != my_head.value() &&  // Normal path.
+    if (head.Data()->prev != my_head.value() &&          // Normal path.
         head.Data()->prev != node->address().value()) {  // FinishInsert().
       backend_->CriticalError(ERR_INVALID_LINKS);
       return;
     }
 
     head.Data()->prev = node->address().value();
     head.Store();
     GenerateCrash(ON_INSERT_1);
     UpdateIterators(&head);
   }
@@ skipping 40 matching lines @@
 //    2. r(r, b), b(r, y), head(b), tail(y)           WriteHead()
 //    3. r(r, b), b(b, y), head(b), tail(y)           next.Store()
 //    4. r(0, 0), b(b, y), head(b), tail(y)           prev.Store()
 //
 // D. Remove tail:
 //    1. a(x, r), r(a, r), head(x), tail(r)           initial state
 //    2. a(x, r), r(a, r), head(x), tail(a)           WriteTail()
 //    3. a(x, a), r(a, r), head(x), tail(a)           prev.Store()
 //    4. a(x, a), r(0, 0), head(x), tail(a)           next.Store()
 void Rankings::Remove(CacheRankingsBlock* node, List list, bool strict) {
-  Trace("Remove 0x%x (0x%x 0x%x) l %d", node->address().value(),
-        node->Data()->next, node->Data()->prev, list);
+  Trace("Remove 0x%x (0x%x 0x%x) l %d",
+        node->address().value(),
+        node->Data()->next,
+        node->Data()->prev,
+        list);
   DCHECK(node->HasData());
   if (strict)
     InvalidateIterators(node);
 
   Addr next_addr(node->Data()->next);
   Addr prev_addr(node->Data()->prev);
   if (!next_addr.is_initialized() || next_addr.is_separate_file() ||
       !prev_addr.is_initialized() || prev_addr.is_separate_file()) {
     if (next_addr.is_initialized() || prev_addr.is_initialized()) {
       LOG(ERROR) << "Invalid rankings info.";
@@ skipping 404 matching lines @@
     WriteTail(my_list);
   }
 
   next.Store();
   prev.Store();
   control_data_->transaction = 0;
   control_data_->operation = 0;
   backend_->FlushIndex();
 }
 
-bool Rankings::CheckLinks(CacheRankingsBlock* node, CacheRankingsBlock* prev,
-                          CacheRankingsBlock* next, List* list) {
+bool Rankings::CheckLinks(CacheRankingsBlock* node,
+                          CacheRankingsBlock* prev,
+                          CacheRankingsBlock* next,
+                          List* list) {
   CacheAddr node_addr = node->address().value();
-  if (prev->Data()->next == node_addr &&
-      next->Data()->prev == node_addr) {
+  if (prev->Data()->next == node_addr && next->Data()->prev == node_addr) {
     // A regular linked node.
     return true;
   }
 
-  Trace("CheckLinks 0x%x (0x%x 0x%x)", node_addr,
-        prev->Data()->next, next->Data()->prev);
+  Trace("CheckLinks 0x%x (0x%x 0x%x)",
+        node_addr,
+        prev->Data()->next,
+        next->Data()->prev);
 
   if (node_addr != prev->address().value() &&
       node_addr != next->address().value() &&
       prev->Data()->next == next->address().value() &&
       next->Data()->prev == prev->address().value()) {
     // The list is actually ok, node is wrong.
     Trace("node 0x%x out of list %d", node_addr, list);
     node->Data()->next = 0;
     node->Data()->prev = 0;
     node->Store();
     return false;
   }
 
-  if (prev->Data()->next == node_addr ||
-      next->Data()->prev == node_addr) {
+  if (prev->Data()->next == node_addr || next->Data()->prev == node_addr) {
     // Only one link is weird, lets double check.
     if (prev->Data()->next != node_addr && IsHead(node_addr, list))
       return true;
 
     if (next->Data()->prev != node_addr && IsTail(node_addr, list))
       return true;
   }
 
   LOG(ERROR) << "Inconsistent LRU.";
   STRESS_NOTREACHED();
@@ skipping 11 matching lines @@
     backend_->CriticalError(ERR_INVALID_LINKS);
     return false;
   }
 
   return true;
 }
 
 int Rankings::CheckList(List list) {
   Addr last1, last2;
   int head_items;
-  int rv = CheckListSection(list, last1, last2, true,  // Head to tail.
-                            &last1, &last2, &head_items);
+  int rv = CheckListSection(list,
+                            last1,
+                            last2,
+                            true,  // Head to tail.
+                            &last1,
+                            &last2,
+                            &head_items);
   if (rv == ERR_NO_ERROR)
     return head_items;
 
   return rv;
 }
 
 // Note that the returned error codes assume a forward walk (from head to tail)
 // so they have to be adjusted accordingly by the caller. We use two stop values
 // to be able to detect a corrupt node at the end that is not linked going back.
-int Rankings::CheckListSection(List list, Addr end1, Addr end2, bool forward,
-                               Addr* last, Addr* second_last, int* num_items) {
+int Rankings::CheckListSection(List list,
+                               Addr end1,
+                               Addr end2,
+                               bool forward,
+                               Addr* last,
+                               Addr* second_last,
+                               int* num_items) {
   Addr current = forward ? heads_[list] : tails_[list];
   *last = *second_last = current;
   *num_items = 0;
   if (!current.is_initialized())
     return ERR_NO_ERROR;
 
   if (!current.SanityCheckForRankings())
     return ERR_INVALID_HEAD;
 
   scoped_ptr<CacheRankingsBlock> node;
@@ skipping 91 matching lines @@
 void Rankings::DecrementCounter(List list) {
   if (!count_lists_)
     return;
 
   DCHECK(control_data_->sizes[list] > 0);
   if (control_data_->sizes[list] > 0)
     control_data_->sizes[list]--;
 }
 
 }  // namespace disk_cache