Refactor some more BrowserMain code. Move core code that's required by all embedders to content.

chrome/browser/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/browser_main.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/threading/platform_thread.h"
-#include "base/threading/thread_restrictions.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/browser_main_win.h"
-#include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_impl.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/defaults.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.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/instant/instant_field_trial.h"
 #include "chrome/browser/jankometer.h"
 #include "chrome/browser/language_usage_metrics.h"
 #include "chrome/browser/metrics/field_trial_synchronizer.h"
 #include "chrome/browser/metrics/histogram_synchronizer.h"
 #include "chrome/browser/metrics/metrics_log.h"
 #include "chrome/browser/metrics/metrics_service.h"
@@ skipping 96 matching lines @@
 #endif
 
 // TODO(port): several win-only methods have been pulled out of this, but
 // BrowserMain() as a whole needs to be broken apart so that it's usable by
 // other platforms. For now, it's just a stub. This is a serious work in
 // progress and should not be taken as an indication of a real refactoring.
 
 #if defined(OS_WIN)
 
 #include "base/environment.h"  // For PreRead experiment.
-#include "base/win/scoped_com_initializer.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/browser_trial.h"
 #include "chrome/browser/browser_util_win.h"
 #include "chrome/browser/first_run/try_chrome_dialog_view.h"
 #include "chrome/browser/first_run/upgrade_util_win.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/rlz/rlz.h"
 #include "chrome/browser/ui/views/user_data_dir_dialog.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/install_util.h"
@@ skipping 52 matching lines @@
 
 #if defined(OS_CHROMEOS)
   // Test loading libcros and exit. We return 0 if the library could be loaded,
   // and 1 if it can't be. This is for validation that the library is installed
   // and versioned properly for Chrome to find.
   if (command_line.HasSwitch(switches::kTestLoadLibcros))
     exit(!chromeos::CrosLibrary::Get()->EnsureLoaded());
 #endif
 }
 
-void RunUIMessageLoop(BrowserProcess* browser_process) {
-  TRACE_EVENT_BEGIN_ETW("BrowserMain:MESSAGE_LOOP", 0, "");
-  // 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 the UI thread blocks, the whole UI is unresponsive.
-  // Do not allow disk IO from the UI thread.
-  base::ThreadRestrictions::SetIOAllowed(false);
-
-#if defined(TOOLKIT_VIEWS)
-  views::AcceleratorHandler accelerator_handler;
-  MessageLoopForUI::current()->Run(&accelerator_handler);
-#elif defined(USE_X11)
-  MessageLoopForUI::current()->Run(NULL);
-#elif defined(OS_POSIX)
-  MessageLoopForUI::current()->Run();
-#endif
-#if defined(OS_CHROMEOS)
-  chromeos::BootTimesLoader::Get()->AddLogoutTimeMarker("UIMessageLoopEnded",
-                                                        true);
-#endif
-
-  TRACE_EVENT_END_ETW("BrowserMain:MESSAGE_LOOP", 0, "");
-}
-
 void AddFirstRunNewTabs(BrowserInit* browser_init,
                         const std::vector<GURL>& new_tabs) {
   for (std::vector<GURL>::const_iterator it = new_tabs.begin();
        it != new_tabs.end(); ++it) {
     if (it->is_valid())
       browser_init->AddFirstRunTab(*it);
   }
 }
 
 #if defined(USE_LINUX_BREAKPAD)
@@ skipping 423 matching lines @@
 const char kMissingLocaleDataTitle[] = "Missing File Error";
 const char kMissingLocaleDataMessage[] =
     "Unable to find locale data files. Please reinstall.";
 }  // namespace chrome_browser
 
 // BrowserMainParts ------------------------------------------------------------
 
 ChromeBrowserMainParts::ChromeBrowserMainParts(
     const MainFunctionParams& parameters)
     : BrowserMainParts(parameters),
-      shutdown_watcher_(new ShutdownWatcherHelper()) {
+      shutdown_watcher_(new ShutdownWatcherHelper()),
+      record_search_engine_(false),
+      translate_manager_(NULL),
+      metrics_(NULL),
+      profile_(NULL),
+      run_message_loop_(true) {
   // If we're running tests (ui_task is non-null).
   if (parameters.ui_task)
     browser_defaults::enable_help_app = false;  
 }
 
 ChromeBrowserMainParts::~ChromeBrowserMainParts() {
 }
 
-void ChromeBrowserMainParts::SetupHistogramSynchronizer() {
-  histogram_synchronizer_ = new HistogramSynchronizer();
-}
-
 // This will be called after the command-line has been mutated by about:flags
 MetricsService* ChromeBrowserMainParts::SetupMetricsAndFieldTrials(
     const CommandLine& parsed_command_line,
     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);
 
   // Initialize FieldTrialList to support FieldTrials that use one-time
@@ skipping 377 matching lines @@
   // in ChromeMain() got destructed when the function returned.
   base::AtExitManager exit_manager;
   upgrade_util::RelaunchChromeBrowserWithNewCommandLineIfNeeded();
 }
 #endif
 
 void ChromeBrowserMainParts::PostMainMessageLoopStart() {
   Profiling::MainMessageLoopStarted();
 }
 
