Add ChromeBrowserMainExtraParts for non main parts. (take 3)

chrome/browser/chrome_browser_main.cc

 // Copyright (c) 2011 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/browser/chrome_browser_main.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 14 matching lines @@
 #include "base/sys_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/about_flags.h"
 #include "chrome/browser/background/background_mode_manager.h"
 #include "chrome/browser/browser_process_impl.h"
 #include "chrome/browser/browser_shutdown.h"
+#include "chrome/browser/chrome_browser_main_extra_parts.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/extensions/default_apps_trial.h"
 #include "chrome/browser/extensions/extension_protocols.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extensions_startup.h"
 #include "chrome/browser/first_run/first_run_browser_process.h"
 #include "chrome/browser/first_run/upgrade_util.h"
 #include "chrome/browser/google/google_url_tracker.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/instant/instant_field_trial.h"
@@ skipping 506 matching lines @@
   } else {
     if (!parsed_command_line.HasSwitch(switches::kTestName)) {
       // We did not log in (we crashed or are debugging), so we need to
       // set the user name for sync.
       chromeos::LoginUtils::Get()->RestoreAuthenticationSession(
           chromeos::UserManager::Get()->logged_in_user().email(), profile);
     }
   }
 }
 
-#else
-
-void OptionallyRunChromeOSLoginManager(const CommandLine& parsed_command_line,
-                                       Profile* profile) {
-  // Dummy empty function for non-ChromeOS builds to avoid extra ifdefs below.
-}
-
 #endif  // defined(OS_CHROMEOS)
 
 #if defined(OS_MACOSX)
 OSStatus KeychainCallback(SecKeychainEvent keychain_event,
                           SecKeychainCallbackInfo *info, void *context) {
   return noErr;
 }
 #endif
 
 #if defined(OS_CHROMEOS) && defined(TOOLKIT_USES_GTK)
@@ skipping 100 matching lines @@
       translate_manager_(NULL),
       profile_(NULL),
       run_message_loop_(true),
       notify_result_(ProcessSingleton::PROCESS_NONE) {
   // If we're running tests (ui_task is non-null).
   if (parameters.ui_task)
     browser_defaults::enable_help_app = false;
 }
 
 ChromeBrowserMainParts::~ChromeBrowserMainParts() {
+  for (int i = static_cast<int>(chrome_extra_parts_.size())-1; i >= 0; --i)
+    delete chrome_extra_parts_[i];
+  chrome_extra_parts_.clear();
 }
 
 // This will be called after the command-line has been mutated by about:flags
 MetricsService* ChromeBrowserMainParts::SetupMetricsAndFieldTrials(
     PrefService* local_state) {
   // Must initialize metrics after labs have been converted into switches,
   // but before field trials are set up (so that client ID is available for
   // one-time randomized field trials).
   MetricsService* metrics = InitializeMetrics(
       parsed_command_line_, local_state);
@@ skipping 461 matching lines @@
 
 DLLEXPORT void __cdecl RelaunchChromeBrowserWithNewCommandLineIfNeeded() {
   // Need an instance of AtExitManager to handle singleton creations and
   // deletions.  We need this new instance because, the old instance created
   // in ChromeMain() got destructed when the function returned.
   base::AtExitManager exit_manager;
   upgrade_util::RelaunchChromeBrowserWithNewCommandLineIfNeeded();
 }
 #endif
 
+// content::BrowserMainParts implementation ------------------------------------
+
 void ChromeBrowserMainParts::PreEarlyInitialization() {
+  for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
+    chrome_extra_parts_[i]->PreEarlyInitialization();
 }
 
 void ChromeBrowserMainParts::PostEarlyInitialization() {
+  for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
+    chrome_extra_parts_[i]->PostEarlyInitialization();
 }
 
 void ChromeBrowserMainParts::ToolkitInitialized() {
+  for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
+    chrome_extra_parts_[i]->ToolkitInitialized();
 }
 
 void ChromeBrowserMainParts::PreMainMessageLoopStart() {
+  for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
+    chrome_extra_parts_[i]->PreMainMessageLoopStart();
 }
 
 void ChromeBrowserMainParts::PostMainMessageLoopStart() {
+  for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
+    chrome_extra_parts_[i]->PostMainMessageLoopStart();
 }
 
 void ChromeBrowserMainParts::PreMainMessageLoopRun() {
   result_code_ = PreMainMessageLoopRunImpl();
+
+  for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
+    chrome_extra_parts_[i]->PreMainMessageLoopRun();
 }
 
 int ChromeBrowserMainParts::PreMainMessageLoopRunImpl() {
   run_message_loop_ = false;
   FilePath user_data_dir;
 #if defined(OS_WIN)
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
 #else
   // Getting the user data dir can fail if the directory isn't
   // creatable, for example; on Windows in code below we bring up a
@@ skipping 293 matching lines @@
         NOTREACHED();
     }
 #if !defined(OS_MACOSX)  // closing brace for if
   }
 #endif
 
 #if defined(USE_X11)
   SetBrowserX11ErrorHandlers();
 #endif
 
