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"
 #include "base/file_util.h"
+#include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/pickle.h"
 #include "base/task_runner.h"
 #include "base/threading/worker_pool.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/simple/simple_entry_format.h"
 #include "net/disk_cache/simple/simple_index_file.h"
 #include "net/disk_cache/simple/simple_util.h"
 
@@ skipping 144 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
 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);
+  bool restore_from_disk = SimpleIndexFile::IndexFileIsStale(index_filename);
 
-  bool force_index_flush = false;
+  scoped_ptr<EntrySet> index_file_entries;
+  if (!restore_from_disk) {
+    index_file_entries = SimpleIndexFile::LoadFromDisk(index_filename);
+  }
+
   if (!index_file_entries.get()) {
     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;
+    restore_from_disk = true;
   }
 
   io_thread->PostTask(FROM_HERE,
                       base::Bind(completion_callback,
                                  base::Passed(&index_file_entries),
-                                 force_index_flush));
+                                 restore_from_disk));
 }
 
 // static
 scoped_ptr<SimpleIndex::EntrySet> SimpleIndex::RestoreFromDisk(
     const base::FilePath& index_filename) {
   using file_util::FileEnumerator;
   LOG(INFO) << "Simple Cache Index is being restored from disk.";
 
   file_util::Delete(index_filename, /* recursive = */ false);
   scoped_ptr<EntrySet> index_file_entries(new EntrySet());
@@ skipping 102 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