Clang format slam.

net/disk_cache/entry_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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/file.h"
 #include "base/strings/string_util.h"
@@ skipping 108 matching lines @@
       entry->ReadData(1, 0, buffer3.get(), kSize3, net::CompletionCallback()));
   EXPECT_EQ(8192,
             entry->WriteData(
                 1, 0, buffer3.get(), 8192, net::CompletionCallback(), false));
   EXPECT_EQ(
       8192,
       entry->ReadData(1, 0, buffer3.get(), kSize3, net::CompletionCallback()));
   EXPECT_EQ(8192, entry->GetDataSize(1));
 
   // We need to delete the memory buffer on this thread.
-  EXPECT_EQ(0, entry->WriteData(
-      0, 0, NULL, 0, net::CompletionCallback(), true));
-  EXPECT_EQ(0, entry->WriteData(
-      1, 0, NULL, 0, net::CompletionCallback(), true));
+  EXPECT_EQ(0,
+            entry->WriteData(0, 0, NULL, 0, net::CompletionCallback(), true));
+  EXPECT_EQ(0,
+            entry->WriteData(1, 0, NULL, 0, net::CompletionCallback(), true));
 }
 
 // We need to support synchronous IO even though it is not a supported operation
 // from the point of view of the disk cache's public interface, because we use
 // it internally, not just by a few tests, but as part of the implementation
 // (see sparse_control.cc, for example).
 void DiskCacheEntryTest::InternalSyncIO() {
   disk_cache::Entry* entry = NULL;
   ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
   ASSERT_TRUE(NULL != entry);
 
   // The bulk of the test runs from within the callback, on the cache thread.
   RunTaskForTest(base::Bind(&DiskCacheEntryTest::InternalSyncIOBackground,
                             base::Unretained(this),
                             entry));
 
-
   entry->Doom();
   entry->Close();
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, InternalSyncIO) {
   InitCache();
   InternalSyncIO();
 }
@@ skipping 246 matching lines @@
   EXPECT_EQ(
       17000,
       entry->ReadData(1, 0, buffer1.get(), kSize1, net::CompletionCallback()));
   EXPECT_EQ(
       17000,
       entry->WriteData(
           1, 20000, buffer1.get(), kSize1, net::CompletionCallback(), false));
   EXPECT_EQ(37000, entry->GetDataSize(1));
 
   // We need to delete the memory buffer on this thread.
-  EXPECT_EQ(0, entry->WriteData(
-      0, 0, NULL, 0, net::CompletionCallback(), true));
-  EXPECT_EQ(0, entry->WriteData(
-      1, 0, NULL, 0, net::CompletionCallback(), true));
+  EXPECT_EQ(0,
+            entry->WriteData(0, 0, NULL, 0, net::CompletionCallback(), true));
+  EXPECT_EQ(0,
+            entry->WriteData(1, 0, NULL, 0, net::CompletionCallback(), true));
 }
 
 void DiskCacheEntryTest::ExternalSyncIO() {
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
 
   // The bulk of the test runs from within the callback, on the cache thread.
   RunTaskForTest(base::Bind(&DiskCacheEntryTest::ExternalSyncIOBackground,
                             base::Unretained(this),
                             entry));
@@ skipping 699 matching lines @@
 }
 
 TEST_F(DiskCacheEntryTest, BufferingNoBuffer) {
   InitCache();
   cache_impl_->SetFlags(disk_cache::kNoBuffering);
   Buffering();
 }
 
 // Checks that entries are zero length when created.
 void DiskCacheEntryTest::SizeAtCreate() {
-  const char key[]  = "the first key";
+  const char key[] = "the first key";
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   const int kNumStreams = 3;
   for (int i = 0; i < kNumStreams; ++i)
     EXPECT_EQ(0, entry->GetDataSize(i));
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, SizeAtCreate) {
@@ skipping 475 matching lines @@
     ++count;
     disk_cache::MemEntryImpl* mem_entry =
         reinterpret_cast<disk_cache::MemEntryImpl*>(entry);
     EXPECT_EQ(disk_cache::MemEntryImpl::kParentEntry, mem_entry->type());
     mem_entry->Close();
   }
   EXPECT_EQ(1, count);
 }
 
 // Writes |buf_1| to offset and reads it back as |buf_2|.
