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
 void SimpleIndex::LoadFromDisk(
     const base::FilePath& index_filename,
     base::SingleThreadTaskRunner* io_thread,
     const IndexCompletionCallback& completion_callback) {
+  // TODO(felipeg): probably could load a stale index and use it for something.
   scoped_ptr<EntrySet> index_file_entries =
       SimpleIndexFile::LoadFromDisk(index_filename);
 
   bool force_index_flush = false;

[gavinp, 2013/04/19 12:23:13]

This whole function is a lot easier to read. Thanks.

[felipeg, 2013/04/19 12:55:58]

Done.

-  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 112 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