+  // Desktop construction occurs here, (required before profile creation).
+  for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
+    chrome_extra_parts_[i]->PostBrowserProcessInit();
+
   // Profile creation ----------------------------------------------------------
 
 #if defined(OS_CHROMEOS)
   // Initialize the screen locker now so that it can receive
   // LOGIN_USER_CHANGED notification from UserManager.
   chromeos::ScreenLocker::InitClass();
 
   // This forces the ProfileManager to be created and register for the
   // notification it needs to track the logged in user.
   g_browser_process->profile_manager();
@@ skipping 45 matching lines @@
 
 #if defined(OS_CHROMEOS)
   // Pass the TokenService pointer to the policy connector so user policy can
   // grab a token and register with the policy server.
   // TODO(mnissler): Remove once OAuth is the only authentication mechanism.
   if (parsed_command_line().HasSwitch(switches::kLoginUser) &&
       !parsed_command_line().HasSwitch(switches::kLoginPassword)) {
     g_browser_process->browser_policy_connector()->SetUserPolicyTokenService(
         profile_->GetTokenService());
   }
+
+  // Tests should be able to tune login manager before showing it.
+  // Thus only show login manager in normal (non-testing) mode.
+  if (!parameters().ui_task)
+    OptionallyRunChromeOSLoginManager(parsed_command_line(), profile_);
 #endif
 
 #if !defined(OS_MACOSX)
   // Importing other browser settings is done in a browser-like process
   // that exits when this task has finished.
   // TODO(port): Port the Mac's IPC-based implementation to other platforms to
   //             replace this implementation. http://crbug.com/22142
   if (parsed_command_line().HasSwitch(switches::kImport) ||
       parsed_command_line().HasSwitch(switches::kImportFromFile)) {
     return FirstRun::ImportNow(profile_, parsed_command_line());
@@ skipping 28 matching lines @@
     // Disk image installation is sort of a first-run task, so it shares the
     // kNoFirstRun switch.
     if (MaybeInstallFromDiskImage()) {
       // The application was installed and the installed copy has been
       // launched.  This process is now obsolete.  Exit.
       return content::RESULT_CODE_NORMAL_EXIT;
     }
   }
 #endif
 
