Run the later parts of startup as UI thread tasks

chrome/app/android/chrome_main_delegate_android.cc

 // Copyright (c) 2012 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.
 
 #include "chrome/app/android/chrome_main_delegate_android.h"
 
 #include "base/android/jni_android.h"
 #include "base/debug/trace_event.h"
+#include "base/memory/scoped_ptr.h"
 #include "chrome/browser/android/chrome_jni_registrar.h"
 #include "chrome/browser/android/chrome_startup_flags.h"
 #include "content/public/browser/browser_main_runner.h"
 
 // ChromeMainDelegateAndroid is created when the library is loaded. It is always
 // done in the process's main Java thread. But for non browser process, e.g.
 // renderer process, it is not the native Chrome's main thread.
-ChromeMainDelegateAndroid::ChromeMainDelegateAndroid() {
-}
+ChromeMainDelegateAndroid::ChromeMainDelegateAndroid()
+    : incremental_startup_enabled_(false) {}
 
 ChromeMainDelegateAndroid::~ChromeMainDelegateAndroid() {
 }
 
 void ChromeMainDelegateAndroid::SandboxInitialized(
     const std::string& process_type) {
   ChromeMainDelegate::SandboxInitialized(process_type);
 }
 
 int ChromeMainDelegateAndroid::RunProcess(
     const std::string& process_type,
     const content::MainFunctionParams& main_function_params) {
   TRACE_EVENT0("startup", "ChromeMainDelegateAndroid::RunProcess")
   if (process_type.empty()) {
     JNIEnv* env = base::android::AttachCurrentThread();
     RegisterApplicationNativeMethods(env);
 
     browser_runner_.reset(content::BrowserMainRunner::Create());
-    return browser_runner_->Initialize(main_function_params);
+
+    // For Chrome on android we want to run the startup tasks incrementally, so

[Yaron, 2013/07/23 02:14:03]

Any reason not to do this on testshell as well and avoid the unnecessary
conditional? Or put another way: why configure this from internal repo? If you
want to make this conditional, it could just be a flag.

[aberent, 2013/07/23 13:45:03]

This has to be conditional, since there are a number of secondary broadcast
receivers and activities provided by Chrome on Android (and implemented in the
internal repo) that assume that the browser starts synchronously. These include
the AccountsChangeReceiver and the various bookmark receivers and activities. As
such the decision on whether startup is allowed to be asynchronous has to be in
the internal repo.

I have not investigated whether we could change these to support asynchronous
startup, but, at the very least, this would involve considerable extra work.

I considered making this a command line flag, but the observer had to be passed
down anyway, so it seemed to make sense to pass down the control of this by the
same route.

+    // that UI tasks can get in in-between.
+    content::StartupTaskRunner::StartupMode mode =
+        incremental_startup_enabled_ ? content::StartupTaskRunner::INCREMENTAL
+                                     : content::StartupTaskRunner::IMMEDIATE;
+    scoped_refptr<content::StartupTaskRunner> startup_task_runner(
+        new content::StartupTaskRunner(mode, GetStartupObserver()));
+
+    return browser_runner_->Initialize(main_function_params,
+                                       startup_task_runner);
   }
 
   return ChromeMainDelegate::RunProcess(process_type, main_function_params);
 }
 
 bool ChromeMainDelegateAndroid::BasicStartupComplete(int* exit_code) {
   SetChromeSpecificCommandLineFlags();
   return ChromeMainDelegate::BasicStartupComplete(exit_code);
 }
 
 bool ChromeMainDelegateAndroid::RegisterApplicationNativeMethods(JNIEnv* env) {
   return chrome::android::RegisterJni(env);
 }
+
+void ChromeMainDelegateAndroid::EnableIncrementalStartup(bool enable) {
+  incremental_startup_enabled_ = enable;
+}