[Offline pages] Implementation of OfflineBackgroundTask using background_task_scheduler

chrome/android/java/src/org/chromium/chrome/browser/offlinepages/BackgroundOfflinerTask.java

 // Copyright 2016 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.offlinepages;
 
 import android.content.Context;
 import android.os.Bundle;
+import android.os.PersistableBundle;
 
 import org.chromium.base.ApplicationStatus;
 import org.chromium.base.Callback;
 import org.chromium.base.Log;
 import org.chromium.base.SysUtils;
 import org.chromium.chrome.browser.ChromeBackgroundServiceWaiter;
 import org.chromium.chrome.browser.offlinepages.interfaces.BackgroundSchedulerProcessor;
 
 /**
  * Handles servicing of background offlining requests coming via the GcmNetworkManager.
@@ skipping 12 matching lines @@
      * Triggers processing of background offlining requests.  This is called when
      * system conditions are appropriate for background offlining, typically from the
      * GcmTaskService onRunTask() method.  In response, we will start the
      * task processing by passing the call along to the C++ RequestCoordinator.
      * Also starts UMA collection.
      *
      * @returns true for success
      */
     public void startBackgroundRequests(
             Context context, Bundle bundle, final ChromeBackgroundServiceWaiter waiter) {
+        TriggerConditions triggerConditions =
+                TaskExtrasPacker.unpackTriggerConditionsFromBundle(bundle);
+        // Set up backup scheduled task in case processing is killed before RequestCoordinator
+        // has a chance to reschedule base on remaining work.
+        BackgroundScheduler.getInstance(context).scheduleBackup(
+                triggerConditions, DEFER_START_SECONDS);
+        long taskScheduledTimeMillis = TaskExtrasPacker.unpackTimeFromBundle(bundle);
         // Complete the wait if background request processing was not started.
         // If background processing was started, completion is going to be handled by callback.
-        if (!startBackgroundRequestsImpl(context, bundle, waiter)) {
+        if (!startBackgroundRequestsImpl(
+                    context, triggerConditions, taskScheduledTimeMillis, createCallback(waiter))) {
             waiter.onWaitDone();
         }
     }
 
+    /** TODO(fgorski): add documentation

[Pete Williamson, 2017/02/21 18:43:43]

Let's add the doc now instead of later.  Why do we overload this?  Maybe one is
for use by GCM, one for JS?

+     * When result is true we are going to be doing work...
+     */
+    public boolean startBackgroundRequests(
+            Context context, PersistableBundle bundle, Callback<Boolean> callback) {
+        // TODO(fgorski): I may not need the backup job... which is handled by the BGJobScheduler
+        // already
+        TriggerConditions conditions = TaskExtrasPacker.unpackTriggerConditionsFromBundle(bundle);
+        long taskScheduledTimeMillis = TaskExtrasPacker.unpackTimeFromBundle(bundle);
+        return startBackgroundRequestsImpl(context, conditions, taskScheduledTimeMillis, callback);
+    }
+
     /**
      * Triggers processing of background offlining requests.  This is called when
      * system conditions are appropriate for background offlining, typically from the
      * GcmTaskService onRunTask() method.  In response, we will start the
      * task processing by passing the call along to the C++ RequestCoordinator.
      * Also starts UMA collection.
      *
-     * @returns true for success
+     * @returns Whether processing will be carried out and completion will be indicated through a
+     *     callback.
      */
-    private boolean startBackgroundRequestsImpl(
-            Context context, Bundle bundle, final ChromeBackgroundServiceWaiter waiter) {
-        // Set up backup scheduled task in case processing is killed before RequestCoordinator
-        // has a chance to reschedule base on remaining work.
-        TriggerConditions previousTriggerConditions =
-                TaskExtrasPacker.unpackTriggerConditionsFromBundle(bundle);
-        BackgroundScheduler.getInstance(context).scheduleBackup(
-                previousTriggerConditions, DEFER_START_SECONDS);
-
+    private boolean startBackgroundRequestsImpl(Context context,
+            TriggerConditions triggerConditions, long taskScheduledTimeMillis,
+            Callback<Boolean> callback) {
         DeviceConditions currentConditions = OfflinePageUtils.getDeviceConditions(context);
         if (!currentConditions.isPowerConnected()
                 && currentConditions.getBatteryPercentage()
-                        < previousTriggerConditions.getMinimumBatteryPercentage()) {
+                        < triggerConditions.getMinimumBatteryPercentage()) {
             Log.d(TAG, "Battery percentage is lower than minimum to start processing");
             return false;
         }
 
         if (SysUtils.isLowEndDevice() && ApplicationStatus.hasVisibleActivities()) {
             Log.d(TAG, "Application visible on low-end device so deferring background processing");
             return false;
         }
 
         // Gather UMA data to measure how often the user's machine is amenable to background
         // loading when we wake to do a task.
-        long taskScheduledTimeMillis = TaskExtrasPacker.unpackTimeFromBundle(bundle);
         OfflinePageUtils.recordWakeupUMA(context, taskScheduledTimeMillis);
 
-        return mBridge.startScheduledProcessing(currentConditions, createCallback(waiter));
+        return mBridge.startScheduledProcessing(currentConditions, callback);
     }
 
     private Callback<Boolean> createCallback(final ChromeBackgroundServiceWaiter waiter) {
         return new Callback<Boolean>() {
             /** Callback releasing the wakelock once background work concludes. */
             @Override
             public void onResult(Boolean result) {
                 Log.d(TAG, "onProcessingDone");
                 // Release the wake lock.
                 waiter.onWaitDone();
             }
         };
     }
 }