Separate deferred startup into tasks.

chrome/android/java/src/org/chromium/chrome/browser/DeferredStartupHandler.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;
 
 import android.content.Context;
 import android.content.Intent;
 import android.content.SharedPreferences;
 import android.content.pm.ResolveInfo;
 import android.net.Uri;
 import android.os.AsyncTask;
+import android.os.Looper;
+import android.os.MessageQueue;
 import android.os.SystemClock;
 import android.support.annotation.UiThread;
 import android.support.annotation.WorkerThread;
 import android.view.inputmethod.InputMethodInfo;
 import android.view.inputmethod.InputMethodManager;
 import android.view.inputmethod.InputMethodSubtype;
 
 import org.chromium.base.CommandLine;
 import org.chromium.base.ContextUtils;
 import org.chromium.base.FieldTrialList;
@@ skipping 15 matching lines @@
 import org.chromium.chrome.browser.partnercustomizations.PartnerBrowserCustomizations;
 import org.chromium.chrome.browser.physicalweb.PhysicalWeb;
 import org.chromium.chrome.browser.precache.PrecacheLauncher;
 import org.chromium.chrome.browser.preferences.ChromePreferenceManager;
 import org.chromium.chrome.browser.preferences.privacy.PrivacyPreferencesManager;
 import org.chromium.chrome.browser.share.ShareHelper;
 import org.chromium.chrome.browser.webapps.WebApkVersionManager;
 import org.chromium.content.browser.ChildProcessLauncher;
 
 import java.util.ArrayList;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Locale;