-void ChromeBrowserMainParts::ToolkitInitialized() {
-#if defined(TOOLKIT_VIEWS)
-  // The delegate needs to be set before any UI is created so that windows
-  // display the correct icon.
-  if (!views::ViewsDelegate::views_delegate)
-    views::ViewsDelegate::views_delegate = new ChromeViewsDelegate;
-
-  // TODO(beng): Move to WidgetImpl and implement on Windows too!
-  if (parameters().command_line_.HasSwitch(switches::kDebugViewsPaint))
-    views::Widget::SetDebugPaintEnabled(true);
-#endif
-
-#if defined(OS_WIN)
-  gfx::PlatformFontWin::adjust_font_callback = &AdjustUIFont;
-  gfx::PlatformFontWin::get_minimum_font_size_callback = &GetMinimumFontSize;
-#endif
-}
-
-int ChromeBrowserMainParts::TemporaryContinue() {
+void ChromeBrowserMainParts::PreMainMessageLoopRun() {
+  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
   // dialog prompting the user to pick a different directory.
   // However, ProcessSingleton needs a real user_data_dir on Mac/Linux,
   // so it's better to fail here than fail mysteriously elsewhere.
   CHECK(PathService::Get(chrome::DIR_USER_DATA, &user_data_dir))
       << "Must be able to get user data directory!";
 #endif
 
-  ProcessSingleton process_singleton(user_data_dir);
+  process_singleton_.reset(new ProcessSingleton(user_data_dir));
 
   bool is_first_run = FirstRun::IsChromeFirstRun() ||
       parsed_command_line().HasSwitch(switches::kFirstRun);
 
-  scoped_ptr<BrowserProcessImpl> browser_process;
   if (parsed_command_line().HasSwitch(switches::kImport) ||
       parsed_command_line().HasSwitch(switches::kImportFromFile)) {
     // We use different BrowserProcess when importing so no GoogleURLTracker is
     // instantiated (as it makes a net::URLRequest and we don't have an IO
     // thread, see bug #1292702).
-    browser_process.reset(new FirstRunBrowserProcess(parsed_command_line()));
+    browser_process_.reset(new FirstRunBrowserProcess(parsed_command_line()));
     is_first_run = false;
   } else {
-    browser_process.reset(new BrowserProcessImpl(parsed_command_line()));
+    browser_process_.reset(new BrowserProcessImpl(parsed_command_line()));
   }
 
   // This forces the TabCloseableStateWatcher to be created and, on chromeos,
   // register for the notifications it needs to track the closeable state of
   // tabs.
   g_browser_process->tab_closeable_state_watcher();
 
   PrefService* local_state = InitializeLocalState(parsed_command_line(),
                                                   is_first_run);
 
@@ skipping 20 matching lines @@
 #else
     const std::string locale =
         local_state->GetString(prefs::kApplicationLocale);
     // On a POSIX OS other than ChromeOS, the parameter that is passed to the
     // method InitSharedInstance is ignored.
     const std::string loaded_locale =
         ResourceBundle::InitSharedInstance(locale);
     if (loaded_locale.empty() &&
         !parsed_command_line().HasSwitch(switches::kNoErrorDialogs)) {
       ShowMissingLocaleMessageBox();
-      return chrome::RESULT_CODE_MISSING_DATA;
+      set_result_code(chrome::RESULT_CODE_MISSING_DATA);
+      return;
     }
     CHECK(!loaded_locale.empty()) << "Locale could not be found for " << locale;
     g_browser_process->SetApplicationLocale(loaded_locale);
 
     FilePath resources_pack_path;
     PathService::Get(chrome::FILE_RESOURCES_PACK, &resources_pack_path);
     ResourceBundle::AddDataPackToSharedInstance(resources_pack_path);
 #endif  // defined(OS_MACOSX)
   }
 
 #if defined(TOOLKIT_GTK)
   g_set_application_name(l10n_util::GetStringUTF8(IDS_PRODUCT_NAME).c_str());
 #endif
 
   std::string try_chrome =
       parsed_command_line().GetSwitchValueASCII(switches::kTryChromeAgain);
   if (!try_chrome.empty()) {
 #if defined(OS_WIN) && !defined(USE_AURA)
     // Setup.exe has determined that we need to run a retention experiment
     // and has lauched chrome to show the experiment UI.
-    if (process_singleton.FoundOtherProcessWindow()) {
+    if (process_singleton_->FoundOtherProcessWindow()) {
       // It seems that we don't need to run the experiment since chrome
       // in the same profile is already running.
       VLOG(1) << "Retention experiment not required";
-      return TryChromeDialogView::NOT_NOW;
+      set_result_code(TryChromeDialogView::NOT_NOW);
+      return;
     }
     int try_chrome_int;
     base::StringToInt(try_chrome, &try_chrome_int);
     TryChromeDialogView::Result answer =
-        TryChromeDialogView::Show(try_chrome_int, &process_singleton);
+        TryChromeDialogView::Show(try_chrome_int, process_singleton_.get());
     if (answer == TryChromeDialogView::NOT_NOW)
-      return chrome::RESULT_CODE_NORMAL_EXIT_CANCEL;
-    if (answer == TryChromeDialogView::UNINSTALL_CHROME)
-      return chrome::RESULT_CODE_NORMAL_EXIT_EXP2;
+      set_result_code(chrome::RESULT_CODE_NORMAL_EXIT_CANCEL);
+    else if (answer == TryChromeDialogView::UNINSTALL_CHROME)
+      set_result_code(chrome::RESULT_CODE_NORMAL_EXIT_EXP2);
 #else
     // We don't support retention experiments on Mac or Linux.
-    return content::RESULT_CODE_NORMAL_EXIT;
+    set_result_code(content::RESULT_CODE_NORMAL_EXIT);
 #endif  // defined(OS_WIN)
+    return;
   }
 
 #if defined(OS_CHROMEOS)
   // This needs to be called after the locale has been set.
   RegisterTranslateableItems();
 #endif
 
 #if defined(TOOLKIT_VIEWS)
   views::Widget::SetPureViews(
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kUsePureViews));
@@ skipping 15 matching lines @@
     chrome_views_delegate->default_parent_view =
         views::desktop::DesktopWindowView::desktop_window_view;
   }
 #endif
 
   BrowserInit browser_init;
 
   // On first run, we need to process the predictor preferences before the
   // browser's profile_manager object is created, but after ResourceBundle
   // is initialized.