-void VerifySparseIO(disk_cache::Entry* entry, int64 offset,
-                    net::IOBuffer* buf_1, int size, net::IOBuffer* buf_2) {
+void VerifySparseIO(disk_cache::Entry* entry,
+                    int64 offset,
+                    net::IOBuffer* buf_1,
+                    int size,
+                    net::IOBuffer* buf_2) {
   net::TestCompletionCallback cb;
 
   memset(buf_2->data(), 0, size);
   int ret = entry->ReadSparseData(offset, buf_2, size, cb.callback());
   EXPECT_EQ(0, cb.GetResult(ret));
 
   ret = entry->WriteSparseData(offset, buf_1, size, cb.callback());
   EXPECT_EQ(size, cb.GetResult(ret));
 
   ret = entry->ReadSparseData(offset, buf_2, size, cb.callback());
   EXPECT_EQ(size, cb.GetResult(ret));
 
   EXPECT_EQ(0, memcmp(buf_1->data(), buf_2->data(), size));
 }
 
 // Reads |size| bytes from |entry| at |offset| and verifies that they are the
 // same as the content of the provided |buffer|.
-void VerifyContentSparseIO(disk_cache::Entry* entry, int64 offset, char* buffer,
+void VerifyContentSparseIO(disk_cache::Entry* entry,
+                           int64 offset,
+                           char* buffer,
                            int size) {
   net::TestCompletionCallback cb;
 
   scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(size));
   memset(buf_1->data(), 0, size);
   int ret = entry->ReadSparseData(offset, buf_1.get(), size, cb.callback());
   EXPECT_EQ(size, cb.GetResult(ret));
   EXPECT_EQ(0, memcmp(buf_1->data(), buffer, size));
 }
 
@@ skipping 78 matching lines @@
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   // Write at offset 0x20F0000 (33 MB - 64 KB), and 0x20F4400 (33 MB - 47 KB).
   EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf.get(), kSize));
   EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F4400, buf.get(), kSize));
 
   // We stop at the first empty block.
   int64 start;
   net::TestCompletionCallback cb;
-  int rv = entry->GetAvailableRange(
-      0x20F0000, kSize * 2, &start, cb.callback());
+  int rv =
+      entry->GetAvailableRange(0x20F0000, kSize * 2, &start, cb.callback());
   EXPECT_EQ(kSize, cb.GetResult(rv));
   EXPECT_EQ(0x20F0000, start);
 
   start = 0;
   rv = entry->GetAvailableRange(0, kSize, &start, cb.callback());
   EXPECT_EQ(0, cb.GetResult(rv));
-  rv = entry->GetAvailableRange(
-      0x20F0000 - kSize, kSize, &start, cb.callback());
+  rv =
+      entry->GetAvailableRange(0x20F0000 - kSize, kSize, &start, cb.callback());
   EXPECT_EQ(0, cb.GetResult(rv));
   rv = entry->GetAvailableRange(0, 0x2100000, &start, cb.callback());
   EXPECT_EQ(kSize, cb.GetResult(rv));
   EXPECT_EQ(0x20F0000, start);
 
   // We should be able to Read based on the results of GetAvailableRange.
   start = -1;
   rv = entry->GetAvailableRange(0x2100000, kSize, &start, cb.callback());
   EXPECT_EQ(0, cb.GetResult(rv));
   rv = entry->ReadSparseData(start, buf.get(), kSize, cb.callback());
   EXPECT_EQ(0, cb.GetResult(rv));
 
   start = 0;
   rv = entry->GetAvailableRange(0x20F2000, kSize, &start, cb.callback());
   EXPECT_EQ(0x2000, cb.GetResult(rv));
   EXPECT_EQ(0x20F2000, start);
   EXPECT_EQ(0x2000, ReadSparseData(entry, start, buf.get(), kSize));
 
   // Make sure that we respect the |len| argument.
   start = 0;
-  rv = entry->GetAvailableRange(
-      0x20F0001 - kSize, kSize, &start, cb.callback());
+  rv =
+      entry->GetAvailableRange(0x20F0001 - kSize, kSize, &start, cb.callback());
   EXPECT_EQ(1, cb.GetResult(rv));
   EXPECT_EQ(0x20F0000, start);
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, GetAvailableRange) {
   InitCache();
   GetAvailableRange();
 }