+  // TODO(stevenjb): Move ChromeOS login code into PostProfileInitialized().
+  // (Requires making ChromeBrowserMainPartsChromeos a non "main" Parts).
+  for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
+    chrome_extra_parts_[i]->PostProfileInitialized();
+
   // Show the First Run UI if this is the first time Chrome has been run on
   // this computer, or we're being compelled to do so by a command line flag.
   // Note that this be done _after_ the PrefService is initialized and all
   // preferences are registered, since some of the code that the importer
   // touches reads preferences.
   if (is_first_run) {
     if (!first_run_ui_bypass) {
       FirstRun::AutoImport(profile_,
                            master_prefs_->homepage_defined,
                            master_prefs_->do_import_items,
@@ skipping 205 matching lines @@
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&GpuBlacklistUpdater::SetupOnFileThread));
 
   // Start watching all browser threads for responsiveness.
   ThreadWatcherList::StartWatchingAll(parsed_command_line());
 
 #if !defined(DISABLE_NACL)
   NaClProcessHost::EarlyStartup();
 #endif
 
-  run_message_loop_ = true;
-  return content::RESULT_CODE_NORMAL_EXIT;
-}
-
-// Called from MainMessageLoopRun().
-void ChromeBrowserMainParts::StartBrowserOrUITask() {
-  // Still initializing, so need to allow IO.
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
-
-  // Tests should be able to tune login manager before showing it.
-  // Thus only show login manager in normal (non-testing) mode.
-  if (!parameters().ui_task)
-    OptionallyRunChromeOSLoginManager(parsed_command_line(), profile_);
-
   if (parameters().ui_task) {
     // We are in test mode. Run one task and enter the main message loop.
 #if defined(OS_MACOSX)
     if (parameters().autorelease_pool)
       parameters().autorelease_pool->Recycle();
 #endif
     parameters().ui_task->Run();
     delete parameters().ui_task;
     run_message_loop_ = false;
   } else {
@@ skipping 49 matching lines @@
             profile_->GetPrefs());
       }
 #endif
 
       run_message_loop_ = true;
     } else {
       run_message_loop_ = false;
     }
   }
   browser_init_.reset();
+  return result_code_;
 }
 
 bool ChromeBrowserMainParts::MainMessageLoopRun(int* result_code) {
   // Set the result code set in PreMainMessageLoopRun or set above.
   *result_code = result_code_;
 
-  // TODO(stevenjb): Move this to another phase, and/or clean up
-  // PreMainMessageLoopRun() so that this can happen after desktop
-  // initilaization and before running the main loop.
-  if (run_message_loop_)
-    StartBrowserOrUITask();
-
   if (!run_message_loop_)
     return true;  // Don't run the default message loop.
 
   // This should be invoked as close to the start of the browser's
   // UI thread message loop as possible to get a stable measurement
   // across versions.
   RecordBrowserStartupTime();
 
 #if defined(USE_AURA)
   aura::Desktop::GetInstance()->Run();
@@ skipping 101 matching lines @@
   browser_shutdown::Shutdown();
   master_prefs_.reset();
   process_singleton_.reset();
 
   // We need to do this check as late as possible, but due to modularity, this
   // may be the last point in Chrome.  This would be more effective if done at
   // a higher level on the stack, so that it is impossible for an early return
   // to bypass this code.  Perhaps we need a *final* hook that is called on all
   // paths from content/browser/browser_main.
   CHECK(MetricsService::UmaMetricsProperlyShutdown());
+
+  for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
+    chrome_extra_parts_[i]->PostMainMessageLoopRun();
 }
 
+// Public members:
+
+void ChromeBrowserMainParts::AddParts(ChromeBrowserMainExtraParts* parts) {
+  chrome_extra_parts_.push_back(parts);
+}
+
+// Misc ------------------------------------------------------------------------
+
 // This code is specific to the Windows-only PreReadExperiment field-trial.
 void RecordPreReadExperimentTime(const char* name, base::TimeDelta time) {
   DCHECK(name != NULL);
 
   // This gets called with different histogram names, so we don't want to use
   // the UMA_HISTOGRAM_CUSTOM_TIMES macro--it uses a static variable, and the
   // first call wins.
   AddPreReadHistogramTime(name, time);
 
 #if defined(OS_WIN)
 #if defined(GOOGLE_CHROME_BUILD)
   // The pre-read experiment is Windows and Google Chrome specific.
   scoped_ptr<base::Environment> env(base::Environment::Create());
 
   // Only record the sub-histogram result if the experiment is running
   // (environment variable is set, and valid).
   std::string pre_read;
   if (env->GetVar(chrome::kPreReadEnvironmentVariable, &pre_read) &&
       (pre_read == "0" || pre_read == "1")) {
     std::string uma_name(name);
     uma_name += "_PreRead";
     uma_name += pre_read == "1" ? "Enabled" : "Disabled";
     AddPreReadHistogramTime(uma_name.c_str(), time);
   }
 #endif
 #endif
 }