Receive app notifications in SimpleCache, so we save our index file

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/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"
 
 namespace {
 
 // How many seconds we delay writing the index to disk since the last cache
 // operation has happened.
-const int kWriteToDiskDelaySecs = 20;
-
-// WriteToDisk at lest every 5 minutes.
-const int kMaxWriteToDiskDelaySecs = 300;
+const int kWriteToDiskDelayMSecs = 20000;
+const int kWriteToDiskOnBackgroundDelayMSecs = 100;
 
 }  // namespace
 
 namespace disk_cache {
 
 EntryMetadata::EntryMetadata() : hash_key_(0),
                                  last_used_time_(0),
                                  entry_size_(0) {
 }
 
@@ skipping 39 matching lines @@
 }
 
 SimpleIndex::SimpleIndex(
     base::SingleThreadTaskRunner* cache_thread,
     base::SingleThreadTaskRunner* io_thread,
     const base::FilePath& path)
     : cache_size_(0),
       initialized_(false),
       index_filename_(path.AppendASCII("simple-index")),
       cache_thread_(cache_thread),
-      io_thread_(io_thread) {
+      io_thread_(io_thread),
+#if defined(OS_ANDROID)
+      activity_status_notifier_(
+          base::Bind(&SimpleIndex::ActivityStatusChanged, AsWeakPtr())),
+#endif
+      app_on_background_(false) {
 }
 
 SimpleIndex::~SimpleIndex() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
 
   // Fail all callbacks waiting for the index to come up.
   for (CallbackList::iterator it = to_run_when_initialized_.begin(),
        end = to_run_when_initialized_.end(); it != end; ++it) {
     it->Run(net::ERR_ABORTED);
   }
@@ skipping 107 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() {
-  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.
+  if (!initialized_)
     return;
+  int delay = kWriteToDiskDelayMSecs;
+  if (app_on_background_) {
+    // When the app is in the background we can write the index much more
+    // frequently. We could even write it to disk on every operation if we
+    // wanted to.
+    delay = kWriteToDiskOnBackgroundDelayMSecs;
   }
-
   // 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::TimeDelta::FromMilliseconds(delay),
       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);
@@ skipping 10 matching lines @@
                       base::Bind(completion_callback,
                                  base::Passed(&index_file_entries),
                                  force_index_flush));
 }
 
 // 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());
 
   // TODO(felipeg,gavinp): Fix this once we have a one-file per entry format.
   COMPILE_ASSERT(kSimpleEntryFileCount == 3,
                  file_pattern_must_match_file_count);
 
   const int kFileSuffixLenght = std::string("_0").size();
   const base::FilePath::StringType file_pattern = FILE_PATH_LITERAL("*_[0-2]");
   FileEnumerator enumerator(index_filename.DirName(),
                             false /* recursive */,
                             FileEnumerator::FILES,
                             file_pattern);
   for (base::FilePath file_path = enumerator.Next(); !file_path.empty();
        file_path = enumerator.Next()) {
     const base::FilePath::StringType base_name = file_path.BaseName().value();
     // Converting to std::string is OK since we never use UTF8 wide chars in our
     // file names.
     const std::string hash_name(base_name.begin(), base_name.end());
     const std::string hash_key_string =
         hash_name.substr(0, hash_name.size() - kFileSuffixLenght);
     uint64 hash_key = 0;
     if (!simple_util::GetEntryHashKeyFromHexString(
             hash_key_string, &hash_key)) {
       LOG(WARNING) << "Invalid Entry Hash Key filename while restoring "
                    << "Simple Index from disk: " << hash_name;
-      // TODO(felipeg): Should we delete the invalid file here ?
       continue;
     }
 
     FileEnumerator::FindInfo find_info = {};
     enumerator.GetFindInfo(&find_info);
     base::Time last_used_time;
 #if defined(OS_POSIX)
     // For POSIX systems, a last access time is available. However, it's not
     // guaranteed to be more accurate than mtime. It is no worse though.
     last_used_time = base::Time::FromTimeT(find_info.stat.st_atime);
@@ skipping 41 matching lines @@
     EntrySet::iterator current_entry = entries_set_.find(it->first);
     if (current_entry != entries_set_.end()) {
       // When Merging, existing valid data in the |current_entry| will prevail.
       current_entry->second.MergeWith(it->second);
       cache_size_ += current_entry->second.GetEntrySize();
     } else {
       InsertInEntrySet(it->second, &entries_set_);
       cache_size_ += it->second.GetEntrySize();
     }
   }
-  last_write_to_disk_ = base::Time::Now();
   initialized_ = true;
   removed_entries_.clear();
 
   // The actual IO is asynchronous, so calling WriteToDisk() shouldn't slow down
   // much the merge.
   if (force_index_flush)
     WriteToDisk();
 
   // Run all callbacks waiting for the index to come up.
   for (CallbackList::iterator it = to_run_when_initialized_.begin(),
        end = to_run_when_initialized_.end(); it != end; ++it) {
     io_thread_->PostTask(FROM_HERE, base::Bind((*it), net::OK));
   }
   to_run_when_initialized_.clear();
 }
 
+#if defined(OS_ANDROID)
+void SimpleIndex::ActivityStatusChanged(
+    net::SimpleCacheActivityStatusNotifier::ActivityStatus activity_status) {
+  DCHECK(io_thread_checker_.CalledOnValidThread());
+  // For more info about android activities, see:
+  // developer.android.com/training/basics/activity-lifecycle/pausing.html
+  // These values are defined in the file ActivityStatus.java
+  if (activity_status == net::SimpleCacheActivityStatusNotifier::RESUMED) {
+    app_on_background_ = false;
+  } else if (activity_status ==
+             net::SimpleCacheActivityStatusNotifier::STOPPED) {
+    app_on_background_ = true;
+    WriteToDisk();
+  }
+}
+#endif
+
 void SimpleIndex::WriteToDisk() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   if (!initialized_)
     return;
-  last_write_to_disk_ = base::Time::Now();
   SimpleIndexFile::IndexMetadata index_metadata(entries_set_.size(),
                                                 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