@@ skipping 60 matching lines @@
   scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf_1->data(), kSize, false);
 
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   // This loop writes back to back starting from offset 0 and 9000.
   for (int i = 0; i < kSize; i += 1024) {
     scoped_refptr<net::WrappedIOBuffer> buf_3(
-      new net::WrappedIOBuffer(buf_1->data() + i));
+        new net::WrappedIOBuffer(buf_1->data() + i));
     VerifySparseIO(entry, i, buf_3.get(), 1024, buf_2.get());
     VerifySparseIO(entry, 9000 + i, buf_3.get(), 1024, buf_2.get());
   }
 
   // Make sure we have data written.
   VerifyContentSparseIO(entry, 0, buf_1->data(), kSize);
   VerifyContentSparseIO(entry, 9000, buf_1->data(), kSize);
 
   // This tests a large write that spans 3 entries from a misaligned offset.
   VerifySparseIO(entry, 20481, buf_1.get(), 8192, buf_2.get());
@@ skipping 106 matching lines @@
 TEST_F(DiskCacheEntryTest, MemoryOnlyUpdateSparseEntry) {
   SetMemoryOnlyMode();
   SetCacheType(net::MEDIA_CACHE);
   InitCache();
   UpdateSparseEntry();
 }
 
 void DiskCacheEntryTest::DoomSparseEntry() {
   std::string key1("the first key");
   std::string key2("the second key");
-  disk_cache::Entry *entry1, *entry2;
+  disk_cache::Entry* entry1, *entry2;
   ASSERT_EQ(net::OK, CreateEntry(key1, &entry1));
   ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));
 
   const int kSize = 4 * 1024;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   int64 offset = 1024;
   // Write to a bunch of ranges.
   for (int i = 0; i < 12; i++) {
@@ skipping 46 matching lines @@
 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomSparseEntry) {
   SetMemoryOnlyMode();
   InitCache();
   DoomSparseEntry();
 }
 
 // A CompletionCallback wrapper that deletes the cache from within the callback.
 // The way a CompletionCallback works means that all tasks (even new ones)
 // are executed by the message loop before returning to the caller so the only
 // way to simulate a race is to execute what we want on the callback.
-class SparseTestCompletionCallback: public net::TestCompletionCallback {
+class SparseTestCompletionCallback : public net::TestCompletionCallback {
  public:
   explicit SparseTestCompletionCallback(scoped_ptr<disk_cache::Backend> cache)
-      : cache_(cache.Pass()) {
-  }
+      : cache_(cache.Pass()) {}
 
  private:
   virtual void SetResult(int result) OVERRIDE {
     cache_.reset();
     TestCompletionCallback::SetResult(result);
   }
 
   scoped_ptr<disk_cache::Backend> cache_;
   DISALLOW_COPY_AND_ASSIGN(SparseTestCompletionCallback);
 };
@@ skipping 486 matching lines @@
 
   const int kReadBufferSize = 200;
   EXPECT_GE(kReadBufferSize, entry->GetDataSize(1));
   scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize));
   EXPECT_EQ(net::ERR_CACHE_CHECKSUM_MISMATCH,
             ReadData(entry, 1, 0, read_buffer.get(), kReadBufferSize));
 
   entry->Doom();  // Should not crash.
 }
 
-bool TruncatePath(const base::FilePath& file_path, int64 length)  {
+bool TruncatePath(const base::FilePath& file_path, int64 length) {
   base::File file(file_path, base::File::FLAG_WRITE | base::File::FLAG_OPEN);
   if (!file.IsValid())
     return false;
   return file.SetLength(length);
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheNoEOF) {
   SetSimpleCacheMode();
   InitCache();
 
@@ skipping 158 matching lines @@
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
   scoped_refptr<net::IOBuffer> buffer1_read(new net::IOBuffer(kSize1));
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
   scoped_refptr<net::IOBuffer> buffer2_read(new net::IOBuffer(kSize2));
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
   CacheTestFillBuffer(buffer2->data(), kSize2, false);
 
   disk_cache::Entry* entry = NULL;
   // Create is optimistic, must return OK.
   ASSERT_EQ(net::OK,
-            cache_->CreateEntry(key, &entry,
-                                base::Bind(&CallbackTest::Run,
-                                           base::Unretained(&callback1))));
+            cache_->CreateEntry(
+                key,
+                &entry,
+                base::Bind(&CallbackTest::Run, base::Unretained(&callback1))));
   EXPECT_NE(null, entry);
   ScopedEntryPtr entry_closer(entry);
 
   // This write may or may not be optimistic (it depends if the previous
   // optimistic create already finished by the time we call the write here).
   int ret = entry->WriteData(
       1,
       0,
       buffer1.get(),
       kSize1,
@@ skipping 35 matching lines @@
                 buffer2_read.get(),
                 kSize2,
                 base::Bind(&CallbackTest::Run, base::Unretained(&callback5))));
   expected++;
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   EXPECT_EQ(0, memcmp(buffer2->data(), buffer2_read->data(), kSize2));
 
   // Check that we are not leaking.
   EXPECT_NE(entry, null);
