Clang format slam.

net/disk_cache/backend_unittest.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 "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/port.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 259 matching lines @@
     ++(*count);
     if (max_to_open >= 0 && implicit_cast<int>(*count) >= max_to_open)
       break;
   };
 
   return true;
 }
 
 void DiskCacheBackendTest::BackendBasics() {
   InitCache();
-  disk_cache::Entry *entry1 = NULL, *entry2 = NULL;
+  disk_cache::Entry* entry1 = NULL, *entry2 = NULL;
   EXPECT_NE(net::OK, OpenEntry("the first key", &entry1));
   ASSERT_EQ(net::OK, CreateEntry("the first key", &entry1));
   ASSERT_TRUE(NULL != entry1);
   entry1->Close();
   entry1 = NULL;
 
   ASSERT_EQ(net::OK, OpenEntry("the first key", &entry1));
   ASSERT_TRUE(NULL != entry1);
   entry1->Close();
   entry1 = NULL;
@@ skipping 51 matching lines @@
 
 TEST_F(DiskCacheBackendTest, ShaderCacheBasics) {
   SetCacheType(net::SHADER_CACHE);
   BackendBasics();
 }
 
 void DiskCacheBackendTest::BackendKeying() {
   InitCache();
   const char* kName1 = "the first key";
   const char* kName2 = "the first Key";
-  disk_cache::Entry *entry1, *entry2;
+  disk_cache::Entry* entry1, *entry2;
   ASSERT_EQ(net::OK, CreateEntry(kName1, &entry1));
 
   ASSERT_EQ(net::OK, CreateEntry(kName2, &entry2));
   EXPECT_TRUE(entry1 != entry2) << "Case sensitive";
   entry2->Close();
 
   char buffer[30];
   base::strlcpy(buffer, kName1, arraysize(buffer));
   ASSERT_EQ(net::OK, OpenEntry(buffer, &entry2));
   EXPECT_TRUE(entry1 == entry2);
   entry2->Close();
 
   base::strlcpy(buffer + 1, kName1, arraysize(buffer) - 1);
   ASSERT_EQ(net::OK, OpenEntry(buffer + 1, &entry2));
   EXPECT_TRUE(entry1 == entry2);
   entry2->Close();
 
-  base::strlcpy(buffer + 3,  kName1, arraysize(buffer) - 3);
+  base::strlcpy(buffer + 3, kName1, arraysize(buffer) - 3);
   ASSERT_EQ(net::OK, OpenEntry(buffer + 3, &entry2));
   EXPECT_TRUE(entry1 == entry2);
   entry2->Close();
 
   // Now verify long keys.
   char buffer2[20000];
   memset(buffer2, 's', sizeof(buffer2));
   buffer2[1023] = '\0';
   ASSERT_EQ(net::OK, CreateEntry(buffer2, &entry2)) << "key on block file";
   entry2->Close();
@@ skipping 54 matching lines @@
                                        cache_thread.message_loop_proxy().get(),
                                        NULL,
                                        &cache,
                                        cb.callback());
     ASSERT_EQ(net::OK, cb.GetResult(rv));
     ASSERT_TRUE(cache.get());
     cache.reset();
 
     rv = disk_cache::CreateCacheBackend(net::MEMORY_CACHE,
                                         net::CACHE_BACKEND_DEFAULT,
-                                        base::FilePath(), 0,
-                                        false, NULL, NULL, &cache,
+                                        base::FilePath(),
+                                        0,
+                                        false,
+                                        NULL,
+                                        NULL,
+                                        &cache,
                                         cb.callback());
     ASSERT_EQ(net::OK, cb.GetResult(rv));
     ASSERT_TRUE(cache.get());
     cache.reset();
   }
 
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 // Tests that |BackendImpl| fails to initialize with a missing file.
@@ skipping 94 matching lines @@
 
 // See crbug.com/330074
 #if !defined(OS_IOS)
 // Tests that one cache instance is not affected by another one going away.
 TEST_F(DiskCacheBackendTest, MultipleInstancesWithPendingFileIO) {
   base::ScopedTempDir store;
   ASSERT_TRUE(store.CreateUniqueTempDir());
 
   net::TestCompletionCallback cb;
   scoped_ptr<disk_cache::Backend> extra_cache;
-  int rv = disk_cache::CreateCacheBackend(
-               net::DISK_CACHE, net::CACHE_BACKEND_DEFAULT, store.path(), 0,
-               false, base::MessageLoopProxy::current().get(), NULL,
-               &extra_cache, cb.callback());
+  int rv =
+      disk_cache::CreateCacheBackend(net::DISK_CACHE,
+                                     net::CACHE_BACKEND_DEFAULT,
+                                     store.path(),
+                                     0,
+                                     false,
+                                     base::MessageLoopProxy::current().get(),
+                                     NULL,
+                                     &extra_cache,
+                                     cb.callback());
   ASSERT_EQ(net::OK, cb.GetResult(rv));
   ASSERT_TRUE(extra_cache.get() != NULL);
 
   ASSERT_TRUE(CleanupCacheDir());
   SetNewEviction();  // Match the expected behavior for integrity verification.
   UseCurrentThread();
 
   CreateBackend(disk_cache::kNoBuffering, NULL);
   rv = GeneratePendingIO(&cb);
 
@@ skipping 58 matching lines @@
 void DiskCacheBackendTest::BackendShutdownWithPendingCreate(bool fast) {
   net::TestCompletionCallback cb;
 
   {
     ASSERT_TRUE(CleanupCacheDir());
     base::Thread cache_thread("CacheThread");
     ASSERT_TRUE(cache_thread.StartWithOptions(
         base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 
     disk_cache::BackendFlags flags =
-      fast ? disk_cache::kNone : disk_cache::kNoRandom;
+        fast ? disk_cache::kNone : disk_cache::kNoRandom;
     CreateBackend(flags, &cache_thread);
 
     disk_cache::Entry* entry;
     int rv = cache_->CreateEntry("some key", &entry, cb.callback());
     ASSERT_EQ(net::ERR_IO_PENDING, rv);
 
     cache_.reset();
     EXPECT_FALSE(cb.have_result());
   }
 
@@ skipping 179 matching lines @@
 TEST_F(DiskCacheBackendTest, ShaderCacheLoad) {
   SetCacheType(net::SHADER_CACHE);
   // Work with a tiny index table (16 entries)
   SetMask(0xf);
   SetMaxSize(0x100000);
   BackendLoad();
 }
 
 // Tests the chaining of an entry to the current head.
 void DiskCacheBackendTest::BackendChain() {
-  SetMask(0x1);  // 2-entry table.
+  SetMask(0x1);        // 2-entry table.
   SetMaxSize(0x3000);  // 12 kB.
   InitCache();
 
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry("The first key", &entry));
   entry->Close();
   ASSERT_EQ(net::OK, CreateEntry("The Second key", &entry));
   entry->Close();
 }
 
@@ skipping 436 matching lines @@
 TEST_F(DiskCacheBackendTest, AppCacheEnumerations) {
   SetCacheType(net::APP_CACHE);
   BackendEnumerations();
 }
 
 // Verifies enumerations while entries are open.
 void DiskCacheBackendTest::BackendEnumerations2() {
   InitCache();
   const std::string first("first");
   const std::string second("second");
-  disk_cache::Entry *entry1, *entry2;
+  disk_cache::Entry* entry1, *entry2;
   ASSERT_EQ(net::OK, CreateEntry(first, &entry1));
   entry1->Close();
   ASSERT_EQ(net::OK, CreateEntry(second, &entry2));
   entry2->Close();
   FlushQueueForTest();
 
   // Make sure that the timestamp is not the same.
   AddDelay();
   ASSERT_EQ(net::OK, OpenEntry(second, &entry1));
   void* iter = NULL;
@@ skipping 50 matching lines @@
   BackendEnumerations2();
 }
 
 // Verify that ReadData calls do not update the LRU cache
 // when using the SHADER_CACHE type.
 TEST_F(DiskCacheBackendTest, ShaderCacheEnumerationReadData) {
   SetCacheType(net::SHADER_CACHE);
   InitCache();
   const std::string first("first");
   const std::string second("second");
-  disk_cache::Entry *entry1, *entry2;
+  disk_cache::Entry* entry1, *entry2;
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
 
   ASSERT_EQ(net::OK, CreateEntry(first, &entry1));
   memset(buffer1->data(), 0, kSize);
   base::strlcpy(buffer1->data(), "And the data to save", kSize);
   EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1.get(), kSize, false));
 
   ASSERT_EQ(net::OK, CreateEntry(second, &entry2));
   entry2->Close();
@@ skipping 14 matching lines @@
   cache_->EndEnumeration(&iter);
 }
 
 #if !defined(LEAK_SANITIZER)
 // Verify handling of invalid entries while doing enumerations.
 // We'll be leaking memory from this test.
 void DiskCacheBackendTest::BackendInvalidEntryEnumeration() {
   InitCache();
 
   std::string key("Some key");
-  disk_cache::Entry *entry, *entry1, *entry2;
+  disk_cache::Entry* entry, *entry1, *entry2;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
 
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
   memset(buffer1->data(), 0, kSize);
   base::strlcpy(buffer1->data(), "And the data to save", kSize);
   EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1.get(), kSize, false));
   entry1->Close();
   ASSERT_EQ(net::OK, OpenEntry(key, &entry1));
   EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1.get(), kSize));
