Have SimpleCache index listen to android activity status notifications.

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 14 matching lines @@
 
 #if defined(OS_POSIX)
 #include <sys/stat.h>
 #include <sys/time.h>
 #endif
 
 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;
 
 // Divides the cache space into this amount of parts to evict when only one part
 // is left.
 const uint32 kEvictionMarginDivisor = 20;
 
 // Utility class used for timestamp comparisons in entry metadata while sorting.
 class CompareHashesForTimestamp {
   typedef disk_cache::SimpleIndex SimpleIndex;
   typedef disk_cache::SimpleIndex::EntrySet EntrySet;
  public:
@@ skipping 101 matching lines @@
   DCHECK_EQ(hash_key_, from.hash_key_);
   if (last_used_time_ == 0)
     last_used_time_ = from.last_used_time_;
   if (entry_size_ == 0)
     entry_size_ = from.entry_size_;
 }
 
 SimpleIndex::SimpleIndex(
     base::SingleThreadTaskRunner* cache_thread,
     base::SingleThreadTaskRunner* io_thread,
-    const base::FilePath& path)
-    : cache_size_(0),
+    const base::FilePath& path) :
+#if defined(OS_ANDROID)
+      activity_status_listener_(
+          base::Bind(&SimpleIndex::OnActivityStateChange, AsWeakPtr())),

[pasko-google - do not use, 2013/05/03 10:30:54]

this operation feels a bit too non-trivial for a constructor, also makes the
formatting ugly, should better do it in Initialize()

[gavinp, 2013/05/03 12:16:53]

Done.

+#endif
+      cache_size_(0),
       max_size_(0),
       high_watermark_(0),
       low_watermark_(0),
       eviction_in_progress_(false),
       initialized_(false),
       index_filename_(path.AppendASCII("the-real-index")),
       cache_thread_(cache_thread),
-      io_thread_(io_thread) {
+      io_thread_(io_thread),
+      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 187 matching lines @@
     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;
-  }
-
+  const int delay = app_on_background_ ? kWriteToDiskOnBackgroundDelayMSecs
+                                       : kWriteToDiskDelayMSecs;
   // 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),

[pasko-google - do not use, 2013/05/03 10:30:54]

So at maximum it can write the index every 100ms, if an index takes 50ms to
write, it could lead to a noticeable impact on the foreground apps. Can we
measure it?

SimpleCache.IndexTimeSinceLastBackgroundWrite?

[gavinp, 2013/05/03 12:16:53]

I think in a followup; we currently measure index write time on the IO thread,
which makes getting this right tricky for metrics.

       base::Bind(&SimpleIndex::WriteToDisk, AsWeakPtr()));
 }
 
 // static
 bool SimpleIndex::IsIndexFileStale(const base::FilePath& index_filename) {
   base::Time index_mtime;
   base::Time dir_mtime;
   if (!GetMTime(index_filename.DirName(), &dir_mtime))
     return true;
   if (!GetMTime(index_filename, &index_mtime))
@@ skipping 139 matching lines @@
     if (current_entry != entries_set_.end()) {
       // When Merging, existing valid data in the |current_entry| will prevail.
       cache_size_ -= current_entry->second.GetEntrySize();
       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();
 
   UMA_HISTOGRAM_CUSTOM_COUNTS("SimpleCache.IndexInitializationWaiters",
                               to_run_when_initialized_.size(), 0, 100, 20);
   // 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::OnActivityStateChange(
+    base::android::ActivityState state) {
+  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 (state == base::android::ACTIVITY_STATE_RESUMED) {
+    app_on_background_ = false;
+  } else if (state == base::android::ACTIVITY_STATE_STOPPED) {

[felipeg, 2013/05/03 10:03:00]

I know Philippe told you that STATE_STOPPED is enough here, but I tested with my
phone and it is not enough.

When the app goes to background it always receive a STATE_PAUSE but only
sometimes it receives STATE_STOPPED

Same is valid for when the app is going to get killed.
Sometimes it receives STATE_DESTROYED and sometimes it receives STATE_STOPPED

We should handle all states to be sure we will write the index to disk.

[Philippe, 2013/05/03 10:11:47]

STOPPED is supposed to be enough. Its support was added recently to Main.java
but the call to ActivityStatus to actually fire the notification for clients is
missing. I will prepare a CL fixing this right now. Please keep your code as it
is. 

+    app_on_background_ = true;
+    WriteToDisk();
+  }
+}
+#endif
+
 void SimpleIndex::WriteToDisk() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   if (!initialized_)
     return;
   UMA_HISTOGRAM_CUSTOM_COUNTS("SimpleCache.IndexNumEntriesOnWrite",
                               entries_set_.size(), 0, 100000, 50);
   const base::TimeTicks start = base::TimeTicks::Now();
   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),
       start));
 }
 
 }  // namespace disk_cache