+import java.util.Queue;
 import java.util.concurrent.TimeUnit;
 
 /**
  * Handler for application level tasks to be completed on deferred startup.
  */
 public class DeferredStartupHandler {
+    private static final String TAG = "DeferredStartupHandler";
     /** Prevents race conditions when deleting snapshot database. */
     private static final Object SNAPSHOT_DATABASE_LOCK = new Object();
     private static final String SNAPSHOT_DATABASE_REMOVED = "snapshot_database_removed";
     private static final String SNAPSHOT_DATABASE_NAME = "snapshots.db";
 
     private static class Holder {
         private static final DeferredStartupHandler INSTANCE = new DeferredStartupHandler();
     }
 
-    private boolean mDeferredStartupComplete;
+    private boolean mDeferredStartupInitialized;
+    private boolean mDeferredStartupCompleted;
+    private long mDeferredStartupDuration;
+    private long mMaxTaskDuration;
     private final Context mAppContext;
 
+    @VisibleForTesting
+    final Queue<Runnable> mDeferredTasks;
+
     /**
      * This class is an application specific object that handles the deferred startup.
      * @return The singleton instance of {@link DeferredStartupHandler}.
      */
     public static DeferredStartupHandler getInstance() {
         return Holder.INSTANCE;
     }
 
     private DeferredStartupHandler() {
         mAppContext = ContextUtils.getApplicationContext();
+        mDeferredTasks = new LinkedList<Runnable>();
+    }
+
+    /**
+     * Add the idle handler which will run deferred startup tasks in sequence when idle.
+     */
+    public void queueDeferredTasksOnIdleHandler() {
+        if (!mDeferredStartupInitialized) return;
+
+        Looper.myQueue().addIdleHandler(new MessageQueue.IdleHandler() {
+            @Override
+            public boolean queueIdle() {
+                Runnable currentTask = mDeferredTasks.poll();
+                if (currentTask == null) {
+                    mDeferredStartupCompleted = true;
+                    recordDeferredStartupStats();
+                    return false;
+                }
+
+                long startTime = SystemClock.uptimeMillis();
+                currentTask.run();
+                long timeTaken = SystemClock.uptimeMillis() - startTime;
+
+                mMaxTaskDuration = Math.max(mMaxTaskDuration, timeTaken);
+                mDeferredStartupDuration += timeTaken;
+                return true;
+            }
+        });
+    }
+
+    private void recordDeferredStartupStats() {
+        RecordHistogram.recordLongTimesHistogram(
+                "UMA.Debug.EnableCrashUpload.DeferredStartUpDuration",
+                mDeferredStartupDuration,
+                TimeUnit.MILLISECONDS);
+        RecordHistogram.recordLongTimesHistogram(
+                "UMA.Debug.EnableCrashUpload.DeferredStartUpMaxTaskDuration",
+                mMaxTaskDuration,
+                TimeUnit.MILLISECONDS);
+        RecordHistogram.recordLongTimesHistogram(
+                "UMA.Debug.EnableCrashUpload.DeferredStartUpCompleteTime",
+                SystemClock.uptimeMillis() - UmaUtils.getForegroundStartTime(),
+                TimeUnit.MILLISECONDS);
+    }
+
+    /**
+     * Adds a single deferred task to the queue.
+     *
+     * @param deferredTask The tasks to be run.
+     */
+    public void addDeferredTask(Runnable deferredTask) {
+        if (mDeferredStartupCompleted) {
+            throw new RuntimeException("Scheduling deferred startup task that will never be run.");
+        }
+        ThreadUtils.assertOnUiThread();
+        mDeferredTasks.add(deferredTask);
     }
 
     /**
      * Handle application level deferred startup tasks that can be lazily done after all
      * the necessary initialization has been completed. Any calls requiring network access should
      * probably go here.
+     *
+     * Keep these tasks short and break up long tasks into multiple smaller tasks, as they run on
+     * the UI thread and are blocking. Remember to follow RAIL guidelines, as much as possible, and
+     * that most devices are quite slow, so leave enough buffer.
      */
     @UiThread
-    public void onDeferredStartupForApp() {
-        if (mDeferredStartupComplete) return;
+    public void initDeferredStartupForApp() {
+        if (mDeferredStartupInitialized) return;
+        mDeferredStartupInitialized = true;
         ThreadUtils.assertOnUiThread();
 
-        long startDeferredStartupTime = SystemClock.uptimeMillis();
-
-        RecordHistogram.recordLongTimesHistogram("UMA.Debug.EnableCrashUpload.DeferredStartUptime",
-                startDeferredStartupTime - UmaUtils.getMainEntryPointTime(),
+        RecordHistogram.recordLongTimesHistogram(
+                "UMA.Debug.EnableCrashUpload.DeferredStartUptime2",
+                SystemClock.uptimeMillis() - UmaUtils.getForegroundStartTime(),
                 TimeUnit.MILLISECONDS);
 
-        // Punt all tasks that may block the UI thread off onto a background thread.
+        mDeferredTasks.add(new Runnable() {
+            @Override
+            public void run() {
+                // Punt all tasks that may block on disk off onto a background thread.
+                initAsyncDiskTask();
+
+                AfterStartupTaskUtils.setStartupComplete();
+
+                PartnerBrowserCustomizations.setOnInitializeAsyncFinished(new Runnable() {
+                    @Override
+                    public void run() {
+                        String homepageUrl = HomepageManager.getHomepageUri(mAppContext);
+                        LaunchMetrics.recordHomePageLaunchMetrics(
+                                HomepageManager.isHomepageEnabled(mAppContext),
+                                NewTabPage.isNTPUrl(homepageUrl), homepageUrl);
+                    }
+                });
+
+                PartnerBookmarksShim.kickOffReading(mAppContext);
+
+                PowerMonitor.create(mAppContext);
+
+                ShareHelper.clearSharedImages(mAppContext);
+            }
+        });
+
+        mDeferredTasks.add(new Runnable() {
+            @Override
+            public void run() {
+                // Clear any media notifications that existed when Chrome was last killed.
+                MediaCaptureNotificationService.clearMediaNotifications(mAppContext);
+
+                startModerateBindingManagementIfNeeded();
+
+                recordKeyboardLocaleUma();
+            }
+        });
+
+        mDeferredTasks.add(new Runnable() {
+            @Override
+            public void run() {
+                // Start or stop Physical Web
+                PhysicalWeb.onChromeStart();
+            }
+        });
+
+        final ChromeApplication application = (ChromeApplication) mAppContext;
+
+        mDeferredTasks.add(new Runnable() {
+            @Override
+            public void run() {
+                // Starts syncing with GSA.
+                application.createGsaHelper().startSync();
+            }
+        });
+
+        // This call will add its own tasks to the queue.
+        application.initializeSharedClasses();
+    }
+
+    private void initAsyncDiskTask() {
         new AsyncTask<Void, Void, Void>() {
             @Override
             protected Void doInBackground(Void... params) {
                 try {
                     TraceEvent.begin("ChromeBrowserInitializer.onDeferredStartup.doInBackground");
                     long asyncTaskStartTime = SystemClock.uptimeMillis();
                     boolean crashDumpDisabled = CommandLine.getInstance().hasSwitch(
                             ChromeSwitches.DISABLE_CRASH_DUMP_UPLOAD);
                     if (!crashDumpDisabled) {
                         RecordHistogram.recordLongTimesHistogram(
-                                "UMA.Debug.EnableCrashUpload.Uptime2",
-                                asyncTaskStartTime - UmaUtils.getMainEntryPointTime(),
+                                "UMA.Debug.EnableCrashUpload.Uptime3",
+                                asyncTaskStartTime - UmaUtils.getForegroundStartTime(),
                                 TimeUnit.MILLISECONDS);
                         PrivacyPreferencesManager.getInstance().enablePotentialCrashUploading();
                         MinidumpUploadService.tryUploadAllCrashDumps(mAppContext);
                     }
                     CrashFileManager crashFileManager =
                             new CrashFileManager(mAppContext.getCacheDir());
                     crashFileManager.cleanOutAllNonFreshMinidumpFiles();
 
                     MinidumpUploadService.storeBreakpadUploadStatsInUma(
                             ChromePreferenceManager.getInstance(mAppContext));
@@ skipping 18 matching lines @@
                             "UMA.Debug.EnableCrashUpload.DeferredStartUpDurationAsync",
                             SystemClock.uptimeMillis() - asyncTaskStartTime,
                             TimeUnit.MILLISECONDS);
 
                     return null;
                 } finally {
                     TraceEvent.end("ChromeBrowserInitializer.onDeferredStartup.doInBackground");
                 }
             }
         }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
-
-        AfterStartupTaskUtils.setStartupComplete();
-
-        PartnerBrowserCustomizations.setOnInitializeAsyncFinished(new Runnable() {
-            @Override
-            public void run() {
-                String homepageUrl = HomepageManager.getHomepageUri(mAppContext);
-                LaunchMetrics.recordHomePageLaunchMetrics(
-                        HomepageManager.isHomepageEnabled(mAppContext),
-                        NewTabPage.isNTPUrl(homepageUrl), homepageUrl);
-            }
-        });
-
-        // TODO(aruslan): http://b/6397072 This will be moved elsewhere
-        PartnerBookmarksShim.kickOffReading(mAppContext);
-
-        PowerMonitor.create(mAppContext);
-
-        ShareHelper.clearSharedImages(mAppContext);
-
-        // Clear any media notifications that existed when Chrome was last killed.
-        MediaCaptureNotificationService.clearMediaNotifications(mAppContext);
-
-        startModerateBindingManagementIfNeeded();
-
-        recordKeyboardLocaleUma();
-
-        ChromeApplication application = (ChromeApplication) mAppContext;
-        // Starts syncing with GSA.
-        application.createGsaHelper().startSync();
-
-        application.initializeSharedClasses();
-
-        // Start or stop Physical Web
-        PhysicalWeb.onChromeStart();
-
-        mDeferredStartupComplete = true;
-
-        RecordHistogram.recordLongTimesHistogram(
-                "UMA.Debug.EnableCrashUpload.DeferredStartUpDuration",
-                SystemClock.uptimeMillis() - startDeferredStartupTime,
-                TimeUnit.MILLISECONDS);
     }
 
     private void startModerateBindingManagementIfNeeded() {
         // Moderate binding doesn't apply to low end devices.
         if (SysUtils.isLowEndDevice()) return;
 
         boolean moderateBindingTillBackgrounded =
                 FieldTrialList.findFullName("ModerateBindingOnBackgroundTabCreation")
                         .equals("Enabled");
         ChildProcessLauncher.startModerateBindingManagement(
@@ skipping 56 matching lines @@
             boolean match = systemLocale.getLanguage().equalsIgnoreCase(keyboardLanguage);
             RecordHistogram.recordBooleanHistogram("InputMethod.MatchesSystemLanguage", match);
         }
     }
 
     /**
     * @return Whether deferred startup has been completed.
     */
     @VisibleForTesting
     public boolean isDeferredStartupComplete() {
-        return mDeferredStartupComplete;
+        return mDeferredStartupCompleted;
     }
 }