@@ skipping 39 matching lines @@
 
   const int kNumEntries = 10;
   for (int i = 0; i < kNumEntries; i++) {
     std::string key = GenerateKey(true);
     disk_cache::Entry* entry;
     ASSERT_EQ(net::OK, CreateEntry(key, &entry));
     entry->Close();
   }
   EXPECT_EQ(kNumEntries, cache_->GetEntryCount());
 
-  disk_cache::Entry *entry1, *entry2;
+  disk_cache::Entry* entry1, *entry2;
   void* iter1 = NULL;
   void* iter2 = NULL;
   ASSERT_EQ(net::OK, OpenNextEntry(&iter1, &entry1));
   ASSERT_TRUE(NULL != entry1);
   entry1->Close();
   entry1 = NULL;
 
   // Let's go to the middle of the list.
   for (int i = 0; i < kNumEntries / 2; i++) {
     if (entry1)
@@ skipping 30 matching lines @@
 }
 
 TEST_F(DiskCacheBackendTest, NewEvictionFixEnumerators) {
   SetNewEviction();
   BackendFixEnumerators();
 }
 
 void DiskCacheBackendTest::BackendDoomRecent() {
   InitCache();
 
-  disk_cache::Entry *entry;
+  disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry("first", &entry));
   entry->Close();
   ASSERT_EQ(net::OK, CreateEntry("second", &entry));
   entry->Close();
   FlushQueueForTest();
 
   AddDelay();
   Time middle = Time::Now();
 
   ASSERT_EQ(net::OK, CreateEntry("third", &entry));