-  FirstRun::MasterPrefs master_prefs;
+  master_prefs_.reset(new FirstRun::MasterPrefs);
   bool first_run_ui_bypass = false;  // True to skip first run UI.
   if (is_first_run) {
     first_run_ui_bypass =
-        !FirstRun::ProcessMasterPreferences(user_data_dir, &master_prefs);
-    AddFirstRunNewTabs(&browser_init, master_prefs.new_tabs);
+        !FirstRun::ProcessMasterPreferences(user_data_dir, master_prefs_.get());
+    AddFirstRunNewTabs(&browser_init, master_prefs_->new_tabs);
 
     // If we are running in App mode, we do not want to show the importer
     // (first run) UI.
     if (!first_run_ui_bypass &&
         (parsed_command_line().HasSwitch(switches::kApp) ||
          parsed_command_line().HasSwitch(switches::kAppId) ||
          parsed_command_line().HasSwitch(switches::kNoFirstRun)))
       first_run_ui_bypass = true;
   }
 
@@ skipping 10 matching lines @@
     local_state->SetBoolean(prefs::kPrintingPrintPreviewEnabledOnce, true);
     about_flags::SetExperimentEnabled(local_state, "print-preview", true);
   }
 #endif
 
   // Convert active labs into switches. Modifies the current command line.
   about_flags::ConvertFlagsToSwitches(local_state,
                                       CommandLine::ForCurrentProcess());
 
   InitializeNetworkOptions(parsed_command_line());
-  InitializeURLRequestThrottlerManager(browser_process->net_log());
+  InitializeURLRequestThrottlerManager(browser_process_->net_log());
 
   // Initialize histogram synchronizer system. This is a singleton and is used
   // for posting tasks via NewRunnableMethod. Its deleted when it goes out of
   // scope. Even though NewRunnableMethod does AddRef and Release, the object
   // will not be deleted after the Task is executed.
-  SetupHistogramSynchronizer();
+  histogram_synchronizer_ = new HistogramSynchronizer();
 
   // Now the command line has been mutated based on about:flags, we can
   // set up metrics and initialize field trials.
-  MetricsService* metrics = SetupMetricsAndFieldTrials(
-      parsed_command_line(), local_state);
+  metrics_ = SetupMetricsAndFieldTrials(parsed_command_line(), local_state);
 
   // Now that all preferences have been registered, set the install date
   // for the uninstall metrics if this is our first run. This only actually
   // gets used if the user has metrics reporting enabled at uninstall time.
   int64 install_date =
       local_state->GetInt64(prefs::kUninstallMetricsInstallDate);
   if (install_date == 0) {
     local_state->SetInt64(prefs::kUninstallMetricsInstallDate,
                           base::Time::Now().ToTimeT());
   }
 
 #if defined(OS_MACOSX)
   // Get the Keychain API to register for distributed notifications on the main
   // thread, which has a proper CFRunloop, instead of later on the I/O thread,
   // which doesn't. This ensures those notifications will get delivered
   // properly. See issue 37766.
   // (Note that the callback mask here is empty. I don't want to register for
   // any callbacks, I just want to initialize the mechanism.)
   SecKeychainAddCallback(&KeychainCallback, 0, NULL);
 #endif
 
