Tweaks to the precache triggering code.

chrome/android/java/src/org/chromium/chrome/browser/precache/PrecacheLauncher.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.content.Context;
 
+import org.chromium.base.Log;
 import org.chromium.base.ThreadUtils;
+import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.chrome.browser.preferences.privacy.PrivacyPreferencesManager;
-
-import java.util.concurrent.Callable;
+import org.chromium.chrome.browser.sync.ProfileSyncService;
 
 /** Class that interacts with the PrecacheManager to control precache cycles. */
 public abstract class PrecacheLauncher {
+    private static final String TAG = "cr.Precache";
+
     /** Pointer to the native PrecacheLauncher object. Set to 0 when uninitialized. */
     private long mNativePrecacheLauncher;
 
     /** Destroy the native PrecacheLauncher, releasing the memory that it was using. */
     public void destroy() {
         if (mNativePrecacheLauncher != 0) {
             nativeDestroy(mNativePrecacheLauncher);
             mNativePrecacheLauncher = 0;
         }
     }
@@ skipping 22 matching lines @@
     /**
      * Called by native code when the precache cycle completes. This method exists because an
      * abstract method cannot be directly called from native.
      */
     @CalledByNative
     private void onPrecacheCompletedCallback() {
         onPrecacheCompleted();
     }
 
     /**
-     * Returns true if precaching is enabled by either Finch or the command line flag, and also by
-     * the predictive network actions preference and current network connection type.
+     * Updates the PrecacheServiceLauncher with whether conditions are right for precaching. All of
+     * the following must be true:
      *
-     * @param privacyPreferencesManager Singleton that manages the prefetch bandwidth preference.
+     * <ul>
+     *   <li>The predictive network actions preference is enabled.</li>
+     *   <li>The current network type is suitable for predictive network actions.</li>
+     *   <li>Sync is enabled for sessions and it is not encrypted with a secondary passphrase.</li>
+     *   <li>Either the Precache field trial or the precache commandline flag is enabled.</li>
+     * </ul>
+     *
+     * This should be called only after the sync backend has been initialized. Must be called on the
+     * UI thread.
+     *
+     * @param context The application context.
      */
-    public static boolean isPrecachingEnabled(
-            final PrivacyPreferencesManager privacyPreferencesManager) {
-        if (!nativeIsPrecachingEnabled()) return false;
-        // privacyPreferencesManager.shouldPrerender() can only be executed on the UI thread.
-        return ThreadUtils.runOnUiThreadBlockingNoException(new Callable<Boolean>() {
+    private void updateEnabledSync(Context context) {
+        PrivacyPreferencesManager privacyPreferencesManager =
+                PrivacyPreferencesManager.getInstance(context);
+
+        // privacyPreferencesManager.shouldPrerender() and nativeShouldRun() can only be executed on
+        // the UI thread.
+        PrecacheServiceLauncher.setIsPrecachingEnabled(
+                context, privacyPreferencesManager.shouldPrerender() && nativeShouldRun());
+        Log.v(TAG, "updateEnabledSync complete");
+    }
+
+    /**
+     * If precaching is enabled, then allow the PrecacheService to be launched and signal Chrome
+     * when conditions are right to start precaching. If precaching is disabled, prevent the
+     * PrecacheService from ever starting.
+     *
+     * @param context Any context within the application.
+     */
+    @VisibleForTesting
+    void updateEnabled(final Context context) {
+        Log.v(TAG, "updateEnabled starting");
+        ThreadUtils.postOnUiThread(new Runnable() {
             @Override
-            public Boolean call() {
-                return privacyPreferencesManager.shouldPrerender();
+            public void run() {
+                final ProfileSyncService sync = ProfileSyncService.get(context);
+
+                if (mListener == null) {
+                    mListener = new ProfileSyncService.SyncStateChangedListener() {
+                        public void syncStateChanged() {
+                            if (sync.isSyncInitialized()) {
+                                updateEnabledSync(context);
+                            }
+                        }
+                    };
+                    sync.addSyncStateChangedListener(mListener);
+                }
+
+                // Call the listener once, in case the sync backend is already initialized.
+                mListener.syncStateChanged();
+                Log.v(TAG, "updateEnabled complete");
             }
         });
     }
 
     /**
      * If precaching is enabled, then allow the PrecacheService to be launched and signal Chrome
      * when conditions are right to start precaching. If precaching is disabled, prevent the
      * PrecacheService from ever starting.
      *
-     * @param privacyPreferencesManager Singleton that manages the prefetch bandwidth preference.
-     * @param context The context of the PrecacheServiceLauncher.
+     * @param context Any context within the application.
      */
-    public static void updatePrecachingEnabled(PrivacyPreferencesManager privacyPreferencesManager,
-            Context context) {
-        PrecacheServiceLauncher.setIsPrecachingEnabled(context,
-                isPrecachingEnabled(privacyPreferencesManager));
+    public static void updatePrecachingEnabled(final Context context) {
+        sInstance.updateEnabled(context);
     }
 
+    private static final PrecacheLauncher sInstance = new PrecacheLauncher() {
+        @Override
+        protected void onPrecacheCompleted() {}
+    };
+
+    // Initialized by updateEnabled to call updateEnabledSync when the sync
+    // backend is initialized. Only accessed on the UI thread.
+    private ProfileSyncService.SyncStateChangedListener mListener = null;
+
     private native long nativeInit();
     private native void nativeDestroy(long nativePrecacheLauncher);
     private native void nativeStart(long nativePrecacheLauncher);
     private native void nativeCancel(long nativePrecacheLauncher);
-    private static native boolean nativeIsPrecachingEnabled();
+
+    @VisibleForTesting native boolean nativeShouldRun();
 }