@@ skipping 57 matching lines @@
 
 TEST_F(DiskCacheBackendTest, DoomAllSparse) {
   InitSparseCache(NULL, NULL);
   EXPECT_EQ(net::OK, DoomAllEntries());
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 void DiskCacheBackendTest::BackendDoomBetween() {
   InitCache();
 
-  disk_cache::Entry *entry;
+  disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry("first", &entry));
   entry->Close();
   FlushQueueForTest();
 
   AddDelay();
   Time middle_start = Time::Now();
 
   ASSERT_EQ(net::OK, CreateEntry("second", &entry));
   entry->Close();
   ASSERT_EQ(net::OK, CreateEntry("third", &entry));
@@ skipping 60 matching lines @@
   DoomEntriesBetween(start, end);
   EXPECT_EQ(9, cache_->GetEntryCount());
 
   start = end;
   end = base::Time::Now();
   DoomEntriesBetween(start, end);
   EXPECT_EQ(3, cache_->GetEntryCount());
 }
 
 void DiskCacheBackendTest::BackendTransaction(const std::string& name,
-                                              int num_entries, bool load) {
+                                              int num_entries,
+                                              bool load) {
   success_ = false;
   ASSERT_TRUE(CopyTestCache(name));
   DisableFirstCleanup();
 
   uint32 mask;
   if (load) {
     mask = 0xf;
     SetMaxSize(0x100000);
   } else {
     // Clear the settings from the previous run.
@@ skipping 153 matching lines @@
 };
 
 // Tests that the disk cache successfully joins the control group, dropping the
 // existing cache in favour of a new empty cache.
 // Disabled on android since this test requires cache creator to create
 // blockfile caches.
 #if !defined(OS_ANDROID)
 TEST_F(DiskCacheTest, SimpleCacheControlJoin) {
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
-                  base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
+      base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 
   scoped_ptr<disk_cache::BackendImpl> cache =
       CreateExistingEntryCache(cache_thread, cache_path_);
   ASSERT_TRUE(cache.get());
   cache.reset();
 
   // Instantiate the SimpleCacheTrial, forcing this run into the
   // ExperimentControl group.
   base::FieldTrialList field_trial_list(new BadEntropyProvider());
   base::FieldTrialList::CreateFieldTrial("SimpleCacheTrial",
@@ skipping 19 matching lines @@
 // existing entries.
 TEST_F(DiskCacheTest, SimpleCacheControlRestart) {
   // Instantiate the SimpleCacheTrial, forcing this run into the
   // ExperimentControl group.
   base::FieldTrialList field_trial_list(new BadEntropyProvider());
   base::FieldTrialList::CreateFieldTrial("SimpleCacheTrial",
                                          "ExperimentControl");
 
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
-                  base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
+      base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 
   scoped_ptr<disk_cache::BackendImpl> cache =
       CreateExistingEntryCache(cache_thread, cache_path_);
   ASSERT_TRUE(cache.get());
 
   net::TestCompletionCallback cb;
 
   const int kRestartCount = 5;
   for (int i = 0; i < kRestartCount; ++i) {
     cache.reset(new disk_cache::BackendImpl(
@@ skipping 82 matching lines @@
   EXPECT_TRUE(CheckCacheIntegrity(cache_path_, new_eviction_, mask_));
 }
 #endif
 
 // We want to be able to deal with messed up entries on disk.
 void DiskCacheBackendTest::BackendInvalidEntry2() {
   ASSERT_TRUE(CopyTestCache("bad_entry"));
   DisableFirstCleanup();
   InitCache();
 
-  disk_cache::Entry *entry1, *entry2;
+  disk_cache::Entry* entry1, *entry2;
   ASSERT_EQ(net::OK, OpenEntry("the first key", &entry1));
   EXPECT_NE(net::OK, OpenEntry("some other key", &entry2));
   entry1->Close();
 
   // CheckCacheIntegrity will fail at this point.
   DisableIntegrityCheck();
 }
 
 TEST_F(DiskCacheBackendTest, InvalidEntry2) {
   BackendInvalidEntry2();
 }
 
 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry2) {
   SetNewEviction();
   BackendInvalidEntry2();
 }
 
 // Tests that we don't crash or hang when enumerating this cache.
 void DiskCacheBackendTest::BackendInvalidEntry3() {
-  SetMask(0x1);  // 2-entry table.
+  SetMask(0x1);        // 2-entry table.
   SetMaxSize(0x3000);  // 12 kB.
   DisableFirstCleanup();
   InitCache();
 
   disk_cache::Entry* entry;
   void* iter = NULL;
   while (OpenNextEntry(&iter, &entry) == net::OK) {
     entry->Close();
   }
 }
 
 TEST_F(DiskCacheBackendTest, InvalidEntry3) {
   ASSERT_TRUE(CopyTestCache("dirty_entry3"));
   BackendInvalidEntry3();
 }
 
 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry3) {
   ASSERT_TRUE(CopyTestCache("dirty_entry4"));
   SetNewEviction();
   BackendInvalidEntry3();
   DisableIntegrityCheck();
 }
 
 // Test that we handle a dirty entry on the LRU list, already replaced with
 // the same key, and with hash collisions.
 TEST_F(DiskCacheBackendTest, InvalidEntry4) {
   ASSERT_TRUE(CopyTestCache("dirty_entry3"));
-  SetMask(0x1);  // 2-entry table.
+  SetMask(0x1);        // 2-entry table.
   SetMaxSize(0x3000);  // 12 kB.
   DisableFirstCleanup();
   InitCache();
 
   TrimForTest(false);
 }
 
 // Test that we handle a dirty entry on the deleted list, already replaced with
 // the same key, and with hash collisions.
 TEST_F(DiskCacheBackendTest, InvalidEntry5) {
   ASSERT_TRUE(CopyTestCache("dirty_entry4"));
   SetNewEviction();
-  SetMask(0x1);  // 2-entry table.
+  SetMask(0x1);        // 2-entry table.
   SetMaxSize(0x3000);  // 12 kB.
   DisableFirstCleanup();
   InitCache();
 
   TrimDeletedListForTest(false);
 }
 
 TEST_F(DiskCacheBackendTest, InvalidEntry6) {
   ASSERT_TRUE(CopyTestCache("dirty_entry5"));
-  SetMask(0x1);  // 2-entry table.
+  SetMask(0x1);        // 2-entry table.
   SetMaxSize(0x3000);  // 12 kB.
   DisableFirstCleanup();
   InitCache();
 
   // There is a dirty entry (but marked as clean) at the end, pointing to a
   // deleted entry through the hash collision list. We should not re-insert the
   // deleted entry into the index table.
 
   TrimForTest(false);
   // The cache should be clean (as detected by CheckCacheIntegrity).
 }
 
 // Tests that we don't hang when there is a loop on the hash collision list.
 // The test cache could be a result of bug 69135.
 TEST_F(DiskCacheBackendTest, BadNextEntry1) {
   ASSERT_TRUE(CopyTestCache("list_loop2"));
-  SetMask(0x1);  // 2-entry table.
+  SetMask(0x1);        // 2-entry table.
   SetMaxSize(0x3000);  // 12 kB.
   DisableFirstCleanup();
   InitCache();
 
   // The second entry points at itselft, and the first entry is not accessible
   // though the index, but it is at the head of the LRU.
 
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry("The first key", &entry));
   entry->Close();
 
   TrimForTest(false);
   TrimForTest(false);
   ASSERT_EQ(net::OK, OpenEntry("The first key", &entry));
   entry->Close();
   EXPECT_EQ(1, cache_->GetEntryCount());
 }
 
 // Tests that we don't hang when there is a loop on the hash collision list.
 // The test cache could be a result of bug 69135.
 TEST_F(DiskCacheBackendTest, BadNextEntry2) {
   ASSERT_TRUE(CopyTestCache("list_loop3"));
-  SetMask(0x1);  // 2-entry table.
+  SetMask(0x1);        // 2-entry table.
   SetMaxSize(0x3000);  // 12 kB.
   DisableFirstCleanup();
   InitCache();
 
   // There is a wide loop of 5 entries.
 
   disk_cache::Entry* entry;
   ASSERT_NE(net::OK, OpenEntry("Not present key", &entry));
 }
 
@@ skipping 344 matching lines @@
   SetNewEviction();
   BackendTrimInvalidEntry12();
 }
 
 // We want to be able to deal with messed up entries on disk.
 void DiskCacheBackendTest::BackendInvalidRankings2() {
   ASSERT_TRUE(CopyTestCache("bad_rankings"));
   DisableFirstCleanup();
   InitCache();
 
-  disk_cache::Entry *entry1, *entry2;
+  disk_cache::Entry* entry1, *entry2;
   EXPECT_NE(net::OK, OpenEntry("the first key", &entry1));
   ASSERT_EQ(net::OK, OpenEntry("some other key", &entry2));
   entry2->Close();
 
   // CheckCacheIntegrity will fail at this point.
   DisableIntegrityCheck();
 }
 
 TEST_F(DiskCacheBackendTest, InvalidRankings2) {
   BackendInvalidRankings2();
@@ skipping 44 matching lines @@
   ASSERT_TRUE(CopyTestCache("bad_rankings"));
   DisableFirstCleanup();
   SetNewEviction();
   InitCache();
   SetTestMode();  // Fail cache reinitialization.
   BackendInvalidRankings();
 }
 
 // If the LRU is corrupt and we have open entries, we disable the cache.
 void DiskCacheBackendTest::BackendDisable() {
-  disk_cache::Entry *entry1, *entry2;
+  disk_cache::Entry* entry1, *entry2;
   void* iter = NULL;
   ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry1));
 
   EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry2));
   EXPECT_EQ(0, cache_->GetEntryCount());
   EXPECT_NE(net::OK, CreateEntry("Something new", &entry2));
 
   entry1->Close();
   FlushQueueForTest();  // Flushing the Close posts a task to restart the cache.
   FlushQueueForTest();  // This one actually allows that task to complete.