-  CreateChildThreads(browser_process.get());
+  CreateChildThreads(browser_process_.get());
 
 #if defined(OS_CHROMEOS)
   // Now that the file thread exists we can record our stats.
   chromeos::BootTimesLoader::Get()->RecordChromeMainStats();
 
   // Read locale-specific GTK resource information.
   std::string gtkrc = l10n_util::GetStringUTF8(IDS_LOCALE_GTKRC);
   if (!gtkrc.empty())
     gtk_rc_parse_string(gtkrc.c_str());
 
   // Trigger prefetching of ownership status.
   chromeos::OwnershipService::GetSharedInstance()->Prewarm();
 #endif
 
   // Record last shutdown time into a histogram.
   browser_shutdown::ReadLastShutdownInfo();
 
 #if defined(OS_WIN)
   // On Windows, we use our startup as an opportunity to do upgrade/uninstall
   // tasks.  Those care whether the browser is already running.  On Linux/Mac,
   // upgrade/uninstall happen separately.
   bool already_running = browser_util::IsBrowserAlreadyRunning();
 
   // If the command line specifies 'uninstall' then we need to work here
   // unless we detect another chrome browser running.
-  if (parsed_command_line().HasSwitch(switches::kUninstall))
-    return DoUninstallTasks(already_running);
+  if (parsed_command_line().HasSwitch(switches::kUninstall)) {
+    set_result_code(DoUninstallTasks(already_running));
+    return;
+  }
 #endif
 
   if (parsed_command_line().HasSwitch(switches::kHideIcons) ||
-      parsed_command_line().HasSwitch(switches::kShowIcons))
-    return HandleIconsCommands(parsed_command_line());
+      parsed_command_line().HasSwitch(switches::kShowIcons)) {
+    set_result_code(HandleIconsCommands(parsed_command_line()));
+    return;
+  }
   if (parsed_command_line().HasSwitch(switches::kMakeDefaultBrowser)) {
-    return ShellIntegration::SetAsDefaultBrowser() ?
+    set_result_code(ShellIntegration::SetAsDefaultBrowser() ?
         static_cast<int>(content::RESULT_CODE_NORMAL_EXIT) :
-        static_cast<int>(chrome::RESULT_CODE_SHELL_INTEGRATION_FAILED);
+        static_cast<int>(chrome::RESULT_CODE_SHELL_INTEGRATION_FAILED));
+    return;
   }
 
   // If the command line specifies --pack-extension, attempt the pack extension
   // startup action and exit.
   if (parsed_command_line().HasSwitch(switches::kPackExtension)) {
     ExtensionsStartupUtil extension_startup_util;
     if (extension_startup_util.PackExtension(parsed_command_line())) {
-      return content::RESULT_CODE_NORMAL_EXIT;
+      set_result_code(content::RESULT_CODE_NORMAL_EXIT);
     } else {
-      return chrome::RESULT_CODE_PACK_EXTENSION_ERROR;
+      set_result_code(chrome::RESULT_CODE_PACK_EXTENSION_ERROR);
     }
+    return;
   }
 
 #if !defined(OS_MACOSX)
   // In environments other than Mac OS X we support import of settings
   // from other browsers. In case this process is a short-lived "import"
   // process that another browser runs just to import the settings, we
   // don't want to be checking for another browser process, by design.
   if (!(parsed_command_line().HasSwitch(switches::kImport) ||
         parsed_command_line().HasSwitch(switches::kImportFromFile))) {
 #endif
     // When another process is running, use that process instead of starting a
     // new one. NotifyOtherProcess will currently give the other process up to
     // 20 seconds to respond. Note that this needs to be done before we attempt
     // to read the profile.
-    switch (process_singleton.NotifyOtherProcessOrCreate()) {
+    switch (process_singleton_->NotifyOtherProcessOrCreate()) {
       case ProcessSingleton::PROCESS_NONE:
         // No process already running, fall through to starting a new one.
         break;
 
       case ProcessSingleton::PROCESS_NOTIFIED:
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
         printf("%s\n", base::SysWideToNativeMB(UTF16ToWide(
             l10n_util::GetStringUTF16(IDS_USED_EXISTING_BROWSER))).c_str());
 #endif
-        return content::RESULT_CODE_NORMAL_EXIT;
+        set_result_code(content::RESULT_CODE_NORMAL_EXIT);
+        return;
 
       case ProcessSingleton::PROFILE_IN_USE:
-        return chrome::RESULT_CODE_PROFILE_IN_USE;
+        set_result_code(chrome::RESULT_CODE_PROFILE_IN_USE);
+        return;
 
       case ProcessSingleton::LOCK_ERROR:
         LOG(ERROR) << "Failed to create a ProcessSingleton for your profile "
                       "directory. This means that running multiple instances "
                       "would start multiple browser processes rather than "
                       "opening a new window in the existing process. Aborting "
                       "now to avoid profile corruption.";
-        return chrome::RESULT_CODE_PROFILE_IN_USE;
+        set_result_code(chrome::RESULT_CODE_PROFILE_IN_USE);
+        return;
 
       default:
         NOTREACHED();
     }
 #if !defined(OS_MACOSX)  // closing brace for if
   }
 #endif
 
 #if defined(USE_X11)
   SetBrowserX11ErrorHandlers();
@@ skipping 36 matching lines @@
         username);
   }
 #endif
 
   if (is_first_run) {
     // Warn the ProfileManager that an import process will run, possibly
     // locking the WebDataService directory of the next Profile created.
     g_browser_process->profile_manager()->SetWillImport();
   }
 
