Only set precache.last_time when precache ran.

chrome/android/java/src/org/chromium/chrome/browser/precache/PrecacheServiceLauncher.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.AlarmManager;
 import android.app.PendingIntent;
 import android.content.BroadcastReceiver;
 import android.content.Context;
@@ skipping 40 matching lines @@
     void setDeviceState(DeviceState deviceState) {
         mDeviceState = deviceState;
     }
 
     /**
      * Set whether or not precaching is enabled. If precaching is enabled, this receiver will start
      * the PrecacheService when it receives an intent. If precaching is disabled, any running
      * PrecacheService will be stopped, and this receiver will do nothing when it receives an
      * intent.
      *
-     * @param context The Context to use.
+     * @param context The application context.
      * @param enabled Whether or not precaching is enabled.
      */
     public static void setIsPrecachingEnabled(Context context, boolean enabled) {
         Log.v(TAG, "setIsPrecachingEnabled(%s)", enabled);
         Editor editor = PreferenceManager.getDefaultSharedPreferences(context).edit();
         editor.putBoolean(PREF_IS_PRECACHING_ENABLED, enabled);
         editor.apply();
 
         if (!enabled) {
             // Stop any running PrecacheService. If PrecacheService is not running, then this does
             // nothing.
             Intent serviceIntent = new Intent(null, null, context, PrecacheService.class);
             context.stopService(serviceIntent);
         }
     }
 
+    /**
+     * Handler for when precaching has finished. If precaching had successfully started, sets an
+     * alarm for a subsequent run, and updates the last precache time. If not (i.e. the precache
+     * attempt aborted), sets an alarm for another attempt.
+     *
+     * @param context The application context.
+     * @param precacheStarted Whether precaching successfully started.
+     */
+    public static void precachingFinished(Context context, boolean precacheStarted) {
+        new PrecacheServiceLauncher().precachingFinishedInternal(context, precacheStarted);
+    }
+
+    private void precachingFinishedInternal(Context context, boolean precacheStarted) {
+        Log.v(TAG, "precachingFinished(%s)", precacheStarted);
+        if (precacheStarted) {
+            // Store a pref indicating that precaching is starting now.
+            setAlarm(context,
+                    Math.max(INTERACTIVE_STATE_POLLING_PERIOD_MS, WAIT_UNTIL_NEXT_PRECACHE_MS));
+
+            Editor editor = PreferenceManager.getDefaultSharedPreferences(context).edit();
+            editor.putLong(PREF_PRECACHE_LAST_TIME, getElapsedRealtimeOnSystem());
+            editor.apply();
+        } else {
+            setAlarm(context,
+                    Math.max(INTERACTIVE_STATE_POLLING_PERIOD_MS,
+                            WAIT_UNTIL_NEXT_PRECACHE_MS - timeSinceLastPrecacheMs(context)));
+        }
+    }
+
     @VisibleForTesting
     static boolean isPrecachingEnabled(Context context) {
         SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
         return prefs.getBoolean(PREF_IS_PRECACHING_ENABLED, false);
     }
 
     @Override
     public void onReceive(Context context, Intent intent) {
-        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
-        long lastPrecacheTimeMs = prefs.getLong(PREF_PRECACHE_LAST_TIME, 0L);
-        if (lastPrecacheTimeMs > getElapsedRealtimeOnSystem()) {
-            // System.elapsedRealtime() counts milliseconds since boot, so if the device has been
-            // rebooted since the last time precaching was performed, reset lastPrecacheTimeMs to 0.
-            lastPrecacheTimeMs = 0L;
-        }
-
         // Do nothing if precaching is disabled.
         if (!isPrecachingEnabled(context)) return;
 
         boolean isPowerConnected = mDeviceState.isPowerConnected(context);
         boolean isWifiAvailable = mDeviceState.isWifiAvailable(context);
         boolean isInteractive = mDeviceState.isInteractive(context);
         boolean areConditionsGoodForPrecaching =
                 isPowerConnected && isWifiAvailable && !isInteractive;
-        long timeSinceLastPrecacheMs = getElapsedRealtimeOnSystem() - lastPrecacheTimeMs;
         boolean hasEnoughTimePassedSinceLastPrecache =
-                timeSinceLastPrecacheMs >= WAIT_UNTIL_NEXT_PRECACHE_MS;
+                timeSinceLastPrecacheMs(context) >= WAIT_UNTIL_NEXT_PRECACHE_MS;
 
         // Only start precaching when an alarm action is received. This is to prevent situations
         // such as power being connected, precaching starting, then precaching being immediately
         // canceled because the screen turns on in response to power being connected.
         if (ACTION_ALARM.equals(intent.getAction())
                 && areConditionsGoodForPrecaching
                 && hasEnoughTimePassedSinceLastPrecache) {
-            // Store a pref indicating that precaching is starting now.
-            Editor editor = prefs.edit();
-            editor.putLong(PREF_PRECACHE_LAST_TIME, getElapsedRealtimeOnSystem());
-            editor.apply();
-
-            setAlarm(context, Math.max(
-                    INTERACTIVE_STATE_POLLING_PERIOD_MS, WAIT_UNTIL_NEXT_PRECACHE_MS));
-
             acquireWakeLockAndStartService(context);
         } else {
             if (isPowerConnected && isWifiAvailable) {
                 // If we're just waiting for non-interactivity (e.g., the screen to be off), or for
                 // enough time to pass after Wi-Fi or power has been connected, then set an alarm
                 // for the next time to check the device state. We can't receive SCREEN_ON/OFF
                 // intents as is done for detecting changes in power and connectivity, because
                 // SCREEN_ON/OFF intents are only delivered to BroadcastReceivers that are
                 // registered dynamically in code, but the PrecacheServiceLauncher is registered in
                 // the Android manifest.
-                setAlarm(context, Math.max(INTERACTIVE_STATE_POLLING_PERIOD_MS,
-                        WAIT_UNTIL_NEXT_PRECACHE_MS - timeSinceLastPrecacheMs));
+                setAlarm(context,
+                        Math.max(INTERACTIVE_STATE_POLLING_PERIOD_MS,
+                                WAIT_UNTIL_NEXT_PRECACHE_MS - timeSinceLastPrecacheMs(context)));
             } else {
                 // If the device doesn't have connected power or doesn't have Wi-Fi, then there's no
                 // point in setting an alarm.
                 cancelAlarm(context);
             }
         }
     }
 
     /** Release the wakelock if it is held. */
     @VisibleForTesting
@@ skipping 76 matching lines @@
     @VisibleForTesting
     protected void cancelAlarmOnSystem(Context context, PendingIntent operation) {
         AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
         alarmManager.cancel(operation);
     }
 
     @VisibleForTesting
     protected long getElapsedRealtimeOnSystem() {
         return SystemClock.elapsedRealtime();
     }
+
+    /** Returns the number of milliseconds since the last precache run completed. */
+    private long timeSinceLastPrecacheMs(Context context) {
+        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
+        long lastPrecacheTimeMs = prefs.getLong(PREF_PRECACHE_LAST_TIME, 0L);
+        if (lastPrecacheTimeMs > getElapsedRealtimeOnSystem()) {
+            // System.elapsedRealtime() counts milliseconds since boot, so if the device has been
+            // rebooted since the last time precaching was performed, reset lastPrecacheTimeMs to 0.
+            lastPrecacheTimeMs = 0L;
+        }
+        return getElapsedRealtimeOnSystem() - lastPrecacheTimeMs;
+    }
 }