Unlink corrupt SimpleCache index files immediately after load.

net/disk_cache/simple/simple_index_unittest.cc

 // Copyright (c) 2013 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/files/scoped_temp_dir.h"
 #include "base/hash.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/pickle.h"
 #include "base/sha1.h"
@@ skipping 22 matching lines @@
   EntryMetadata NewEntryMetadataWithValues() {
     return EntryMetadata(kTestLastUsedTime, kTestEntrySize);
   }
 
   void CheckEntryMetadataValues(const EntryMetadata& entry_metadata) {
     EXPECT_EQ(kTestLastUsedTime, entry_metadata.GetLastUsedTime());
     EXPECT_EQ(kTestEntrySize, entry_metadata.GetEntrySize());
   }
 };
 
-class TestSimpleIndexFile : public SimpleIndexFile,
-                            public base::SupportsWeakPtr<TestSimpleIndexFile> {
+class MockSimpleIndexFile : public SimpleIndexFile,
+                            public base::SupportsWeakPtr<MockSimpleIndexFile> {
  public:
-  TestSimpleIndexFile()
+  MockSimpleIndexFile()
       : SimpleIndexFile(NULL, NULL, base::FilePath()),
         get_index_entries_calls_(0),
         doom_entry_set_calls_(0),
         last_response_thread_(NULL),
         disk_writes_(0) {}
 
   virtual void LoadIndexEntries(
       scoped_refptr<base::SingleThreadTaskRunner> response_thread,
       const SimpleIndexFile::IndexCompletionCallback&
           completion_callback) OVERRIDE {
@@ skipping 39 matching lines @@
   int doom_entry_set_calls_;
   base::SingleThreadTaskRunner* last_response_thread_;
   base::Callback<void(int)> last_doom_reply_callback_;
   int disk_writes_;
   SimpleIndex::EntrySet disk_write_entry_set_;
 };
 
 class SimpleIndexTest  : public testing::Test {
  public:
   virtual void SetUp() OVERRIDE {
-    scoped_ptr<TestSimpleIndexFile> index_file(new TestSimpleIndexFile());
+    scoped_ptr<MockSimpleIndexFile> index_file(new MockSimpleIndexFile());
     index_file_ = index_file->AsWeakPtr();
     index_.reset(new SimpleIndex(NULL, base::FilePath(),
                                  index_file.PassAs<SimpleIndexFile>()));
 
     index_->Initialize();
   }
 
   void WaitForTimeChange() {
     base::Time now(base::Time::Now());
 
@@ skipping 21 matching lines @@
   }
 
   void ReturnIndexFile() {
     scoped_ptr<SimpleIndex::EntrySet> map(new SimpleIndex::EntrySet);
     map->swap(index_file_return_map_);
     index_file_->completion_callback().Run(map.Pass(), false);
   }
 
   // Non-const for timer manipulation.
   SimpleIndex* index() { return index_.get(); }
-  const TestSimpleIndexFile* index_file() const { return index_file_.get(); }
+  const MockSimpleIndexFile* index_file() const { return index_file_.get(); }
 
  protected:
   SimpleIndex::EntrySet index_file_return_map_;
   scoped_ptr<SimpleIndex> index_;
-  base::WeakPtr<TestSimpleIndexFile> index_file_;
+  base::WeakPtr<MockSimpleIndexFile> index_file_;
 };
 
 TEST_F(EntryMetadataTest, Basics) {
   EntryMetadata entry_metadata;
   EXPECT_EQ(base::Time::FromInternalValue(0), entry_metadata.GetLastUsedTime());
   EXPECT_EQ(size_t(0), entry_metadata.GetEntrySize());
 
   entry_metadata = NewEntryMetadataWithValues();
   CheckEntryMetadataValues(entry_metadata);
 
@@ skipping 403 matching lines @@
   WaitForTimeChange();
   EXPECT_EQ(expected_trigger, index()->write_to_disk_timer_.desired_run_time());
   index()->Insert("key2");
   index()->UpdateEntrySize("key2", 40);
   EXPECT_TRUE(index()->write_to_disk_timer_.IsRunning());
   EXPECT_LT(expected_trigger, index()->write_to_disk_timer_.desired_run_time());
   index()->write_to_disk_timer_.Stop();
 }
 
 }  // namespace disk_cache