-  Profile* profile = CreateProfile(parameters(), user_data_dir,
-                                   parsed_command_line());
-  if (!profile)
-    return content::RESULT_CODE_NORMAL_EXIT;
+  profile_ = CreateProfile(parameters(), user_data_dir, parsed_command_line());
+  if (!profile_) {
+    set_result_code(content::RESULT_CODE_NORMAL_EXIT);
+    return;
+  }
 
   // Post-profile init ---------------------------------------------------------
 
 #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());
+        profile_->GetTokenService());
   }
 #endif
 
-  PrefService* user_prefs = profile->GetPrefs();
+  PrefService* user_prefs = profile_->GetPrefs();
   DCHECK(user_prefs);
 
   // 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);
+    OptionallyRunChromeOSLoginManager(parsed_command_line(), profile_);
   }
 
 #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());
+    set_result_code(FirstRun::ImportNow(profile_, parsed_command_line()));
+    return;
   }
 #endif
 
 #if defined(OS_WIN)
   // Do the tasks if chrome has been upgraded while it was last running.
-  if (!already_running && upgrade_util::DoUpgradeTasks(parsed_command_line()))
-    return content::RESULT_CODE_NORMAL_EXIT;
+  if (!already_running && upgrade_util::DoUpgradeTasks(parsed_command_line())) {
+    set_result_code(content::RESULT_CODE_NORMAL_EXIT);
+    return;
+  }
 #endif
 
   // Check if there is any machine level Chrome installed on the current
   // machine. If yes and the current Chrome process is user level, we do not
   // allow the user level Chrome to run. So we notify the user and uninstall
   // user level Chrome.
   // Note this check should only happen here, after all the checks above
   // (uninstall, resource bundle initialization, other chrome browser
   // processes etc).
   // Do not allow this to occur for Chrome Frame user-to-system handoffs.
   if (!parsed_command_line().HasSwitch(switches::kChromeFrame) &&
-      CheckMachineLevelInstall())
-    return chrome::RESULT_CODE_MACHINE_LEVEL_INSTALL_EXISTS;
+      CheckMachineLevelInstall()) {
+    set_result_code(chrome::RESULT_CODE_MACHINE_LEVEL_INSTALL_EXISTS);
+    return;
+  }
 
   // Create the TranslateManager singleton.
-  TranslateManager* translate_manager = TranslateManager::GetInstance();
-  DCHECK(translate_manager != NULL);
+  translate_manager_ = TranslateManager::GetInstance();
+  DCHECK(translate_manager_ != NULL);
 
 #if defined(OS_MACOSX)
   if (!parsed_command_line().HasSwitch(switches::kNoFirstRun)) {
     // 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;
+      set_result_code(content::RESULT_CODE_NORMAL_EXIT);
+      return;
     }
   }
 #endif
 
   // 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,
-                           master_prefs.dont_import_items,
-                           master_prefs.run_search_engine_experiment,
-                           master_prefs.randomize_search_engine_experiment,
-                           master_prefs.make_chrome_default,
-                           &process_singleton);
+      FirstRun::AutoImport(profile_,
+                           master_prefs_->homepage_defined,
+                           master_prefs_->do_import_items,
+                           master_prefs_->dont_import_items,
+                           master_prefs_->run_search_engine_experiment,
+                           master_prefs_->randomize_search_engine_experiment,
+                           master_prefs_->make_chrome_default,
+                           process_singleton_.get());
 #if defined(OS_POSIX)
       // On Windows, the download is tagged with enable/disable stats so there
       // is no need for this code.
 
       // If stats reporting was turned on by the first run dialog then toggle
       // the pref.
       if (GoogleUpdateSettings::GetCollectStatsConsent())
         local_state->SetBoolean(prefs::kMetricsReportingEnabled, true);
 #endif  // OS_POSIX
     }  // if (!first_run_ui_bypass)
 
     Browser::SetNewHomePagePrefs(user_prefs);
-    g_browser_process->profile_manager()->OnImportFinished(profile);
+    g_browser_process->profile_manager()->OnImportFinished(profile_);
   }  // if (is_first_run)
 
   // Sets things up so that if we crash from this point on, a dialog will
   // popup asking the user to restart chrome. It is done this late to avoid
   // testing against a bunch of special cases that are taken care early on.
   PrepareRestartOnCrashEnviroment(parsed_command_line());
 
 #if defined(OS_WIN)
   // Registers Chrome with the Windows Restart Manager, which will restore the
   // Chrome session when the computer is restarted after a system update.
@@ skipping 11 matching lines @@
   bool preconnect_enabled = true;  // Default status (easy to change!).
   if (parsed_command_line().HasSwitch(switches::kDisablePreconnect))
     preconnect_enabled = false;
   else if (parsed_command_line().HasSwitch(switches::kEnablePreconnect))
     preconnect_enabled = true;
   chrome_browser_net::PredictorInit dns_prefetch(
       user_prefs,
       local_state,
       preconnect_enabled);
 
-#if defined(OS_WIN)
-  base::win::ScopedCOMInitializer com_initializer;
-
-#if defined(GOOGLE_CHROME_BUILD)
+#if defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
   // Init the RLZ library. This just binds the dll and schedules a task on the
   // file thread to be run sometime later. If this is the first run we record
   // the installation event.
   bool google_search_default = false;
   TemplateURLService* template_url_service =