@@ skipping 78 matching lines @@
   ASSERT_TRUE(CopyTestCache("list_loop"));
   DisableFirstCleanup();
   SetNewEviction();
   InitCache();
   SetTestMode();  // Fail cache reinitialization.
   BackendDisable2();
 }
 
 // If the index size changes when we disable the cache, we should not crash.
 void DiskCacheBackendTest::BackendDisable3() {
-  disk_cache::Entry *entry1, *entry2;
+  disk_cache::Entry* entry1, *entry2;
   void* iter = NULL;
   EXPECT_EQ(2, cache_->GetEntryCount());
   ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry1));
   entry1->Close();
 
   EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry2));
   FlushQueueForTest();
 
   ASSERT_EQ(net::OK, CreateEntry("Something new", &entry2));
   entry2->Close();
@@ skipping 13 matching lines @@
   ASSERT_TRUE(CopyTestCache("bad_rankings2"));
   DisableFirstCleanup();
   SetMaxSize(20 * 1024 * 1024);
   SetNewEviction();
   InitCache();
   BackendDisable3();
 }
 
 // If we disable the cache, already open entries should work as far as possible.
 void DiskCacheBackendTest::BackendDisable4() {
-  disk_cache::Entry *entry1, *entry2, *entry3, *entry4;
+  disk_cache::Entry* entry1, *entry2, *entry3, *entry4;
   void* iter = NULL;
   ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry1));
 
   char key2[2000];
   char key3[20000];
   CacheTestFillBuffer(key2, sizeof(key2), true);
   CacheTestFillBuffer(key3, sizeof(key3), true);
   key2[sizeof(key2) - 1] = '\0';
   key3[sizeof(key3) - 1] = '\0';
   ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));