-  EXPECT_TRUE(
-      static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
+  EXPECT_TRUE(static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic2) {
   // Test sequence:
   // Create, Open, Close, Close.
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* null = NULL;
   const char key[] = "the first key";
 
   MessageLoopHelper helper;
   CallbackTest callback1(&helper, false);
   CallbackTest callback2(&helper, false);
 
   disk_cache::Entry* entry = NULL;
   ASSERT_EQ(net::OK,
-            cache_->CreateEntry(key, &entry,
-                                base::Bind(&CallbackTest::Run,
-                                           base::Unretained(&callback1))));
+            cache_->CreateEntry(
+                key,
+                &entry,
+                base::Bind(&CallbackTest::Run, base::Unretained(&callback1))));
   EXPECT_NE(null, entry);
   ScopedEntryPtr entry_closer(entry);
 
   disk_cache::Entry* entry2 = NULL;
   ASSERT_EQ(net::ERR_IO_PENDING,
-            cache_->OpenEntry(key, &entry2,
-                              base::Bind(&CallbackTest::Run,
-                                         base::Unretained(&callback2))));
+            cache_->OpenEntry(
+                key,
+                &entry2,
+                base::Bind(&CallbackTest::Run, base::Unretained(&callback2))));
   ASSERT_TRUE(helper.WaitUntilCacheIoFinished(1));
 
   EXPECT_NE(null, entry2);
   EXPECT_EQ(entry, entry2);
 
   // We have to call close twice, since we called create and open above.
   entry->Close();
 
   // Check that we are not leaking.
-  EXPECT_TRUE(
-      static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
+  EXPECT_TRUE(static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic3) {
   // Test sequence:
   // Create, Close, Open, Close.
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* null = NULL;
   const char key[] = "the first key";
 
   disk_cache::Entry* entry = NULL;
   ASSERT_EQ(net::OK,
             cache_->CreateEntry(key, &entry, net::CompletionCallback()));
   EXPECT_NE(null, entry);
   entry->Close();
 
   net::TestCompletionCallback cb;
   disk_cache::Entry* entry2 = NULL;
   ASSERT_EQ(net::ERR_IO_PENDING,
             cache_->OpenEntry(key, &entry2, cb.callback()));
   ASSERT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING));
   ScopedEntryPtr entry_closer(entry2);
 
   EXPECT_NE(null, entry2);
   EXPECT_EQ(entry, entry2);
 
   // Check that we are not leaking.
-  EXPECT_TRUE(
-      static_cast<disk_cache::SimpleEntryImpl*>(entry2)->HasOneRef());
+  EXPECT_TRUE(static_cast<disk_cache::SimpleEntryImpl*>(entry2)->HasOneRef());
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic4) {
   // Test sequence:
   // Create, Close, Write, Open, Open, Close, Write, Read, Close.
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* null = NULL;
   const char key[] = "the first key";
 
@@ skipping 43 matching lines @@
             entry2->WriteData(
                 1, 0, buffer1.get(), kSize1, net::CompletionCallback(), false));
 
   // Lets do another read so we block until both the write and the read
   // operation finishes and we can then test for HasOneRef() below.
   EXPECT_EQ(net::ERR_IO_PENDING,
             entry2->ReadData(1, 0, buffer1.get(), kSize1, cb.callback()));
   EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
 
   // Check that we are not leaking.
