Unlink corrupt SimpleCache index files immediately after load.

net/disk_cache/simple/simple_index_file_unittest.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.
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/hash.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 131 matching lines @@
   EXPECT_FALSE(SimpleIndexFile::IsIndexFileStale(index_path));
 
   EXPECT_EQ(static_cast<int>(kDummyData.size()),
             file_util::WriteFile(temp_dir.path().AppendASCII("other_file"),
                                  kDummyData.data(),
                                  kDummyData.size()));
 
   EXPECT_TRUE(SimpleIndexFile::IsIndexFileStale(index_path));
 }
 
+TEST_F(SimpleIndexFileTest, WriteThenLoadIndex) {
+  base::ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+
+  const base::FilePath index_path =
+      temp_dir.path().AppendASCII(SimpleIndexFile::kIndexFileName);
+  EXPECT_TRUE(SimpleIndexFile::IsIndexFileStale(index_path));
+
+  SimpleIndex::EntrySet entries;
+  static const uint64 kHashes[] = { 11, 22, 33 };
+  static const size_t kNumHashes = arraysize(kHashes);
+  EntryMetadata metadata_entries[kNumHashes];
+  for (size_t i = 0; i < kNumHashes; ++i) {
+    uint64 hash = kHashes[i];
+    metadata_entries[i] =
+        EntryMetadata(Time::FromInternalValue(hash), hash);
+    SimpleIndex::InsertInEntrySet(hash, metadata_entries[i], &entries);
+  }
+
+  const uint64 kCacheSize = 456U;
+  {
+    SimpleIndexFile simple_index_file(base::MessageLoopProxy::current(),
+                                      base::MessageLoopProxy::current(),
+                                      temp_dir.path());
+    simple_index_file.WriteToDisk(entries, kCacheSize,
+                                  base::TimeTicks(), false);
+    base::RunLoop().RunUntilIdle();
+    EXPECT_TRUE(file_util::PathExists(index_path));
+  }
+
+  SimpleIndexFile simple_index_file(base::MessageLoopProxy::current(),
+                                    base::MessageLoopProxy::current(),
+                                    temp_dir.path());
+  SimpleIndexFile::IndexCompletionCallback callback =
+      base::Bind(&SimpleIndexFileTest::IndexCompletionCallback,
+                 base::Unretained(this));
+  simple_index_file.LoadIndexEntries(base::MessageLoopProxy::current(),
+                                     callback);
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(file_util::PathExists(index_path));
+  ASSERT_TRUE(callback_result());
+  EXPECT_FALSE(callback_result()->force_index_flush);
+  const SimpleIndex::EntrySet* read_entries =
+      callback_result()->index_file_entries.get();
+  ASSERT_TRUE(read_entries);
+
+  EXPECT_EQ(kNumHashes, read_entries->size());
+  for (size_t i = 0; i < kNumHashes; ++i)
+    EXPECT_EQ(1U, read_entries->count(kHashes[i]));
+}
+
 TEST_F(SimpleIndexFileTest, IsIndexFileCorrupt) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   const base::FilePath index_path =
       temp_dir.path().AppendASCII(SimpleIndexFile::kIndexFileName);
   EXPECT_TRUE(SimpleIndexFile::IsIndexFileStale(index_path));
   const std::string kDummyData = "nothing to be seen here";
   EXPECT_EQ(static_cast<int>(kDummyData.size()),
             file_util::WriteFile(index_path,
                                  kDummyData.data(),
                                  kDummyData.size()));
   EXPECT_FALSE(SimpleIndexFile::IsIndexFileStale(index_path));
 
   SimpleIndexFile simple_index_file(base::MessageLoopProxy::current(),
                                     base::MessageLoopProxy::current(),
                                     temp_dir.path());
 
   SimpleIndexFile::IndexCompletionCallback callback =
       base::Bind(&SimpleIndexFileTest::IndexCompletionCallback,
                  base::Unretained(this));
 
   simple_index_file.LoadIndexEntries(base::MessageLoopProxy::current(),
                                      callback);
   base::RunLoop().RunUntilIdle();
 
+  EXPECT_FALSE(file_util::PathExists(index_path));
   ASSERT_TRUE(callback_result());
   EXPECT_TRUE(callback_result()->index_file_entries);
   EXPECT_TRUE(callback_result()->force_index_flush);
 }
 
 }  // namespace disk_cache