Have SimpleCache index listen to android activity status notifications.

net/disk_cache/simple/simple_index.cc

Index: net/disk_cache/simple/simple_index.cc
diff --git a/net/disk_cache/simple/simple_index.cc b/net/disk_cache/simple/simple_index.cc
index d7d6408cadff790bb71453c48dc2a5feecbdedf9..1a69347fe804120180d92fbfbf7f9b5de9b3ca54 100644
--- a/net/disk_cache/simple/simple_index.cc
+++ b/net/disk_cache/simple/simple_index.cc
@@ -32,10 +32,8 @@ 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.
@@ -157,8 +155,12 @@ void EntryMetadata::MergeWith(const EntryMetadata& from) {
 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),
@@ -166,7 +168,8 @@ SimpleIndex::SimpleIndex(
       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() {
@@ -374,19 +377,12 @@ void SimpleIndex::InsertInEntrySet(
 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()));
 }
 
@@ -546,7 +542,6 @@ void SimpleIndex::MergeInitializingSet(scoped_ptr<EntrySet> index_file_entries,
       cache_size_ += it->second.GetEntrySize();
     }
   }
-  last_write_to_disk_ = base::Time::Now();
   initialized_ = true;
   removed_entries_.clear();
 
@@ -565,6 +560,22 @@ void SimpleIndex::MergeInitializingSet(scoped_ptr<EntrySet> index_file_entries,
   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_)