[Offline pages] Refactoring and code fix in BackgroundOffinerTask

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 org.chromium.base.ApplicationStatus;
 import org.chromium.base.Callback;
 import org.chromium.base.Log;
 import org.chromium.base.SysUtils;
-import org.chromium.base.VisibleForTesting;
 import org.chromium.chrome.browser.ChromeBackgroundServiceWaiter;
 import org.chromium.chrome.browser.offlinepages.interfaces.BackgroundSchedulerProcessor;
 
 /**
  * Handles servicing of background offlining requests coming via the GcmNetworkManager.
  */
 public class BackgroundOfflinerTask {
     private static final String TAG = "BGOfflinerTask";
     private static final long DEFER_START_SECONDS = 5 * 60;
 
     public BackgroundOfflinerTask(BackgroundSchedulerProcessor bridge) {
         mBridge = bridge;
     }
 
     private final BackgroundSchedulerProcessor mBridge;
 
     /**
      * 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 boolean startBackgroundRequests(Context context, Bundle bundle,
-                                           ChromeBackgroundServiceWaiter waiter) {
+    public void startBackgroundRequests(
+            Context context, Bundle bundle, final ChromeBackgroundServiceWaiter waiter) {
+        // 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)) {
+            waiter.onWaitDone();
+        }
+    }
+
+    /**
+     * 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
+     */
+    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.backupSchedule(context, previousTriggerConditions, DEFER_START_SECONDS);
 
         DeviceConditions currentConditions = OfflinePageUtils.getDeviceConditions(context);
         if (!currentConditions.isPowerConnected()
                 && currentConditions.getBatteryPercentage()
                         < previousTriggerConditions.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;
         }
 
-        // Now initiate processing.
-        processBackgroundRequests(bundle, currentConditions, waiter);
-
         // 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 true;
+        return mBridge.startScheduledProcessing(currentConditions, createCallback(waiter));
     }
 
-    /**
-     * Triggers processing of background offlining requests.
-     */
-    // TODO(petewil): Change back to private when UMA works in the test, and test
-    // startBackgroundRequests instead of this method.
-    @VisibleForTesting
-    public void processBackgroundRequests(
-            Bundle bundle, DeviceConditions deviceConditions,
-            final ChromeBackgroundServiceWaiter waiter) {
-        // TODO(petewil): Nothing is holding the Wake Lock.  We need some solution to
-        // keep hold of it.  Options discussed so far are having a fresh set of functions
-        // to grab and release a countdown latch, or holding onto the wake lock ourselves,
-        // or grabbing the wake lock and then starting chrome and running
-        // startScheduledProcessing on the UI thread.
-
-        // TODO(petewil): Decode the TriggerConditions from the bundle.
-
-        Callback<Boolean> callback = new Callback<Boolean>() {
-            /**
-             * Callback function which indicates completion of background work.
-             * @param result - true if work was actually done (used for UMA).
-             */
+    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.
-                Log.d(TAG, "onProcessingDone");
                 waiter.onWaitDone();
             }
         };
-
-        // Pass the activation on to the bridge to the C++ RequestCoordinator.
-        if (!mBridge.startScheduledProcessing(deviceConditions, callback)) {
-            // Processing not started currently. Let callback know.
-            callback.onResult(false);
-        }
     }
 }