[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.
  *
  * 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");
         }
@@ skipping 10 matching lines @@
     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); }
 
+    private void scheduleLaunchTask() {

[jkarlin, 2015/09/02 18:16:36]

It appears that this can be called multiple times, resulting in multiple tasks.
Should we check for this? Or perhaps removeScheduledTasks() first?

[iclelland, 2015/09/02 20:04:48]

If it is called when there is already a task scheduled, the re-use of the same
tag ("BackgroundSync Event") means that the existing task will just be updated.

[jkarlin, 2015/09/03 11:11:57]

Acknowledged.

+        // 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, 0)
+                .setRequiredNetwork(Task.NETWORK_STATE_CONNECTED)
+                .setPersisted(true)
+                .setUpdateCurrent(true)
+                .build();
+        mScheduler.schedule(oneoff);
+    }
+
+    private void removeScheduledTasks() {
+        mScheduler.cancelAllTasks(BackgroundSyncLauncherService.class);
+    }
+
     /**
      * 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) {
@@ skipping 18 matching lines @@
      * call is asynchronous.
      */
     @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)

[jkarlin, 2015/09/02 18:16:36]

Do we still need this preference?

[iclelland, 2015/09/02 20:04:48]

I wasn't certain. I was still tracing through the code to see when and how it
was used. Is there any situation where the user starts the browser (rather than
the GcmNetworkManager starting it) where we'd need to check this preference?

Or in that case, does the background sync manager just always run through its
list of registrations when browser starts?

If the preference can be removed, then that should clear up a lot of other code
as well.

[jkarlin, 2015/09/03 11:11:57]

Nope, this isn't checked by the C++ code, only by the BackgroundSyncLauncher
code.
Yep.
Definitely, I'll be happy to see it go.

[iclelland, 2015/09/03 15:52:06]

Done.

                         .apply();
                 return null;
             }
         }.execute();
+        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) {
+        mScheduler = GcmNetworkManager.getInstance(context);
         setLaunchWhenNextOnline(context, false);
     }
-}
+}