-      TemplateURLServiceFactory::GetForProfile(profile);
+      TemplateURLServiceFactory::GetForProfile(profile_);
   if (template_url_service) {
     const TemplateURL* url_template =
         template_url_service->GetDefaultSearchProvider();
     if (url_template) {
       const TemplateURLRef* urlref = url_template->url();
       if (urlref) {
         google_search_default = urlref->HasGoogleBaseURLs();
       }
     }
   }
 
   bool google_search_homepage = false;
-  PrefService* pref_service = profile->GetPrefs();
+  PrefService* pref_service = profile_->GetPrefs();
   if (pref_service) {
     std::string homepage = pref_service->GetString(prefs::kHomePage);
     google_search_homepage =
         homepage == GoogleURLTracker::kDefaultGoogleHomepage;
   }
 
-  RLZTracker::InitRlzDelayed(is_first_run, master_prefs.ping_delay,
+  RLZTracker::InitRlzDelayed(is_first_run, master_prefs_->ping_delay,
                              google_search_default, google_search_homepage);
 
   // Prime the RLZ cache for the home page access point so that its avaiable
   // for the startup page if needed (i.e., when the startup page is set to
   // the home page).
   RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_HOME_PAGE, NULL);
-
-#endif  // GOOGLE_CHROME_BUILD
-#endif  // OS_WIN
+#endif  // GOOGLE_CHROME_BUILD && OS_WIN
 
   // Configure modules that need access to resources.
   net::NetModule::SetResourceProvider(chrome_common_net::NetResourceProvider);
 
   // In unittest mode, this will do nothing.  In normal mode, this will create
   // the global GoogleURLTracker and IntranetRedirectDetector instances, which
   // will promptly go to sleep for five and seven seconds, respectively (to
   // avoid slowing startup), and wake up afterwards to see if they should do
   // anything else.
   //
   // A simpler way of doing all this would be to have some function which could
   // give the time elapsed since startup, and simply have these objects check
   // that when asked to initialize themselves, but this doesn't seem to exist.
   //
   // These can't be created in the BrowserProcessImpl constructor because they
   // need to read prefs that get set after that runs.
-  browser_process->google_url_tracker();
-  browser_process->intranet_redirect_detector();
+  browser_process_->google_url_tracker();
+  browser_process_->intranet_redirect_detector();
 
   // Prepare for memory caching of SDCH dictionaries.
   // Perform A/B test to measure global impact of SDCH support.
   // Set up a field trial to see what disabling SDCH does to latency of page
   // layout globally.
   base::FieldTrial::Probability kSDCH_DIVISOR = 1000;
   base::FieldTrial::Probability kSDCH_DISABLE_PROBABILITY = 1;  // 0.1% prob.
   // After June 30, 2011 builds, it will always be in default group.
   scoped_refptr<base::FieldTrial> sdch_trial(
       new base::FieldTrial("GlobalSdch", kSDCH_DIVISOR, "global_enable_sdch",
@@ skipping 25 matching lines @@
     printing::PrintedDocument::set_debug_dump_path(path);
   }
 #endif
 
 #if defined(TOUCH_UI)
   views::TouchFactory::GetInstance()->set_keep_mouse_cursor(
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kKeepMouseCursor));
 #endif
 
   HandleTestParameters(parsed_command_line());
-  RecordBreakpadStatusUMA(metrics);
+  RecordBreakpadStatusUMA(metrics_);
   about_flags::RecordUMAStatistics(local_state);
   LanguageUsageMetrics::RecordAcceptLanguages(
-      profile->GetPrefs()->GetString(prefs::kAcceptLanguages));
+      profile_->GetPrefs()->GetString(prefs::kAcceptLanguages));
   LanguageUsageMetrics::RecordApplicationLanguage(
       g_browser_process->GetApplicationLocale());
 
 #if defined(OS_CHROMEOS)
