Only set precache.last_time when precache ran.

chrome/android/java/src/org/chromium/chrome/browser/precache/PrecacheService.java

 // Copyright 2015 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.
 
 package org.chromium.chrome.browser.precache;
 
 import android.app.Service;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
@@ skipping 54 matching lines @@
             }
         }
     };
 
     @VisibleForTesting
     BroadcastReceiver getDeviceStateReceiver() {
         return mDeviceStateReceiver;
     }
 
     @VisibleForTesting
-    void handlePrecacheCompleted() {
-        if (mIsPrecaching) finishPrecaching();
+    void handlePrecacheCompleted(boolean precacheStarted) {
+        if (mIsPrecaching) finishPrecaching(precacheStarted);
     }
 
     /** PrecacheLauncher used to run precaching. */
     private PrecacheLauncher mPrecacheLauncher = new PrecacheLauncher() {
         @Override
-        protected void onPrecacheCompleted() {
-            handlePrecacheCompleted();
+        protected void onPrecacheCompleted(boolean precacheStarted) {

[bengr, 2015/08/05 23:25:35]

Why would onPrecachCompleted be called if precacheStarted is false?

[twifkak, 2015/08/06 00:09:46]

There are two cases:
https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/and...

This should be obvious: precache_manager is not there for some reason.

https://code.google.com/p/chromium/codesearch#chromium/src/components/precach...

The latter is a little less obvious, but you can see at line 102 that
is_precaching_ is set only if ShouldRun(). So not having sync tabs or not being
in the field trial would cause this to call onPrecacheCompleted(false).

Is it okay that this runs (and does nothing) every 15 minutes for people not in
the field trial or for people opted out of sync?

[bengr, 2015/08/07 18:41:57]

It's not ideal. What would it take to prevent it?

[twifkak, 2015/08/07 21:48:15]

Done. I renamed the parameter since it's a misnomer now.

+            handlePrecacheCompleted(precacheStarted);
         }
     };
 
     @VisibleForTesting
     void setPrecacheLauncher(PrecacheLauncher precacheLauncher) {
         mPrecacheLauncher = precacheLauncher;
     }
 
     @Override
     public void onCreate() {
@@ skipping 60 matching lines @@
         acquirePrecachingWakeLock();
 
         // In certain cases, the PrecacheLauncher will skip precaching entirely and call
         // finishPrecaching() before this call to mPrecacheLauncher.start() returns, so the call to
         // mPrecacheLauncher.start() must happen after acquiring the wake lock to ensure that the
         // wake lock is released properly.
         mPrecacheLauncher.start();
     }
 
     /** End a precache cycle. */
-    private void finishPrecaching() {
+    private void finishPrecaching(boolean precacheStarted) {
         Log.v(TAG, "Finish precaching");
-        shutdownPrecaching();
+        shutdownPrecaching(precacheStarted);
     }
 
     /** Cancel a precache cycle. */
     private void cancelPrecaching() {
         Log.v(TAG, "Cancel precaching");
         prepareNativeLibraries();
         mPrecacheLauncher.cancel();
 
-        shutdownPrecaching();
+        shutdownPrecaching(true);
     }
 
     /**
      * Update state to indicate that precaching is no longer in progress, and stop the service.
      */
-    private void shutdownPrecaching() {
+    private void shutdownPrecaching(boolean precacheStarted) {
         mIsPrecaching = false;
         releasePrecachingWakeLock();
+        PrecacheServiceLauncher.precachingFinished(getApplicationContext(), precacheStarted);
         stopSelf();
     }
 
     /** Register a BroadcastReceiver to detect when conditions become wrong for precaching. */
     private void registerDeviceStateReceiver() {
         IntentFilter filter = new IntentFilter();
         filter.addAction(Intent.ACTION_POWER_DISCONNECTED);
         filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
         filter.addAction(Intent.ACTION_SCREEN_ON);
         registerReceiver(mDeviceStateReceiver, filter);
     }
 
     /** Acquire the precaching WakeLock. */
     private void acquirePrecachingWakeLock() {
         if (mPrecachingWakeLock == null) {
             PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
             mPrecachingWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
         }
         mPrecachingWakeLock.acquire();
     }
 
     /** Release the precaching WakeLock if it is held. */
     private void releasePrecachingWakeLock() {
         if (mPrecachingWakeLock != null && mPrecachingWakeLock.isHeld()) {
             mPrecachingWakeLock.release();
         }
     }
 }