Add SimpleCache index file heuristics

net/disk_cache/simple/simple_index.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 "net/disk_cache/simple/simple_index.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 155 matching lines @@
 // static
 void SimpleIndex::InsertInEntrySet(
     const disk_cache::EntryMetadata& entry_metadata,
     EntrySet* entry_set) {
   DCHECK(entry_set);
   entry_set->insert(
       std::make_pair(entry_metadata.GetHashKey(), entry_metadata));
 }
 
 void SimpleIndex::PostponeWritingToDisk() {
+  if (!initialized_)
+    return;
   const base::TimeDelta file_age = base::Time::Now() - last_write_to_disk_;
   if (file_age > base::TimeDelta::FromSeconds(kMaxWriteToDiskDelaySecs) &&
       write_to_disk_timer_.IsRunning()) {
     // If the index file is too old and there is a timer programmed to run a
     // WriteToDisk soon, we don't postpone it, so we always WriteToDisk
     // approximately every kMaxWriteToDiskDelaySecs.
     return;
   }
 
   // If the timer is already active, Start() will just Reset it, postponing it.
   write_to_disk_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromSeconds(kWriteToDiskDelaySecs),
       base::Bind(&SimpleIndex::WriteToDisk, AsWeakPtr()));
 }
 
 // static
+bool SimpleIndex::IsIndexFileStale(const base::FilePath& index_filename) {
+  base::PlatformFileInfo dir_info;
+  base::PlatformFileInfo index_info;
+  if (!file_util::GetFileInfo(index_filename.DirName(), &dir_info))
+    return false;
+  DCHECK(dir_info.is_directory);
+  if (!file_util::GetFileInfo(index_filename, &index_info))
+    return false;
+
+  // Index file last_modified must be equal to the directory last_modified since
+  // the last operation we do is ReplaceFile in the
+  // SimpleIndexFile::WriteToDisk().
+  // If not true, we need to restore the index.
+  return index_info.last_modified >= dir_info.last_modified;
+}
+
+// static
 void SimpleIndex::LoadFromDisk(
     const base::FilePath& index_filename,
     base::SingleThreadTaskRunner* io_thread,
     const IndexCompletionCallback& completion_callback) {
-  scoped_ptr<EntrySet> index_file_entries =
-      SimpleIndexFile::LoadFromDisk(index_filename);
+  // TODO(felipeg): probably could load a stale index and use it for something.
+  scoped_ptr<EntrySet> index_file_entries;
+  // Only load if the index is not stale.
+  if (!SimpleIndex::IsIndexFileStale(index_filename))
+    index_file_entries = SimpleIndexFile::LoadFromDisk(index_filename);
 
   bool force_index_flush = false;
-  if (!index_file_entries.get()) {
+  if (!index_file_entries) {
     index_file_entries = SimpleIndex::RestoreFromDisk(index_filename);
     // When we restore from disk we write the merged index file to disk right
     // away, this might save us from having to restore again next time.
     force_index_flush = true;
   }
 
   io_thread->PostTask(FROM_HERE,
                       base::Bind(completion_callback,
                                  base::Passed(&index_file_entries),
                                  force_index_flush));
@@ skipping 62 matching lines @@
 
 // static
 void SimpleIndex::WriteToDiskInternal(const base::FilePath& index_filename,
                                       scoped_ptr<Pickle> pickle) {
   SimpleIndexFile::WriteToDisk(index_filename, *pickle);
 }
 
 void SimpleIndex::MergeInitializingSet(scoped_ptr<EntrySet> index_file_entries,
                                        bool force_index_flush) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
+  DCHECK(index_file_entries);
   // First, remove the entries that are in the |removed_entries_| from both
   // sets.
   for (base::hash_set<uint64>::const_iterator it =
            removed_entries_.begin(); it != removed_entries_.end(); ++it) {
     entries_set_.erase(*it);
     index_file_entries->erase(*it);
   }
 
   // Recalculate the cache size while merging the two sets.
   cache_size_ = 0;
@@ skipping 30 matching lines @@
                                                 cache_size_);
   scoped_ptr<Pickle> pickle = SimpleIndexFile::Serialize(index_metadata,
                                                          entries_set_);
   cache_thread_->PostTask(FROM_HERE, base::Bind(
       &SimpleIndex::WriteToDiskInternal,
       index_filename_,
       base::Passed(&pickle)));
 }
 
 }  // namespace disk_cache