-  metrics->StartExternalMetrics();
+  metrics_->StartExternalMetrics();
 
   // Initialize the brightness observer so that we'll display an onscreen
   // indication of brightness changes during login.
   static chromeos::BrightnessObserver* brightness_observer =
       new chromeos::BrightnessObserver();
   chromeos::CrosLibrary::Get()->GetBrightnessLibrary()->AddObserver(
       brightness_observer);
 
   // Listen for system key events so that the user will be able to adjust the
   // volume on the login screen.
   chromeos::SystemKeyEventListener::GetInstance();
 
   // Listen for XI_HierarchyChanged events.
   chromeos::XInputHierarchyChangedEventListener::GetInstance();
 #endif
 
   // The extension service may be available at this point. If the command line
   // specifies --uninstall-extension, attempt the uninstall extension startup
   // action.
   if (parsed_command_line().HasSwitch(switches::kUninstallExtension)) {
     ExtensionsStartupUtil ext_startup_util;
-    if (ext_startup_util.UninstallExtension(parsed_command_line(), profile)) {
-      return content::RESULT_CODE_NORMAL_EXIT;
+    if (ext_startup_util.UninstallExtension(parsed_command_line(), profile_)) {
+      set_result_code(content::RESULT_CODE_NORMAL_EXIT);
     } else {
-      return chrome::RESULT_CODE_UNINSTALL_EXTENSION_ERROR;
+      set_result_code(chrome::RESULT_CODE_UNINSTALL_EXTENSION_ERROR);
     }
+    return;
   }
 
 #if defined(OS_WIN)
   // We check this here because if the profile is OTR (chromeos possibility)
   // it won't still be accessible after browser is destroyed.
-  bool record_search_engine = is_first_run && !profile->IsOffTheRecord();
+  record_search_engine_ = is_first_run && !profile_->IsOffTheRecord();
 #endif
 
   // ChildProcess:: is a misnomer unless you consider context.  Use
   // of --wait-for-debugger only makes sense when Chrome itself is a
   // child process (e.g. when launched by PyAuto).
   if (parsed_command_line().HasSwitch(switches::kWaitForDebugger)) {
     ChildProcess::WaitForDebugger("Browser");
   }
 
 #if defined(OS_CHROMEOS)
   // Run the Out of Memory priority manager while in this scope.  Wait
   // until here to start so that we give the most amount of time for
   // the other services to start up before we start adjusting the oom
   // priority.  In reality, it doesn't matter much where in this scope
   // this is started, but it must be started in this scope so it will
   // also be terminated when this scope exits.
   scoped_ptr<browser::OomPriorityManager> oom_priority_manager(
       new browser::OomPriorityManager);
 #endif
 
   // Create the instance of the cloud print proxy service so that it can launch
   // the service process if needed. This is needed because the service process
   // might have shutdown because an update was available.
   // TODO(torne): this should maybe be done with
   // ProfileKeyedServiceFactory::ServiceIsCreatedWithProfile() instead?
-  CloudPrintProxyServiceFactory::GetForProfile(profile);
+  CloudPrintProxyServiceFactory::GetForProfile(profile_);
 
   // Initialize GpuDataManager and collect preliminary gpu info on FILE thread.
   // Upon completion, it posts GpuBlacklist auto update task on UI thread.
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableFunction(&GpuBlacklistUpdater::SetupOnFileThread));
 
   // Start watching all browser threads for responsiveness.
   ThreadWatcherList::StartWatchingAll(parsed_command_line());
 

[jam, 2011/09/08 16:21:06]

fixed this spacing and also 1766

