Clang format slam.

net/disk_cache/blockfile/stress_cache.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.
 
 // This is a simple application that stress-tests the crash recovery of the disk
 // cache. The main application starts a copy of itself on a loop, checking the
 // exit code of the child process. When the child dies in an unexpected way,
 // the main application quits.
 
 // The child application has two threads: one to exercise the cache in an
@@ skipping 84 matching lines @@
 
   key[size - 1] = '\0';
   return std::string(key);
 }
 
 // This thread will loop forever, adding and removing entries from the cache.
 // iteration is the current crash cycle, so the entries on the cache are marked
 // to know which instance of the application wrote them.
 void StressTheCache(int iteration) {
   int cache_size = 0x2000000;  // 32MB.
-  uint32 mask = 0xfff;  // 4096 entries.
+  uint32 mask = 0xfff;         // 4096 entries.
 
   base::FilePath path;
   PathService::Get(base::DIR_TEMP, &path);
   path = path.AppendASCII("cache_test_stress");
 
   base::Thread cache_thread("CacheThread");
   if (!cache_thread.StartWithOptions(
           base::Thread::Options(base::MessageLoop::TYPE_IO, 0)))
     return;
 
-  disk_cache::BackendImpl* cache =
-      new disk_cache::BackendImpl(path, mask,
-                                  cache_thread.message_loop_proxy().get(),
-                                  NULL);
+  disk_cache::BackendImpl* cache = new disk_cache::BackendImpl(
+      path, mask, cache_thread.message_loop_proxy().get(), NULL);
   cache->SetMaxSize(cache_size);
   cache->SetFlags(disk_cache::kNoLoadProtection);
 
   net::TestCompletionCallback cb;
   int rv = cache->Init(cb.callback());
 
   if (cb.GetResult(rv) != net::OK) {
     printf("Unable to initialize cache.\n");
     return;
   }
-  printf("Iteration %d, initial entries: %d\n", iteration,
-         cache->GetEntryCount());
+  printf(
+      "Iteration %d, initial entries: %d\n", iteration, cache->GetEntryCount());
 
   int seed = static_cast<int>(Time::Now().ToInternalValue());
   srand(seed);
 
-  // kNumKeys is meant to be enough to have about 3x or 4x iterations before
-  // the process crashes.
+// kNumKeys is meant to be enough to have about 3x or 4x iterations before
+// the process crashes.
 #ifdef NDEBUG
   const int kNumKeys = 4000;
 #else
   const int kNumKeys = 1200;
 #endif
   const int kNumEntries = 30;
   std::string keys[kNumKeys];
   disk_cache::Entry* entries[kNumEntries] = {0};
 
   for (int i = 0; i < kNumKeys; i++) {
@@ skipping 13 matching lines @@
     if (entries[slot])
       entries[slot]->Close();
 
     net::TestCompletionCallback cb;
     rv = cache->OpenEntry(keys[key], &entries[slot], cb.callback());
     if (cb.GetResult(rv) != net::OK) {
       rv = cache->CreateEntry(keys[key], &entries[slot], cb.callback());
       CHECK_EQ(net::OK, cb.GetResult(rv));
     }
 
-    base::snprintf(buffer->data(), kSize,
-                   "i: %d iter: %d, size: %d, truncate: %d     ", i, iteration,
-                   size, truncate ? 1 : 0);
-    rv = entries[slot]->WriteData(0, 0, buffer.get(), size, cb.callback(),
-                                  truncate);
+    base::snprintf(buffer->data(),
+                   kSize,
+                   "i: %d iter: %d, size: %d, truncate: %d     ",
+                   i,
+                   iteration,
+                   size,
+                   truncate ? 1 : 0);
+    rv = entries[slot]->WriteData(
+        0, 0, buffer.get(), size, cb.callback(), truncate);
     CHECK_EQ(size, cb.GetResult(rv));
 
     if (rand() % 100 > 80) {
       key = rand() % kNumKeys;
       net::TestCompletionCallback cb2;
       rv = cache->DoomEntry(keys[key], cb2.callback());
       cb2.GetResult(rv);
     }
 
     if (!(i % 100))
@@ skipping 42 matching lines @@
 
   RunSoon(thread->message_loop());
   return true;
 }
 
 void CrashHandler(const std::string& str) {
   g_crashing = true;
   base::debug::BreakDebugger();
 }
 
-bool MessageHandler(int severity, const char* file, int line,
-                    size_t message_start, const std::string& str) {
+bool MessageHandler(int severity,
+                    const char* file,
+                    int line,
+                    size_t message_start,
+                    const std::string& str) {
   const size_t kMaxMessageLen = 48;
   char message[kMaxMessageLen];
   size_t len = std::min(str.length() - message_start, kMaxMessageLen - 1);
 
   memcpy(message, str.c_str() + message_start, len);
   message[len] = '\0';
 #if !defined(DISK_CACHE_TRACE_TO_LOG)
   disk_cache::Trace("%s", message);
 #endif
   return false;
 }
 
 // -----------------------------------------------------------------------
 
 #if defined(OS_WIN)
 // {B9A153D4-31C3-48e4-9ABF-D54383F14A0D}
 const GUID kStressCacheTraceProviderName = {
-    0xb9a153d4, 0x31c3, 0x48e4,
-        { 0x9a, 0xbf, 0xd5, 0x43, 0x83, 0xf1, 0x4a, 0xd } };
+    0xb9a153d4,
+    0x31c3,
+    0x48e4,
+    {0x9a, 0xbf, 0xd5, 0x43, 0x83, 0xf1, 0x4a, 0xd}};
 #endif
 
 int main(int argc, const char* argv[]) {
   // Setup an AtExitManager so Singleton objects will be destructed.
   base::AtExitManager at_exit_manager;
 
   if (argc < 2)
     return MasterCode();
 
   logging::SetLogAssertHandler(CrashHandler);
@@ skipping 16 matching lines @@
   long int iteration = strtol(argv[1], &end, 0);
 
   if (!StartCrashThread()) {
     printf("failed to start thread\n");
     return kError;
   }
 
   StressTheCache(iteration);
   return 0;
 }