[Background Sync] Use GcmNetworkManager to start the browser for sync events.

content/public/android/java/src/org/chromium/content/browser/BackgroundSyncLauncher.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.content.browser;
 
 import android.content.Context;
-import android.content.SharedPreferences;
-import android.os.AsyncTask;
-import android.preference.PreferenceManager;
+
+import com.google.android.gms.gcm.GcmNetworkManager;
+import com.google.android.gms.gcm.OneoffTask;
+import com.google.android.gms.gcm.Task;
 
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 
 /**
  * The {@link BackgroundSyncLauncher} singleton is created and owned by the C++ browser. It
  * registers interest in waking up the browser the next time the device goes online after the
  *browser closes via the {@link #setLaunchWhenNextOnline} method.

[jkarlin, 2015/09/04 13:21:35]

while you're here, can you add a space after the above *?

  *
  * Thread model: This class is to be run on the UI thread only.
  */
 @JNINamespace("content")
 public class BackgroundSyncLauncher {
-    static final String PREF_BACKGROUND_SYNC_LAUNCH_NEXT_ONLINE = "bgsync_launch_next_online";
-
     // The instance of BackgroundSyncLauncher currently owned by a C++
     // BackgroundSyncLauncherAndroid, if any. If it is non-null then the browser is running.
     private static BackgroundSyncLauncher sInstance;
 
+    private GcmNetworkManager mScheduler;
+
     /**
      * Create a BackgroundSyncLauncher object, which is owned by C++.
      * @param context The app context.
      */
     @VisibleForTesting
     @CalledByNative
     protected static BackgroundSyncLauncher create(Context context) {
         if (sInstance != null) {
             throw new IllegalStateException("Already instantiated");
         }
 
         sInstance = new BackgroundSyncLauncher(context);
         return sInstance;
     }
 
     /**
      * Called when the C++ counterpart is deleted.
      */
     @VisibleForTesting
     @CalledByNative
     protected void destroy() {
         assert sInstance == this;
         sInstance = null;
     }
 
     /**
-     * Callback for {@link #shouldLaunchWhenNextOnline}. The run method is invoked on the UI thread.
-     */
-    public static interface ShouldLaunchCallback { public void run(Boolean shouldLaunch); }
-
-    /**
-     * Returns whether the browser should be launched when the device next goes online.
-     * This is set by C++ and reset to false each time {@link BackgroundSyncLauncher}'s singleton is
-     * created (the native browser is started). This call is asynchronous and will run the callback
-     * on the UI thread when complete.
-     * @param context The application context.
-     * @param sharedPreferences The shared preferences.
-     */
-    protected static void shouldLaunchWhenNextOnline(
-            final Context context, final ShouldLaunchCallback callback) {
-        new AsyncTask<Void, Void, Boolean>() {
-            @Override
-            protected Boolean doInBackground(Void... params) {
-                SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
-                return prefs.getBoolean(PREF_BACKGROUND_SYNC_LAUNCH_NEXT_ONLINE, false);
-            }
-            @Override
-            protected void onPostExecute(Boolean shouldLaunch) {
-                callback.run(shouldLaunch);
-            }
-        }.execute();
-    }
-
-    /**
      * Set interest (or disinterest) in launching the browser the next time the device goes online
-     * after the browser closes. On creation of the {@link BackgroundSyncLauncher} class (on browser
-     * start) this value is reset to false. This is set by C++ and reset to false each time
-     * {@link BackgroundSyncLauncher}'s singleton is created (the native browser is started). This
-     * call is asynchronous.
+     * after the browser closes, by scheduling a one-shot task to launch the browser. On creation
+     * of the {@link BackgroundSyncLauncher} class (on browser start) this is reset to false
+     * (removing any scheduled tasks). This is set by C++ and reset to false each time
+     * {@link BackgroundSyncLauncher}'s singleton is created (the native browser is started).

[jkarlin, 2015/09/04 13:21:35]

Any chance you could rephrase the entire above comment? It's hard to follow.

[iclelland, 2015/09/10 20:40:46]

Rewritten -- hopefully clearer now.

      */
     @VisibleForTesting
     @CalledByNative
-    protected void setLaunchWhenNextOnline(final Context context, final boolean shouldLaunch) {
-        new AsyncTask<Void, Void, Void>() {
-            @Override
-            protected Void doInBackground(Void... params) {
-                SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
-                prefs.edit()
-                        .putBoolean(PREF_BACKGROUND_SYNC_LAUNCH_NEXT_ONLINE, shouldLaunch)
-                        .apply();
-                return null;
-            }
-        }.execute();
+    protected void setLaunchWhenNextOnline(final boolean shouldLaunch) {

[jkarlin, 2015/09/04 13:21:35]

The name of this function could be clearer, perhaps
"launchBrowserWhenNextOnlineIfStopped"?

[iclelland, 2015/09/10 20:40:46]

Done.

+        if (shouldLaunch) {
+            scheduleLaunchTask();
+        } else {
+            removeScheduledTasks();
+        }
     }
 
     /**
      * True if the native browser has started and created an instance of {@link
      * BackgroundSyncLauncher}.
      */
     protected static boolean hasInstance() {
         return sInstance != null;
     }
 
     private BackgroundSyncLauncher(Context context) {
-        setLaunchWhenNextOnline(context, false);
+        mScheduler = GcmNetworkManager.getInstance(context);
+        setLaunchWhenNextOnline(false);
     }
-}
+
+    private void scheduleLaunchTask() {
+        // Google Play Services may not be up to date, if the application was not installed through
+        // the Play Store. In this case, scheduling the task will fail silently.
+        // TODO(iclelland): Check whether the Play Services client library matches the requirements
+        // in the manifest, and respond appropriately if it does not.
+        OneoffTask oneoff = new OneoffTask.Builder()
+                .setService(BackgroundSyncLauncherService.class)
+                .setTag("BackgroundSync Event")
+                .setExecutionWindow(0, 1)
+                .setRequiredNetwork(Task.NETWORK_STATE_CONNECTED)
+                .setPersisted(true)
+                .setUpdateCurrent(true)
+                .build();
+        mScheduler.schedule(oneoff);
+    }
+
+    private void removeScheduledTasks() {
+        mScheduler.cancelAllTasks(BackgroundSyncLauncherService.class);
+    }

[jkarlin, 2015/09/04 13:21:35]

I just saw this in the docs: 
Important: When Google Play Services or the client app is updated, all scheduled
tasks will be removed. GcmNetworkManager invokes the client app’s
onInitializeTasks(). Override this function to reschedule necessary tasks.
https://developers.google.com/cloud-messaging/network-manager

So we might need to keep track of the preference after all so that we can start
up the tasks again.

[iclelland, 2015/09/10 20:40:46]

I'll add a TODO to handle the update case better. This probably doesn't affect
one-shots so much, since neither play services nor chrome are likely to be
updated when the device is offline. We'll definitely have to handle this before
adding either periodic or power-sensitive one-shots.

[jkarlin, 2015/09/11 18:57:55]

We'll also need it for retries as retry has an exponential backoff so it's
possible for a one-shot to not fire for some time after going online. Given that
we already have the code to store the preference, it probably makes sense to
restore it and add the onInitializeTasks handler in this CL.

[iclelland, 2015/09/24 13:40:53]

Done.

+}