SimpleCache: Add a test that covers recovery from missing index.

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 <stdint.h>
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
@@ skipping 3868 matching lines @@
             OpenEntry(*(keys_to_match.begin()), &entry_opened_middle));
   ASSERT_TRUE(EnumerateAndMatchKeys(-1, iter.get(), &keys_to_match, &count));
   iter.reset();
   entry_opened_before->Close();
   entry_opened_middle->Close();
 
   EXPECT_EQ(key_pool.size(), count);
   EXPECT_TRUE(keys_to_match.empty());
 }
 
+TEST_F(DiskCacheBackendTest, SimpleCacheIndexRecovery) {
+  // Make sure we can recover set of entries when the index was removed.
+  SetSimpleCacheMode();
+  InitCache();
+  std::set<std::string> key_pool;
+  ASSERT_TRUE(CreateSetOfRandomEntries(&key_pool));
+
+  cache_.reset();
+
+  // Give it a chance to write out the index, so we can delete it (rather
+  // than have it write it after we delete it).
+  disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
+  base::RunLoop().RunUntilIdle();
+
+  base::FilePath index_path =
+      cache_path_.AppendASCII("index-dir").AppendASCII("the-real-index");
+  ASSERT_TRUE(base::DeleteFile(index_path, false));
+
+  DisableFirstCleanup();
+  InitCache();
+  // A bit surprising, but it calls it "NEWCACHE" if there was no index,
+  // even if it reconstructed non-zero things.
+  EXPECT_EQ(disk_cache::SimpleIndex::INITIALIZE_METHOD_NEWCACHE,
+            simple_cache_impl_->index()->init_method());
+
+  // Check that enumeration returns all entries.
+  std::set<std::string> keys_to_match(key_pool);
+  std::unique_ptr<TestIterator> iter = CreateIterator();
+  size_t count = 0;
+  ASSERT_TRUE(EnumerateAndMatchKeys(-1, iter.get(), &keys_to_match, &count));
+  iter.reset();
+  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);
@@ skipping 185 matching lines @@
   disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
   base::RunLoop().RunUntilIdle();
 
   disk_cache::Entry* reopen_entry1;
   ASSERT_THAT(OpenEntry(key1, &reopen_entry1), IsOk());
 
   // This shouldn't pick up entry2's write time incorrectly.
   EXPECT_LE(reopen_entry1->GetLastModified(), entry1_timestamp);
   reopen_entry1->Close();
 }