-  EXPECT_TRUE(
-      static_cast<disk_cache::SimpleEntryImpl*>(entry2)->HasOneRef());
+  EXPECT_TRUE(static_cast<disk_cache::SimpleEntryImpl*>(entry2)->HasOneRef());
   entry2->Close();
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic5) {
   // Test sequence:
   // Create, Doom, Write, Read, Close.
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* null = NULL;
   const char key[] = "the first key";
@@ skipping 13 matching lines @@
   EXPECT_EQ(
       net::ERR_IO_PENDING,
       entry->WriteData(1, 0, buffer1.get(), kSize1, cb.callback(), false));
   EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
 
   EXPECT_EQ(net::ERR_IO_PENDING,
             entry->ReadData(1, 0, buffer1.get(), kSize1, cb.callback()));
   EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
 
   // Check that we are not leaking.
-  EXPECT_TRUE(
-      static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
+  EXPECT_TRUE(static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic6) {
   // Test sequence:
   // Create, Write, Doom, Doom, Read, Doom, Close.
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* null = NULL;
   const char key[] = "the first key";
 
@@ skipping 150 matching lines @@
 
   disk_cache::Entry* entry2 = NULL;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry2));
   ScopedEntryPtr entry2_closer(entry2);
   EXPECT_NE(null, entry2);
 
   // Redundantly dooming entry1 should not delete entry2.
   disk_cache::SimpleEntryImpl* simple_entry1 =
       static_cast<disk_cache::SimpleEntryImpl*>(entry1);
   net::TestCompletionCallback cb;
-  EXPECT_EQ(net::OK,
-            cb.GetResult(simple_entry1->DoomEntry(cb.callback())));
+  EXPECT_EQ(net::OK, cb.GetResult(simple_entry1->DoomEntry(cb.callback())));
 
   disk_cache::Entry* entry3 = NULL;
   ASSERT_EQ(net::OK, OpenEntry(key, &entry3));
   ScopedEntryPtr entry3_closer(entry3);
   EXPECT_NE(null, entry3);
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheDoomCreateDoom) {
   // Test sequence:
   // Create, Doom, Create, Doom.
@@ skipping 26 matching lines @@
   SetSimpleCacheMode();
   InitCache();
 
   // Create a corrupt file in place of a future entry. Optimistic create should
   // initially succeed, but realize later that creation failed.
   const std::string key = "the key";
   net::TestCompletionCallback cb;
   disk_cache::Entry* entry = NULL;
   disk_cache::Entry* entry2 = NULL;
 
-  EXPECT_TRUE(disk_cache::simple_util::CreateCorruptFileForTests(
-      key, cache_path_));
+  EXPECT_TRUE(
+      disk_cache::simple_util::CreateCorruptFileForTests(key, cache_path_));
   EXPECT_EQ(net::OK, cache_->CreateEntry(key, &entry, cb.callback()));
   ASSERT_TRUE(entry);
   ScopedEntryPtr entry_closer(entry);
   ASSERT_NE(net::OK, OpenEntry(key, &entry2));
 
   // Check that we are not leaking.
-  EXPECT_TRUE(
-      static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
+  EXPECT_TRUE(static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
 
   DisableIntegrityCheck();
 }
 
 // Tests that old entries are evicted while new entries remain in the index.
 // This test relies on non-mandatory properties of the simple Cache Backend:
 // LRU eviction, specific values of high-watermark and low-watermark etc.
 // When changing the eviction algorithm, the test will have to be re-engineered.
 TEST_F(DiskCacheEntryTest, SimpleCacheEvictOldEntries) {
   const int kMaxSize = 200 * 1024;
@@ skipping 28 matching lines @@
 
   // TODO(pasko): Find a way to wait for the eviction task(s) to finish by using
   // the internal knowledge about |SimpleBackendImpl|.
   ASSERT_NE(net::OK, OpenEntry(key1, &entry))
       << "Should have evicted the old entry";
   for (int i = 0; i < 2; i++) {
     int entry_no = kNumExtraEntries - i - 1;
     // Generally there is no guarantee that at this point the backround eviction
     // is finished. We are testing the positive case, i.e. when the eviction
     // never reaches this entry, should be non-flaky.
-    ASSERT_EQ(net::OK, OpenEntry(key2 + base::StringPrintf("%d", entry_no),
-                                 &entry))
+    ASSERT_EQ(net::OK,
+              OpenEntry(key2 + base::StringPrintf("%d", entry_no), &entry))
         << "Should not have evicted fresh entry " << entry_no;
     entry->Close();
   }
 }
 
 // Tests that if a read and a following in-flight truncate are both in progress
 // simultaniously that they both can occur successfully. See
 // http://crbug.com/239223
-TEST_F(DiskCacheEntryTest, SimpleCacheInFlightTruncate)  {
+TEST_F(DiskCacheEntryTest, SimpleCacheInFlightTruncate) {
   SetSimpleCacheMode();
   InitCache();
 
   const char key[] = "the first key";
 
   const int kBufferSize = 1024;
   scoped_refptr<net::IOBuffer> write_buffer(new net::IOBuffer(kBufferSize));
   CacheTestFillBuffer(write_buffer->data(), kBufferSize, false);
 
   disk_cache::Entry* entry = NULL;
@@ skipping 17 matching lines @@
   EXPECT_EQ(net::ERR_IO_PENDING,
             entry->ReadData(1,
                             0,
                             read_buffer.get(),
                             kReadBufferSize,
                             base::Bind(&CallbackTest::Run,
                                        base::Unretained(&read_callback))));
   ++expected;
 
   // Truncate the entry to the length of that read.
-  scoped_refptr<net::IOBuffer>
-      truncate_buffer(new net::IOBuffer(kReadBufferSize));
+  scoped_refptr<net::IOBuffer> truncate_buffer(
+      new net::IOBuffer(kReadBufferSize));
   CacheTestFillBuffer(truncate_buffer->data(), kReadBufferSize, false);
   CallbackTest truncate_callback(&helper, false);
   EXPECT_EQ(net::ERR_IO_PENDING,
             entry->WriteData(1,
                              0,
                              truncate_buffer.get(),
                              kReadBufferSize,
                              base::Bind(&CallbackTest::Run,
                                         base::Unretained(&truncate_callback)),
                              true));
@@ skipping 179 matching lines @@
   // Read the second half of the data.
   offset = buf_len;
   buf_len = kHalfSize;
   scoped_refptr<net::IOBuffer> buffer1_read2(new net::IOBuffer(buf_len));
   EXPECT_EQ(buf_len, ReadData(entry2, 1, offset, buffer1_read2.get(), buf_len));
   char* buffer1_data = buffer1->data() + offset;
   EXPECT_EQ(0, memcmp(buffer1_data, buffer1_read2->data(), buf_len));
 
   // Check that we are not leaking.
   EXPECT_NE(entry, null);
-  EXPECT_TRUE(
-      static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
+  EXPECT_TRUE(static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
   entry->Close();
   entry = NULL;
 }
 
 // Test if we can write the data not in sequence and read correctly. In
 // this case the CRC will not be present.
 TEST_F(DiskCacheEntryTest, SimpleCacheNonSequentialWrite) {
   // Test sequence:
   // Create, Write (second half of data), Write (first half of data), Read,
   // Close.
@@ skipping 80 matching lines @@
                          base::File::FLAG_READ | base::File::FLAG_OPEN);
   ASSERT_TRUE(entry_file0.IsValid());
 
   int data_size[disk_cache::kSimpleEntryStreamCount] = {kSize, stream1_size, 0};
   int sparse_data_size = 0;
   disk_cache::SimpleEntryStat entry_stat(
       base::Time::Now(), base::Time::Now(), data_size, sparse_data_size);
   int eof_offset = entry_stat.GetEOFOffsetInFile(key, 0);
   disk_cache::SimpleFileEOF eof_record;
   ASSERT_EQ(static_cast<int>(sizeof(eof_record)),
-            entry_file0.Read(eof_offset, reinterpret_cast<char*>(&eof_record),
+            entry_file0.Read(eof_offset,
+                             reinterpret_cast<char*>(&eof_record),
                              sizeof(eof_record)));
   EXPECT_EQ(disk_cache::kSimpleFinalMagicNumber, eof_record.final_magic_number);
   EXPECT_TRUE((eof_record.flags & disk_cache::SimpleFileEOF::FLAG_HAS_CRC32) ==
               disk_cache::SimpleFileEOF::FLAG_HAS_CRC32);
 
   buffer_read = new net::IOBuffer(kSize);
   EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer_read.get(), kSize));
   EXPECT_EQ(0, memcmp(buffer->data(), buffer_read->data(), kSize));
 
   // Shrink stream1.
@@ skipping 348 matching lines @@
   EXPECT_EQ(kSize, callback.GetResult(ret));
 
   // Make sure the first range was removed when the second was written.
   ret = entry->ReadSparseData(0, buffer, kSize, callback.callback());
   EXPECT_EQ(0, callback.GetResult(ret));
 
   entry->Close();
 }
 
 #endif  // defined(OS_POSIX)