@@ skipping 103 matching lines @@
   stats.clear();
   cache_->GetStats(&stats);
   EXPECT_FALSE(stats.empty());
 
   EXPECT_EQ(1, std::count(stats.begin(), stats.end(), hits));
 }
 
 void DiskCacheBackendTest::BackendDoomAll() {
   InitCache();
 
-  disk_cache::Entry *entry1, *entry2;
+  disk_cache::Entry* entry1, *entry2;
   ASSERT_EQ(net::OK, CreateEntry("first", &entry1));
   ASSERT_EQ(net::OK, CreateEntry("second", &entry2));
   entry1->Close();
   entry2->Close();
 
   ASSERT_EQ(net::OK, CreateEntry("third", &entry1));
   ASSERT_EQ(net::OK, CreateEntry("fourth", &entry2));
 
   ASSERT_EQ(4, cache_->GetEntryCount());
   EXPECT_EQ(net::OK, DoomAllEntries());
   ASSERT_EQ(0, cache_->GetEntryCount());
 
   // We should stop posting tasks at some point (if we post any).
   base::MessageLoop::current()->RunUntilIdle();
 
-  disk_cache::Entry *entry3, *entry4;
+  disk_cache::Entry* entry3, *entry4;
   EXPECT_NE(net::OK, OpenEntry("third", &entry3));
   ASSERT_EQ(net::OK, CreateEntry("third", &entry3));
   ASSERT_EQ(net::OK, CreateEntry("fourth", &entry4));
 
   EXPECT_EQ(net::OK, DoomAllEntries());
   ASSERT_EQ(0, cache_->GetEntryCount());
 
   entry1->Close();
   entry2->Close();
   entry3->Doom();  // The entry should be already doomed, but this must work.
@@ skipping 127 matching lines @@
   EXPECT_EQ(kDefaultCacheSize - 1,
             disk_cache::PreferredCacheSize(large_size * 10 / 8 - 1));
 
   // Region 2: expected = default_size
   EXPECT_EQ(kDefaultCacheSize,
             disk_cache::PreferredCacheSize(large_size * 10 / 8));
   EXPECT_EQ(kDefaultCacheSize,
             disk_cache::PreferredCacheSize(large_size * 10 - 1));
 
   // Region 3: expected = available * 0.1
-  EXPECT_EQ(kDefaultCacheSize,
-            disk_cache::PreferredCacheSize(large_size * 10));
+  EXPECT_EQ(kDefaultCacheSize, disk_cache::PreferredCacheSize(large_size * 10));
   EXPECT_EQ((kDefaultCacheSize * 25 - 1) / 10,
             disk_cache::PreferredCacheSize(large_size * 25 - 1));
 
   // Region 4: expected = default_size * 2.5
   EXPECT_EQ(kDefaultCacheSize * 25 / 10,
             disk_cache::PreferredCacheSize(large_size * 25));
   EXPECT_EQ(kDefaultCacheSize * 25 / 10,
             disk_cache::PreferredCacheSize(large_size * 100 - 1));
   EXPECT_EQ(kDefaultCacheSize * 25 / 10,
             disk_cache::PreferredCacheSize(large_size * 100));
   EXPECT_EQ(kDefaultCacheSize * 25 / 10,
             disk_cache::PreferredCacheSize(large_size * 250 - 1));
 
   // Region 5: expected = available * 0.1
   int64 largest_size = kDefaultCacheSize * 4;
   EXPECT_EQ(kDefaultCacheSize * 25 / 10,
             disk_cache::PreferredCacheSize(large_size * 250));
   EXPECT_EQ(largest_size - 1,
             disk_cache::PreferredCacheSize(largest_size * 100 - 1));
 
   // Region 6: expected = largest possible size
-  EXPECT_EQ(largest_size,
-            disk_cache::PreferredCacheSize(largest_size * 100));
-  EXPECT_EQ(largest_size,
-            disk_cache::PreferredCacheSize(largest_size * 10000));
+  EXPECT_EQ(largest_size, disk_cache::PreferredCacheSize(largest_size * 100));
+  EXPECT_EQ(largest_size, disk_cache::PreferredCacheSize(largest_size * 10000));
 }
 
 // Tests that we can "migrate" a running instance from one experiment group to
 // another.
 TEST_F(DiskCacheBackendTest, Histograms) {
   InitCache();
   disk_cache::BackendImpl* backend_ = cache_impl_;  // Needed be the macro.
 
   for (int i = 1; i < 3; i++) {
     CACHE_UMA(HOURS, "FillupTime", i, 28);
@@ skipping 74 matching lines @@
   file->Init(name);
 
 #if defined(OS_WIN)
   DWORD sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
   DWORD access = GENERIC_READ | GENERIC_WRITE;
   base::win::ScopedHandle file2(CreateFile(
       name.value().c_str(), access, sharing, NULL, OPEN_EXISTING, 0, NULL));
   EXPECT_FALSE(file2.IsValid());
 
   sharing |= FILE_SHARE_DELETE;
-  file2.Set(CreateFile(name.value().c_str(), access, sharing, NULL,
-                       OPEN_EXISTING, 0, NULL));
+  file2.Set(CreateFile(
+      name.value().c_str(), access, sharing, NULL, OPEN_EXISTING, 0, NULL));
   EXPECT_TRUE(file2.IsValid());
 #endif
 
   EXPECT_TRUE(base::DeleteFile(name, false));
 
   // We should be able to use the file.
   const int kSize = 200;
   char buffer1[kSize];
   char buffer2[kSize];
   memset(buffer1, 't', kSize);
@@ skipping 124 matching lines @@
 }
 
 TEST_F(DiskCacheBackendTest, DISABLED_SimpleCacheSetSize) {
   SetSimpleCacheMode();
   BackendSetSize();
 }
 
 // MacOS has a default open file limit of 256 files, which is incompatible with
 // this simple cache test.
 #if defined(OS_MACOSX)
-#define SIMPLE_MAYBE_MACOS(TestName) DISABLED_ ## TestName
+#define SIMPLE_MAYBE_MACOS(TestName) DISABLED_##TestName
 #else
 #define SIMPLE_MAYBE_MACOS(TestName) TestName
 #endif
 
 TEST_F(DiskCacheBackendTest, SIMPLE_MAYBE_MACOS(SimpleCacheLoad)) {
   SetMaxSize(0x100000);
   SetSimpleCacheMode();
   BackendLoad();
 }
 
@@ skipping 89 matching lines @@
   entry = NULL;
 
   // Write an invalid header for stream 0 and stream 1.
   base::FilePath entry_file1_path = cache_path_.AppendASCII(
       disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, 0));
 
   disk_cache::SimpleFileHeader header;
   header.initial_magic_number = GG_UINT64_C(0xbadf00d);
   EXPECT_EQ(
       implicit_cast<int>(sizeof(header)),
-      base::WriteFile(entry_file1_path, reinterpret_cast<char*>(&header),
-                           sizeof(header)));
+      base::WriteFile(
+          entry_file1_path, reinterpret_cast<char*>(&header), sizeof(header)));
   ASSERT_EQ(net::ERR_FAILED, OpenEntry(key, &entry));
 }
 
 // Tests that the Simple Cache Backend fails to initialize with non-matching
 // file structure on disk.
 TEST_F(DiskCacheBackendTest, SimpleCacheOverBlockfileCache) {
   // Create a cache structure with the |BackendImpl|.
   InitCache();
   disk_cache::Entry* entry;
   const int kSize = 50;
@@ skipping 71 matching lines @@
   cache_->EndEnumeration(&iter);
   EXPECT_EQ(key_pool.size(), count);
   EXPECT_TRUE(keys_to_match.empty());
 
   // Check that opening entries does not affect enumeration.
   keys_to_match = key_pool;
   iter = NULL;
   count = 0;
   disk_cache::Entry* entry_opened_before;
   ASSERT_EQ(net::OK, OpenEntry(*(key_pool.begin()), &entry_opened_before));
-  ASSERT_TRUE(EnumerateAndMatchKeys(key_pool.size()/2,
-                                    &iter,
-                                    &keys_to_match,
-                                    &count));
+  ASSERT_TRUE(EnumerateAndMatchKeys(
+      key_pool.size() / 2, &iter, &keys_to_match, &count));
 
   disk_cache::Entry* entry_opened_middle;
-  ASSERT_EQ(net::OK,
-            OpenEntry(*(keys_to_match.begin()), &entry_opened_middle));
+  ASSERT_EQ(net::OK, OpenEntry(*(keys_to_match.begin()), &entry_opened_middle));
   ASSERT_TRUE(EnumerateAndMatchKeys(-1, &iter, &keys_to_match, &count));
   cache_->EndEnumeration(&iter);
   entry_opened_before->Close();
   entry_opened_middle->Close();
 
   EXPECT_EQ(key_pool.size(), count);
   EXPECT_TRUE(keys_to_match.empty());
 }
 
 // Tests that the enumerations are not affected by dooming an entry in the
 // middle.
 TEST_F(DiskCacheBackendTest, SimpleCacheEnumerationWhileDoomed) {
   SetSimpleCacheMode();
   InitCache();
   std::set<std::string> key_pool;
   ASSERT_TRUE(CreateSetOfRandomEntries(&key_pool));
 
   // Check that enumeration returns all entries but the doomed one.
   std::set<std::string> keys_to_match(key_pool);
   void* iter = NULL;
   size_t count = 0;
-  ASSERT_TRUE(EnumerateAndMatchKeys(key_pool.size()/2,
-                                    &iter,
-                                    &keys_to_match,
-                                    &count));
+  ASSERT_TRUE(EnumerateAndMatchKeys(
+      key_pool.size() / 2, &iter, &keys_to_match, &count));
 
   std::string key_to_delete = *(keys_to_match.begin());
   DoomEntry(key_to_delete);
   keys_to_match.erase(key_to_delete);
   key_pool.erase(key_to_delete);
   ASSERT_TRUE(EnumerateAndMatchKeys(-1, &iter, &keys_to_match, &count));
   cache_->EndEnumeration(&iter);
 
   EXPECT_EQ(key_pool.size(), count);
   EXPECT_TRUE(keys_to_match.empty());
@@ skipping 15 matching lines @@
   ASSERT_EQ(net::OK, CreateEntry(key, &corrupted_entry));
   ASSERT_TRUE(corrupted_entry);
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, false);
   ASSERT_EQ(kSize,
             WriteData(corrupted_entry, 0, 0, buffer.get(), kSize, false));
   ASSERT_EQ(kSize, ReadData(corrupted_entry, 0, 0, buffer.get(), kSize));
   corrupted_entry->Close();
 
-  EXPECT_TRUE(disk_cache::simple_util::CreateCorruptFileForTests(
-      key, cache_path_));
+  EXPECT_TRUE(
+      disk_cache::simple_util::CreateCorruptFileForTests(key, cache_path_));
   EXPECT_EQ(key_pool.size() + 1,
             implicit_cast<size_t>(cache_->GetEntryCount()));
 
   // Check that enumeration returns all entries but the corrupt one.
   std::set<std::string> keys_to_match(key_pool);
   void* iter = NULL;
   size_t count = 0;
   ASSERT_TRUE(EnumerateAndMatchKeys(-1, &iter, &keys_to_match, &count));
   cache_->EndEnumeration(&iter);
 
   EXPECT_EQ(key_pool.size(), count);
   EXPECT_TRUE(keys_to_match.empty());
 }
 
 #endif  // defined(OS_POSIX)