Clang format slam.

net/tools/crash_cache/crash_cache.cc

 // Copyright (c) 2011 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.
 
 // This command-line program generates the set of files needed for the crash-
 // cache unit tests (DiskCacheTest,CacheBackend_Recover*). This program only
 // works properly on debug mode, because the crash functionality is not compiled
 // on release builds of the cache.
 
 #include <string>
@@ skipping 70 matching lines @@
 
 // -----------------------------------------------------------------------
 
 namespace disk_cache {
 NET_EXPORT_PRIVATE extern RankCrashes g_rankings_crash;
 }
 
 const char* kCrashEntryName = "the first key";
 
 // Creates the destinaton folder for this run, and returns it on full_path.
-bool CreateTargetFolder(const base::FilePath& path, RankCrashes action,
+bool CreateTargetFolder(const base::FilePath& path,
+                        RankCrashes action,
                         base::FilePath* full_path) {
   const char* folders[] = {
-    "",
-    "insert_empty1",
-    "insert_empty2",
-    "insert_empty3",
-    "insert_one1",
-    "insert_one2",
-    "insert_one3",
-    "insert_load1",
-    "insert_load2",
-    "remove_one1",
-    "remove_one2",
-    "remove_one3",
-    "remove_one4",
-    "remove_head1",
-    "remove_head2",
-    "remove_head3",
-    "remove_head4",
-    "remove_tail1",
-    "remove_tail2",
-    "remove_tail3",
-    "remove_load1",
-    "remove_load2",
-    "remove_load3"
-  };
+      "",             "insert_empty1", "insert_empty2", "insert_empty3",
+      "insert_one1",  "insert_one2",   "insert_one3",   "insert_load1",
+      "insert_load2", "remove_one1",   "remove_one2",   "remove_one3",
+      "remove_one4",  "remove_head1",  "remove_head2",  "remove_head3",
+      "remove_head4", "remove_tail1",  "remove_tail2",  "remove_tail3",
+      "remove_load1", "remove_load2",  "remove_load3"};
   COMPILE_ASSERT(arraysize(folders) == disk_cache::MAX_CRASH, sync_folders);
   DCHECK(action > disk_cache::NO_CRASH && action < disk_cache::MAX_CRASH);
 
   *full_path = path.AppendASCII(folders[action]);
 
   if (base::PathExists(*full_path))
     return false;
 
   return base::CreateDirectory(*full_path);
 }
 
 // Makes sure that any pending task is processed.
 void FlushQueue(disk_cache::Backend* cache) {
   net::TestCompletionCallback cb;
-  int rv =
-      reinterpret_cast<disk_cache::BackendImpl*>(cache)->FlushQueueForTest(
-          cb.callback());
+  int rv = reinterpret_cast<disk_cache::BackendImpl*>(cache)
+               ->FlushQueueForTest(cb.callback());
   cb.GetResult(rv);  // Ignore the result;
 }
 
 bool CreateCache(const base::FilePath& path,
                  base::Thread* thread,
                  disk_cache::Backend** cache,
                  net::TestCompletionCallback* cb) {
   int size = 1024 * 1024;
   disk_cache::BackendImpl* backend = new disk_cache::BackendImpl(
       path, thread->message_loop_proxy().get(), NULL);
   backend->SetMaxSize(size);
   backend->SetType(net::DISK_CACHE);
   backend->SetFlags(disk_cache::kNoRandom);
   int rv = backend->Init(cb->callback());
   *cache = backend;
   return (cb->GetResult(rv) == net::OK && !(*cache)->GetEntryCount());
 }
 
 // Generates the files for an empty and one item cache.
-int SimpleInsert(const base::FilePath& path, RankCrashes action,
+int SimpleInsert(const base::FilePath& path,
+                 RankCrashes action,
                  base::Thread* cache_thread) {
   net::TestCompletionCallback cb;
   disk_cache::Backend* cache;
   if (!CreateCache(path, cache_thread, &cache, &cb))
     return GENERIC;
 
   const char* test_name = "some other key";
 
   if (action <= disk_cache::INSERT_EMPTY_3) {
     test_name = kCrashEntryName;
@@ skipping 13 matching lines @@
   test_name = kCrashEntryName;
 
   rv = cache->CreateEntry(test_name, &entry, cb.callback());
   if (cb.GetResult(rv) != net::OK)
     return GENERIC;
 
   return NOT_REACHED;
 }
 
 // Generates the files for a one item cache, and removing the head.
-int SimpleRemove(const base::FilePath& path, RankCrashes action,
+int SimpleRemove(const base::FilePath& path,
+                 RankCrashes action,
                  base::Thread* cache_thread) {
   DCHECK(action >= disk_cache::REMOVE_ONE_1);
   DCHECK(action <= disk_cache::REMOVE_TAIL_3);
 
   net::TestCompletionCallback cb;
   disk_cache::Backend* cache;
   if (!CreateCache(path, cache_thread, &cache, &cb))
     return GENERIC;
 
   disk_cache::Entry* entry;
@@ skipping 18 matching lines @@
     return GENERIC;
 
   disk_cache::g_rankings_crash = action;
   entry->Doom();
   entry->Close();
   FlushQueue(cache);
 
   return NOT_REACHED;
 }
 
-int HeadRemove(const base::FilePath& path, RankCrashes action,
+int HeadRemove(const base::FilePath& path,
+               RankCrashes action,
                base::Thread* cache_thread) {
   DCHECK(action >= disk_cache::REMOVE_HEAD_1);
   DCHECK(action <= disk_cache::REMOVE_HEAD_4);
 
   net::TestCompletionCallback cb;
   disk_cache::Backend* cache;
   if (!CreateCache(path, cache_thread, &cache, &cb))
     return GENERIC;
 
   disk_cache::Entry* entry;
@@ skipping 16 matching lines @@
 
   disk_cache::g_rankings_crash = action;
   entry->Doom();
   entry->Close();
   FlushQueue(cache);
 
   return NOT_REACHED;
 }
 
 // Generates the files for insertion and removals on heavy loaded caches.
-int LoadOperations(const base::FilePath& path, RankCrashes action,
+int LoadOperations(const base::FilePath& path,
+                   RankCrashes action,
                    base::Thread* cache_thread) {
   DCHECK(action >= disk_cache::INSERT_LOAD_1);
 
   // Work with a tiny index table (16 entries).
   disk_cache::BackendImpl* cache = new disk_cache::BackendImpl(
       path, 0xf, cache_thread->message_loop_proxy().get(), NULL);
   if (!cache->SetMaxSize(0x100000))
     return GENERIC;
 
   // No experiments and use a simple LRU.
@@ skipping 98 matching lines @@
 
   base::FilePath path;
   PathService::Get(base::DIR_SOURCE_ROOT, &path);
   path = path.AppendASCII("net");
   path = path.AppendASCII("data");
   path = path.AppendASCII("cache_tests");
   path = path.AppendASCII("new_crashes");
 
   return SlaveCode(path, action);
 }