+
   int result_code = content::RESULT_CODE_NORMAL_EXIT;
   base::mac::ScopedNSAutoreleasePool* pool = parameters().autorelease_pool_;
   if (parameters().ui_task) {
     // We are in test mode. Run one task and enter the main message loop.
     if (pool)
       pool->Recycle();
     parameters().ui_task->Run();
     delete parameters().ui_task;
-  } else {
+    } else {
     // Most general initialization is behind us, but opening a
     // tab and/or session restore and such is still to be done.
     base::TimeTicks browser_open_start = base::TimeTicks::Now();
 
     // We are in regular browser boot sequence. Open initial tabs and enter the
     // main message loop.
-    if (browser_init.Start(parsed_command_line(), FilePath(), profile,
+    if (browser_init.Start(parsed_command_line(), FilePath(), profile_,
                            &result_code)) {
 #if (defined(OS_WIN) || defined(OS_LINUX)) && !defined(OS_CHROMEOS)
       // Initialize autoupdate timer. Timer callback costs basically nothing
       // when browser is not in persistent mode, so it's OK to let it ride on
       // the main thread. This needs to be done here because we don't want
       // to start the timer when Chrome is run inside a test harness.
       g_browser_process->StartAutoupdateTimer();
 #endif
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
@@ skipping 12 matching lines @@
         pool->Recycle();
 
       RecordPreReadExperimentTime("Startup.BrowserOpenTabs",
                                   base::TimeTicks::Now() - browser_open_start);
 
       // TODO(mad): Move this call in a proper place on CrOS.
       // http://crosbug.com/17687
 #if !defined(OS_CHROMEOS)
       // If we're running tests (ui_task is non-null), then we don't want to
       // call FetchLanguageListFromTranslateServer
-      if (parameters().ui_task == NULL && translate_manager != NULL) {
+      if (parameters().ui_task == NULL && translate_manager_ != NULL) {
         // TODO(willchan): Get rid of this after TranslateManager doesn't use
         // the default request context. http://crbug.com/89396.
         // This is necessary to force |default_request_context_| to be
         // initialized.
-        profile->GetRequestContext();
-        translate_manager->FetchLanguageListFromTranslateServer(user_prefs);
+        profile_->GetRequestContext();
+        translate_manager_->FetchLanguageListFromTranslateServer(user_prefs);
       }
 #endif
 
-      RunUIMessageLoop(browser_process.get());
+      run_message_loop_ = true;
     }
   }
+}
 
+void ChromeBrowserMainParts::MainMessageLoopRun() {
+  if (!run_message_loop_)
+    return;
+
+  // 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(TOOLKIT_VIEWS)
+  views::AcceleratorHandler accelerator_handler;
+  MessageLoopForUI::current()->Run(&accelerator_handler);
+#elif defined(USE_X11)
+  MessageLoopForUI::current()->Run(NULL);
+#elif defined(OS_POSIX)
+  MessageLoopForUI::current()->Run();
+#endif
+#if defined(OS_CHROMEOS)
+  chromeos::BootTimesLoader::Get()->AddLogoutTimeMarker("UIMessageLoopEnded",
+                                                        true);
+#endif
+}
+
+void ChromeBrowserMainParts::PostMainMessageLoopRun() {
   // Start watching for jank during shutdown. It gets disarmed when
   // |shutdown_watcher_| object is destructed.
   shutdown_watcher_->Arm(base::TimeDelta::FromSeconds(45));
 
 #if defined(OS_WIN)
   // If it's the first run, log the search engine chosen.  We wait until
   // shutdown because otherwise we can't be sure the user has finished
   // selecting a search engine through the dialog reached from the first run
   // bubble link.
-  if (record_search_engine) {
+  if (record_search_engine_) {
     TemplateURLService* url_service =
-        TemplateURLServiceFactory::GetForProfile(profile);
+        TemplateURLServiceFactory::GetForProfile(profile_);
     const TemplateURL* default_search_engine =
         url_service->GetDefaultSearchProvider();
     // The default engine can be NULL if the administrator has disabled
     // default search.
     SearchEngineType search_engine_type =
         default_search_engine ? default_search_engine->search_engine_type() :
                                 SEARCH_ENGINE_OTHER;
     // Record the search engine chosen.
-    if (master_prefs.run_search_engine_experiment) {
+    if (master_prefs_->run_search_engine_experiment) {
       UMA_HISTOGRAM_ENUMERATION(
           "Chrome.SearchSelectExperiment",
           search_engine_type,
           SEARCH_ENGINE_MAX);
       // If the selection has been randomized, also record the winner by slot.
-      if (master_prefs.randomize_search_engine_experiment) {
+      if (master_prefs_->randomize_search_engine_experiment) {
         size_t engine_pos = url_service->GetSearchEngineDialogSlot();
         if (engine_pos < 4) {
           std::string experiment_type = "Chrome.SearchSelectExperimentSlot";
           // Nicer in UMA if slots are 1-based.
           experiment_type.push_back('1' + engine_pos);
           UMA_HISTOGRAM_ENUMERATION(
               experiment_type,
               search_engine_type,
               SEARCH_ENGINE_MAX);
         } else {
           NOTREACHED() << "Invalid search engine selection slot.";
         }
       }
     } else {
       UMA_HISTOGRAM_ENUMERATION(
           "Chrome.SearchSelectExempt",
           search_engine_type,
           SEARCH_ENGINE_MAX);
     }
   }
 #endif
 
   // Some tests don't set parameters.ui_task, so they started translate
   // language fetch that was never completed so we need to cleanup here
   // otherwise it will be done by the destructor in a wrong thread.
-  if (parameters().ui_task == NULL && translate_manager != NULL)
-    translate_manager->CleanupPendingUlrFetcher();
+  if (parameters().ui_task == NULL && translate_manager_ != NULL)

[tony, 2011/09/08 17:21:04]

Do we need to make a member variable for translate_manager_ or can we just call
TranslateManager::GetInstance() again?

[jam, 2011/09/08 17:43:01]

I had done this so that we don't end up constructing TranslateManager in
PostMainMessageLoopRun() if it wasn't constructed before (to match the old
behavior)

+    translate_manager_->CleanupPendingUlrFetcher();
 
-
-  process_singleton.Cleanup();
+  process_singleton_->Cleanup();
 
   // Stop all tasks that might run on WatchDogThread.
   ThreadWatcherList::StopWatchingAll();
 
-  metrics->Stop();
+  metrics_->Stop();

[tony, 2011/09/08 17:21:04]

It looks like this is g_browser_process->metrics_service(), so we can probably
use that instead of making a member variable for it.

[jam, 2011/09/08 17:43:01]

Done.

 
   // browser_shutdown takes care of deleting browser_process, so we need to
   // release it.
-  ignore_result(browser_process.release());
+  ignore_result(browser_process_.release());
   browser_shutdown::Shutdown();
+  master_prefs_.reset();
+  process_singleton_.reset();
+}
 
-  return result_code;
+void ChromeBrowserMainParts::ToolkitInitialized() {
+#if defined(TOOLKIT_VIEWS)
+  // The delegate needs to be set before any UI is created so that windows
+  // display the correct icon.
+  if (!views::ViewsDelegate::views_delegate)
+    views::ViewsDelegate::views_delegate = new ChromeViewsDelegate;
+
+  // TODO(beng): Move to WidgetImpl and implement on Windows too!
+  if (parameters().command_line_.HasSwitch(switches::kDebugViewsPaint))
+    views::Widget::SetDebugPaintEnabled(true);
+#endif
+
+#if defined(OS_WIN)
+  gfx::PlatformFontWin::adjust_font_callback = &AdjustUIFont;
+  gfx::PlatformFontWin::get_minimum_font_size_callback = &GetMinimumFontSize;
+#endif
 }
 
 // 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
 }