Start moving code from BrowserMain to content, so that it can be reused by all embedders of conte...

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/allocator/allocator_shim.h"
 #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/system_monitor/system_monitor.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/chrome_content_browser_client.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"
@@ skipping 39 matching lines @@
 #include "chrome/common/jstemplate_builder.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/net/net_resource_provider.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/profiling.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/common/child_process.h"
 #include "content/common/content_client.h"
-#include "content/common/hi_res_timer_manager.h"
 #include "content/common/main_function_params.h"
 #include "grit/app_locale_settings.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/platform_locale_settings.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/net_module.h"
-#include "net/base/network_change_notifier.h"
 #include "net/http/http_basic_stream.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_stream_factory.h"
 #include "net/socket/client_socket_pool_base.h"
 #include "net/socket/client_socket_pool_manager.h"
-#include "net/socket/tcp_client_socket.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_throttler_manager.h"
 #include "net/websockets/websocket_job.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 
 #if defined(USE_LINUX_BREAKPAD)
 #include "base/linux_util.h"
 #include "chrome/app/breakpad_linux.h"
 #endif
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
-#include <dbus/dbus-glib.h>
-
 #include "chrome/browser/browser_main_gtk.h"
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #endif
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 #include "chrome/browser/first_run/upgrade_util_linux.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/boot_times_loader.h"
 #include "chrome/browser/chromeos/brightness_observer.h"
 #include "chrome/browser/chromeos/cros_settings_names.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/screen_lock_library.h"
 #include "chrome/browser/chromeos/customization_document.h"
 #include "chrome/browser/chromeos/external_metrics.h"
 #include "chrome/browser/chromeos/login/authenticator.h"
 #include "chrome/browser/chromeos/login/login_utils.h"
 #include "chrome/browser/chromeos/login/ownership_service.h"
 #include "chrome/browser/chromeos/login/screen_locker.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
-#include "chrome/browser/chromeos/net/cros_network_change_notifier_factory.h"
 #include "chrome/browser/chromeos/system_key_event_listener.h"
 #include "chrome/browser/chromeos/user_cros_settings_provider.h"
 #include "chrome/browser/chromeos/xinput_hierarchy_changed_event_listener.h"
 #include "chrome/browser/oom_priority_manager.h"
 #include "chrome/browser/ui/views/browser_dialogs.h"
 #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 <windows.h>
-#include <commctrl.h>
-#include <shellapi.h>
 
 #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"
 #include "chrome/installer/util/shell_util.h"
 #include "content/browser/user_metrics.h"
-#include "content/common/sandbox_policy.h"
 #include "net/base/net_util.h"
 #include "net/base/sdch_manager.h"
 #include "printing/printed_document.h"
-#include "sandbox/src/sandbox.h"
 #include "ui/base/l10n/l10n_util_win.h"
 #include "ui/gfx/platform_font_win.h"
 #endif  // defined(OS_WIN)
 
 #if defined(OS_MACOSX)
 #include <Security/Security.h>
 
 #include "chrome/browser/mac/install_from_dmg.h"
 #endif
 
@@ skipping 234 matching lines @@
         !local_state->IsManagedPreference(prefs::kApplicationLocale)) {
       local_state->SetString(prefs::kApplicationLocale, owner_locale);
       local_state->ScheduleSavePersistentPrefs();
     }
   }
 #endif
 
   return local_state;
 }
 
-// Windows-specific initialization code for the sandbox broker services. This
-// is just a NOP on non-Windows platforms to reduce ifdefs later on.
-void InitializeBrokerServices(const MainFunctionParams& parameters,
-                              const CommandLine& parsed_command_line) {
-#if defined(OS_WIN)
-  sandbox::BrokerServices* broker_services =
-      parameters.sandbox_info_.BrokerServices();
-  if (broker_services) {
-    sandbox::InitBrokerServices(broker_services);
-    if (!parsed_command_line.HasSwitch(switches::kNoSandbox)) {
-      bool use_winsta = !parsed_command_line.HasSwitch(
-                            switches::kDisableAltWinstation);
-      // Precreate the desktop and window station used by the renderers.
-      sandbox::TargetPolicy* policy = broker_services->CreatePolicy();
-      sandbox::ResultCode result = policy->CreateAlternateDesktop(use_winsta);
-      CHECK(sandbox::SBOX_ERROR_FAILED_TO_SWITCH_BACK_WINSTATION != result);
-      policy->Release();
-    }
-  }
-#endif
-}
-
 // Initializes the profile, possibly doing some user prompting to pick a
 // fallback profile. Returns the newly created profile, or NULL if startup
 // should not continue.
 Profile* CreateProfile(const MainFunctionParams& parameters,
                        const FilePath& user_data_dir,
                        const CommandLine& parsed_command_line) {
   Profile* profile;
   if (ProfileManager::IsMultipleProfilesEnabled()) {
     if (parsed_command_line.HasSwitch(switches::kProfileDirectory)) {
       g_browser_process->local_state()->SetString(prefs::kProfileLastUsed,
@@ skipping 53 matching lines @@
 
 int GetMinimumFontSize() {
   int min_font_size;
   base::StringToInt(l10n_util::GetStringUTF16(IDS_MINIMUM_UI_FONT_SIZE),
                     &min_font_size);
   return min_font_size;
 }
 
 #endif
 
-#if defined(TOOLKIT_USES_GTK)
-static void GLibLogHandler(const gchar* log_domain,
-                           GLogLevelFlags log_level,
-                           const gchar* message,
-                           gpointer userdata) {
-  if (!log_domain)
-    log_domain = "<unknown>";
-  if (!message)
-    message = "<no message>";
-
-  if (strstr(message, "Loading IM context type") ||
-      strstr(message, "wrong ELF class: ELFCLASS64")) {
-    // http://crbug.com/9643
-    // Until we have a real 64-bit build or all of these 32-bit package issues
-    // are sorted out, don't fatal on ELF 32/64-bit mismatch warnings and don't
-    // spam the user with more than one of them.
-    static bool alerted = false;
-    if (!alerted) {
-      LOG(ERROR) << "Bug 9643: " << log_domain << ": " << message;
-      alerted = true;
-    }
-  } else if (strstr(message, "Theme file for default has no") ||
-             strstr(message, "Theme directory") ||
-             strstr(message, "theme pixmap")) {
-    LOG(ERROR) << "GTK theme error: " << message;
-  } else if (strstr(message, "gtk_drag_dest_leave: assertion")) {
-    LOG(ERROR) << "Drag destination deleted: http://crbug.com/18557";
-  } else if (strstr(message, "Out of memory") &&
-             strstr(log_domain, "<unknown>")) {
-    LOG(ERROR) << "DBus call timeout or out of memory: "
-               << "http://crosbug.com/15496";
-  } else {
-    LOG(DFATAL) << log_domain << ": " << message;
-  }
-}
-
-static void SetUpGLibLogHandler() {
-  // Register GLib-handled assertions to go through our logging system.
-  const char* kLogDomains[] = { NULL, "Gtk", "Gdk", "GLib", "GLib-GObject" };
-  for (size_t i = 0; i < arraysize(kLogDomains); i++) {
-    g_log_set_handler(kLogDomains[i],
-                      static_cast<GLogLevelFlags>(G_LOG_FLAG_RECURSION |
-                                                  G_LOG_FLAG_FATAL |
-                                                  G_LOG_LEVEL_ERROR |
-                                                  G_LOG_LEVEL_CRITICAL |
-                                                  G_LOG_LEVEL_WARNING),
-                      GLibLogHandler,
-                      NULL);
-  }
-}
-#endif
-
-void InitializeToolkit(const MainFunctionParams& parameters) {
-  // TODO(evan): this function is rather subtle, due to the variety
-  // of intersecting ifdefs we have.  To keep it easy to follow, there
-  // are no #else branches on any #ifs.
-
-#if defined(TOOLKIT_USES_GTK)
-  // We want to call g_thread_init(), but in some codepaths (tests) it
-  // is possible it has already been called.  In older versions of
-  // GTK, it is an error to call g_thread_init twice; unfortunately,
-  // the API to tell whether it has been called already was also only
-  // added in a newer version of GTK!  Thankfully, this non-intuitive
-  // check is actually equivalent and sufficient to work around the
-  // error.
-  if (!g_thread_supported())
-    g_thread_init(NULL);
-  // Glib type system initialization. Needed at least for gconf,
-  // used in net/proxy/proxy_config_service_linux.cc. Most likely
-  // this is superfluous as gtk_init() ought to do this. It's
-  // definitely harmless, so retained as a reminder of this
-  // requirement for gconf.
-  g_type_init();
-  // We use glib-dbus for geolocation and it's possible other libraries
-  // (e.g. gnome-keyring) will use it, so initialize its threading here
-  // as well.
-  dbus_g_thread_init();
-  gfx::GtkInitFromCommandLine(parameters.command_line_);
-  SetUpGLibLogHandler();
-#endif
-
-#if defined(TOOLKIT_GTK)
-  // It is important for this to happen before the first run dialog, as it
-  // styles the dialog as well.
-  gtk_util::InitRCStyles();
-#endif
-
-#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;
-
-  // Init common control sex.
-  INITCOMMONCONTROLSEX config;
-  config.dwSize = sizeof(config);
-  config.dwICC = ICC_WIN95_CLASSES;
-  if (!InitCommonControlsEx(&config))
-    LOG_GETLASTERROR(FATAL);
-#endif
-}
-
 #if defined(OS_CHROMEOS)
 
 // Class is used to login using passed username and password.
 // The instance will be deleted upon success or failure.
 class StubLogin : public chromeos::LoginStatusConsumer,
                   public chromeos::LoginUtils::Delegate {
  public:
   StubLogin(std::string username, std::string password) {
     authenticator_ = chromeos::LoginUtils::Get()->CreateAuthenticator(this);
     authenticator_.get()->AuthenticateToLogin(
@@ skipping 172 matching lines @@
 namespace chrome_browser {
 // This error message is not localized because we failed to load the
 // localization data files.
 const char kMissingLocaleDataTitle[] = "Missing File Error";
 const char kMissingLocaleDataMessage[] =
     "Unable to find locale data files. Please reinstall.";
 }  // namespace chrome_browser
 
 // BrowserMainParts ------------------------------------------------------------
 
-BrowserMainParts::BrowserMainParts(const MainFunctionParams& parameters)
-    : parameters_(parameters),
-      parsed_command_line_(parameters.command_line_) {
+ChromeBrowserMainParts::ChromeBrowserMainParts(
+    const MainFunctionParams& parameters)
+    : BrowserMainParts(parameters),
+      shutdown_watcher_(new ShutdownWatcherHelper()) {
+  // If we're running tests (ui_task is non-null).
+  if (parameters.ui_task)
+    browser_defaults::enable_help_app = false;  
 }
 
-BrowserMainParts::~BrowserMainParts() {
+ChromeBrowserMainParts::~ChromeBrowserMainParts() {
 }
 
-// BrowserMainParts: |EarlyInitialization()| and related -----------------------
-
-void BrowserMainParts::EarlyInitialization() {
-  PreEarlyInitialization();
-
-  if (parsed_command_line().HasSwitch(switches::kEnableBenchmarking))
-    base::FieldTrial::EnableBenchmarking();
-
-  InitializeSSL();
-
-  if (parsed_command_line().HasSwitch(switches::kDisableSSLFalseStart))
-    net::SSLConfigService::DisableFalseStart();
-  if (parsed_command_line().HasSwitch(switches::kEnableSSLCachedInfo))
-    net::SSLConfigService::EnableCachedInfo();
-  if (parsed_command_line().HasSwitch(switches::kEnableOriginBoundCerts))
-    net::SSLConfigService::EnableOriginBoundCerts();
-  if (parsed_command_line().HasSwitch(
-          switches::kEnableDNSCertProvenanceChecking)) {
-    net::SSLConfigService::EnableDNSCertProvenanceChecking();
-  }
-
-  // TODO(abarth): Should this move to InitializeNetworkOptions?  This doesn't
-  // seem dependent on InitializeSSL().
-  if (parsed_command_line().HasSwitch(switches::kEnableTcpFastOpen))
-    net::set_tcp_fastopen_enabled(true);
-
-  PostEarlyInitialization();
-}
-
-void BrowserMainParts::SetupHistogramSynchronizer() {
+void ChromeBrowserMainParts::SetupHistogramSynchronizer() {
   histogram_synchronizer_ = new HistogramSynchronizer();
 }
 
 // This will be called after the command-line has been mutated by about:flags
-MetricsService* BrowserMainParts::SetupMetricsAndFieldTrials(
+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
   // randomization. The client ID will be empty if the user has not opted
   // to send metrics.
@@ skipping 11 matching lines @@
 
   return metrics;
 }
 
 // This is an A/B test for the maximum number of persistent connections per
 // host. Currently Chrome, Firefox, and IE8 have this value set at 6. Safari
 // uses 4, and Fasterfox (a plugin for Firefox that supposedly configures it to
 // run faster) uses 8. We would like to see how much of an effect this value has
 // on browsing. Too large a value might cause us to run into SYN flood detection
 // mechanisms.
-void BrowserMainParts::ConnectionFieldTrial() {
+void ChromeBrowserMainParts::ConnectionFieldTrial() {
   const base::FieldTrial::Probability kConnectDivisor = 100;
   const base::FieldTrial::Probability kConnectProbability = 1;  // 1% prob.
 
   // After June 30, 2011 builds, it will always be in default group.
   scoped_refptr<base::FieldTrial> connect_trial(
       new base::FieldTrial(
           "ConnCountImpact", kConnectDivisor, "conn_count_6", 2011, 6, 30));
 
   // This (6) is the current default value. Having this group declared here
   // makes it straightforward to modify |kConnectProbability| such that the same
@@ skipping 28 matching lines @@
 }
 
 // A/B test for determining a value for unused socket timeout. Currently the
 // timeout defaults to 10 seconds. Having this value set too low won't allow us
 // to take advantage of idle sockets. Setting it to too high could possibly
 // result in more ERR_CONNECTION_RESETs, since some servers will kill a socket
 // before we time it out. Since these are "unused" sockets, we won't retry the
 // connection and instead show an error to the user. So we need to be
 // conservative here. We've seen that some servers will close the socket after
 // as short as 10 seconds. See http://crbug.com/84313 for more details.
-void BrowserMainParts::SocketTimeoutFieldTrial() {
+void ChromeBrowserMainParts::SocketTimeoutFieldTrial() {
   const base::FieldTrial::Probability kIdleSocketTimeoutDivisor = 100;
   // 1% probability for all experimental settings.
   const base::FieldTrial::Probability kSocketTimeoutProbability = 1;
 
   // After June 30, 2011 builds, it will always be in default group.
   scoped_refptr<base::FieldTrial> socket_timeout_trial(
       new base::FieldTrial("IdleSktToImpact", kIdleSocketTimeoutDivisor,
           "idle_timeout_10", 2011, 6, 30));
   const int socket_timeout_10 = socket_timeout_trial->kDefaultGroupNumber;
 
@@ skipping 10 matching lines @@
     net::ClientSocketPool::set_unused_idle_socket_timeout(5);
   } else if (idle_to_trial_group == socket_timeout_10) {
     net::ClientSocketPool::set_unused_idle_socket_timeout(10);
   } else if (idle_to_trial_group == socket_timeout_20) {
     net::ClientSocketPool::set_unused_idle_socket_timeout(20);
   } else {
     NOTREACHED();
   }
 }
 
-void BrowserMainParts::ProxyConnectionsFieldTrial() {
+void ChromeBrowserMainParts::ProxyConnectionsFieldTrial() {
   const base::FieldTrial::Probability kProxyConnectionsDivisor = 100;
   // 25% probability
   const base::FieldTrial::Probability kProxyConnectionProbability = 1;
 
   // After June 30, 2011 builds, it will always be in default group.
   scoped_refptr<base::FieldTrial> proxy_connection_trial(
       new base::FieldTrial("ProxyConnectionImpact", kProxyConnectionsDivisor,
           "proxy_connections_32", 2011, 6, 30));
 
   // This (32 connections per proxy server) is the current default value.
@@ skipping 25 matching lines @@
   }
 }
 
 // When --use-spdy not set, users will be in A/B test for spdy.
 // group A (npn_with_spdy): this means npn and spdy are enabled. In case server
 //                          supports spdy, browser will use spdy.
 // group B (npn_with_http): this means npn is enabled but spdy won't be used.
 //                          Http is still used for all requests.
 //           default group: no npn or spdy is involved. The "old" non-spdy
 //                          chrome behavior.
-void BrowserMainParts::SpdyFieldTrial() {
+void ChromeBrowserMainParts::SpdyFieldTrial() {
   if (parsed_command_line().HasSwitch(switches::kUseSpdy)) {
     std::string spdy_mode =
         parsed_command_line().GetSwitchValueASCII(switches::kUseSpdy);
     net::HttpNetworkLayer::EnableSpdy(spdy_mode);
   } else {
 #if !defined(OS_CHROMEOS)
     bool is_spdy_trial = false;
     const base::FieldTrial::Probability kSpdyDivisor = 100;
     base::FieldTrial::Probability npnhttp_probability = 5;
 
@@ skipping 47 matching lines @@
     base::StringToInt(parsed_command_line().GetSwitchValueASCII(
             switches::kMaxSpdyConcurrentStreams),
         &value);
     if (value > 0)
       net::SpdySession::set_max_concurrent_streams(value);
   }
 }
 
 // If --socket-reuse-policy is not specified, run an A/B test for choosing the
 // warmest socket.
-void BrowserMainParts::WarmConnectionFieldTrial() {
+void ChromeBrowserMainParts::WarmConnectionFieldTrial() {
   const CommandLine& command_line = parsed_command_line();
   if (command_line.HasSwitch(switches::kSocketReusePolicy)) {
     std::string socket_reuse_policy_str = command_line.GetSwitchValueASCII(
         switches::kSocketReusePolicy);
     int policy = -1;
     base::StringToInt(socket_reuse_policy_str, &policy);
 
     const int policy_list[] = { 0, 1, 2 };
     VLOG(1) << "Setting socket_reuse_policy = " << policy;
     SetSocketReusePolicy(policy, policy_list, arraysize(policy_list));
@@ skipping 20 matching lines @@
 
   const int policy_list[] = { warmest_socket, warm_socket,
                               last_accessed_socket };
   SetSocketReusePolicy(warmest_socket_trial_group, policy_list,
                        arraysize(policy_list));
 }
 
 // If neither --enable-connect-backup-jobs or --disable-connect-backup-jobs is
 // specified, run an A/B test for automatically establishing backup TCP
 // connections when a certain timeout value is exceeded.
-void BrowserMainParts::ConnectBackupJobsFieldTrial() {
+void ChromeBrowserMainParts::ConnectBackupJobsFieldTrial() {
   if (parsed_command_line().HasSwitch(switches::kEnableConnectBackupJobs)) {
     net::internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
         true);
   } else if (parsed_command_line().HasSwitch(
         switches::kDisableConnectBackupJobs)) {
     net::internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
         false);
   } else {
     const base::FieldTrial::Probability kConnectBackupJobsDivisor = 100;
     // 1% probability.
     const base::FieldTrial::Probability kConnectBackupJobsProbability = 1;
     // After June 30, 2011 builds, it will always be in default group.
     scoped_refptr<base::FieldTrial> trial(
         new base::FieldTrial("ConnnectBackupJobs",
             kConnectBackupJobsDivisor, "ConnectBackupJobsEnabled", 2011, 6,
                 30));
     const int connect_backup_jobs_enabled = trial->kDefaultGroupNumber;
     trial->AppendGroup("ConnectBackupJobsDisabled",
                        kConnectBackupJobsProbability);
     const int trial_group = trial->group();
     net::internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
         trial_group == connect_backup_jobs_enabled);
   }
 }
 
 // Test the impact on subsequent Google searches of getting suggestions from
 // www.google.TLD instead of clients1.google.TLD.
-void BrowserMainParts::SuggestPrefixFieldTrial() {
+void ChromeBrowserMainParts::SuggestPrefixFieldTrial() {
   const base::FieldTrial::Probability kSuggestPrefixDivisor = 100;
   // 50% probability.
   const base::FieldTrial::Probability kSuggestPrefixProbability = 50;
   // After Jan 1, 2012, it will always be in default group.
   scoped_refptr<base::FieldTrial> trial(
       new base::FieldTrial("SuggestHostPrefix",
           kSuggestPrefixDivisor, "Default_Prefix", 2012, 1, 1));
   trial->AppendGroup("Www_Prefix", kSuggestPrefixProbability);
   // The field trial is detected directly, so we don't need to call anything.
 }
 
-// BrowserMainParts: |MainMessageLoopStart()| and related ----------------------
-
-void BrowserMainParts::MainMessageLoopStart() {
-  PreMainMessageLoopStart();
-
-  main_message_loop_.reset(new MessageLoop(MessageLoop::TYPE_UI));
-
-  // TODO(viettrungluu): should these really go before setting the thread name?
-  system_monitor_.reset(new base::SystemMonitor);
-  hi_res_timer_manager_.reset(new HighResolutionTimerManager);
-
-  InitializeMainThread();
-
-  network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
-
-  PostMainMessageLoopStart();
-  Profiling::MainMessageLoopStarted();
-}
-
-void BrowserMainParts::InitializeMainThread() {
-  const char* kThreadName = "CrBrowserMain";
-  base::PlatformThread::SetName(kThreadName);
-  main_message_loop().set_thread_name(kThreadName);
-
-  // Register the main thread by instantiating it, but don't call any methods.
-  main_thread_.reset(new BrowserThread(BrowserThread::UI,
-                                       MessageLoop::current()));
-}
-
-// BrowserMainParts: |SetupMetricsAndFieldTrials()| related --------------------
+// ChromeBrowserMainParts: |SetupMetricsAndFieldTrials()| related --------------
 
 // Initializes the metrics service with the configuration for this process,
 // returning the created service (guaranteed non-NULL).
-MetricsService* BrowserMainParts::InitializeMetrics(
+MetricsService* ChromeBrowserMainParts::InitializeMetrics(
     const CommandLine& parsed_command_line,
     const PrefService* local_state) {
 #if defined(OS_WIN)
   if (parsed_command_line.HasSwitch(switches::kChromeFrame))
     MetricsLog::set_version_extension("-F");
 #elif defined(ARCH_CPU_64_BITS)
   MetricsLog::set_version_extension("-64");
 #endif  // defined(OS_WIN)
 
   MetricsService* metrics = g_browser_process->metrics_service();
@@ skipping 16 matching lines @@
   bool enabled = local_state->GetBoolean(prefs::kMetricsReportingEnabled);
 #endif  // #if defined(OS_CHROMEOS)
   if (enabled) {
     metrics->Start();
   }
 #endif  // defined(GOOGLE_CHROME_BUILD)
 
   return metrics;
 }
 
-void BrowserMainParts::SetupFieldTrials(bool metrics_recording_enabled,
-                                        bool proxy_policy_is_set) {
+void ChromeBrowserMainParts::SetupFieldTrials(bool metrics_recording_enabled,
+                                              bool proxy_policy_is_set) {
   // Note: make sure to call ConnectionFieldTrial() before
   // ProxyConnectionsFieldTrial().
   ConnectionFieldTrial();
   SocketTimeoutFieldTrial();
   // If a policy is defining the number of active connections this field test
   // shoud not be performed.
   if (!proxy_policy_is_set)
     ProxyConnectionsFieldTrial();
   prerender::ConfigurePrefetchAndPrerender(parsed_command_line());
   InstantFieldTrial::Activate();
@@ skipping 22 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
 
-// Main routine for running as the Browser process.
-int BrowserMain(const MainFunctionParams& parameters) {
-  // Create ShutdownWatcherHelper object for watching jank during shutdown.
-  // Please keep |shutdown_watcher| as the first object constructed, and hence
-  // it is destroyed last.
-  ShutdownWatcherHelper shutdown_watcher;
+void ChromeBrowserMainParts::PostMainMessageLoopStart() {
+  Profiling::MainMessageLoopStarted();
+}
 
-  TRACE_EVENT_BEGIN_ETW("BrowserMain", 0, "");
+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;
 
-  // Override the default ContentBrowserClient to let Chrome participate in
-  // content logic.
-  chrome::ChromeContentBrowserClient browser_client;
-  content::GetContentClient()->set_browser(&browser_client);
-
-  // If we're running tests (ui_task is non-null).
-  if (parameters.ui_task)
-    browser_defaults::enable_help_app = false;
-
-  scoped_ptr<BrowserMainParts>
-      parts(BrowserMainParts::CreateBrowserMainParts(parameters));
-
-  parts->EarlyInitialization();
-
-  // Must happen before we try to use a message loop or display any UI.
-  InitializeToolkit(parameters);
-
-#if defined(OS_CHROMEOS)
-  // Initialize CrosLibrary only for the browser, unless running tests
-  // (which do their own CrosLibrary setup).
-  if (!parameters.ui_task) {
-    bool use_stub = parameters.command_line_.HasSwitch(switches::kStubCros);
-    chromeos::CrosLibrary::Initialize(use_stub);
-  }
-  // Replace the default NetworkChangeNotifierFactory with ChromeOS specific
-  // implementation.
-  net::NetworkChangeNotifier::SetFactory(
-      new chromeos::CrosNetworkChangeNotifierFactory());
+  // TODO(beng): Move to WidgetImpl and implement on Windows too!
+  if (parameters().command_line_.HasSwitch(switches::kDebugViewsPaint))
+    views::Widget::SetDebugPaintEnabled(true);
 #endif
 
-  parts->MainMessageLoopStart();
+#if defined(OS_WIN)
+  gfx::PlatformFontWin::adjust_font_callback = &AdjustUIFont;
+  gfx::PlatformFontWin::get_minimum_font_size_callback = &GetMinimumFontSize;
+#endif
+}
 
-  // WARNING: If we get a WM_ENDSESSION, objects created on the stack here
-  // are NOT deleted. If you need something to run during WM_ENDSESSION add it
-  // to browser_shutdown::Shutdown or BrowserProcess::EndSession.
-
-  // !!!!!!!!!! READ ME !!!!!!!!!!
-  // I (viettrungluu) am in the process of refactoring |BrowserMain()|. If you
-  // need to add something above this comment, read the documentation in
-  // browser_main.h. If you need to add something below, please do the
-  // following:
-  //  - Figure out where you should add your code. Do NOT just pick a random
-  //    location "which works".
-  //  - Document the dependencies apart from compile-time-checkable ones. What
-  //    must happen before your new code is executed? Does your new code need to
-  //    run before something else? Are there performance reasons for executing
-  //    your code at that point?
-  //  - If you need to create a (persistent) object, heap allocate it and keep a
-  //    |scoped_ptr| to it rather than allocating it on the stack. Otherwise
-  //    I'll have to convert your code when I refactor.
-  //  - Unless your new code is just a couple of lines, factor it out into a
-  //    function with a well-defined purpose. Do NOT just add it inline in
-  //    |BrowserMain()|.
-  // Thanks!
-
-  // TODO(viettrungluu): put the remainder into BrowserMainParts
-  const CommandLine& parsed_command_line = parameters.command_line_;
-  base::mac::ScopedNSAutoreleasePool* pool = parameters.autorelease_pool_;
-
-#if defined(OS_WIN) && !defined(NO_TCMALLOC)
-  // When linking shared libraries, NO_TCMALLOC is defined, and dynamic
-  // allocator selection is not supported.
-
-  // Make this call before going multithreaded, or spawning any subprocesses.
-  base::allocator::SetupSubprocessAllocator();
-#endif  // OS_WIN
-
+int ChromeBrowserMainParts::TemporaryContinue() {
   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);
 
   bool is_first_run = FirstRun::IsChromeFirstRun() ||
-      parsed_command_line.HasSwitch(switches::kFirstRun);
+      parsed_command_line().HasSwitch(switches::kFirstRun);
 
   scoped_ptr<BrowserProcessImpl> browser_process;
-  if (parsed_command_line.HasSwitch(switches::kImport) ||
-      parsed_command_line.HasSwitch(switches::kImportFromFile)) {
+  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()));
   }
 
-  // BrowserProcessImpl's constructor should set g_browser_process.
-  DCHECK(g_browser_process);
-
   // 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();
 
-  // The broker service initialization needs to run early because it will
-  // initialize the sandbox broker, which requires the process to swap its
-  // window station. During this time all the UI will be broken. This has to
-  // run before threads and windows are created.
-  InitializeBrokerServices(parameters, parsed_command_line);
-
-  // Initialize histogram statistics gathering system.
-  base::StatisticsRecorder statistics;
-
-  PrefService* local_state = InitializeLocalState(parsed_command_line,
+  PrefService* local_state = InitializeLocalState(parsed_command_line(),
                                                   is_first_run);
 
 #if defined(USE_LINUX_BREAKPAD)
   // Needs to be called after we have chrome::DIR_USER_DATA and
   // g_browser_process.
   g_browser_process->file_thread()->message_loop()->PostTask(FROM_HERE,
       new GetLinuxDistroTask());
 
   if (IsCrashReportingEnabled(local_state))
     InitCrashReporter();
 #endif
 
   // If we're running tests (ui_task is non-null), then the ResourceBundle
   // has already been initialized.
-  if (parameters.ui_task) {
+  if (parameters().ui_task) {
     g_browser_process->SetApplicationLocale("en-US");
   } else {
     // Mac starts it earlier in |PreMainMessageLoopStart()| (because it is
     // needed when loading the MainMenu.nib and the language doesn't depend on
     // anything since it comes from Cocoa.
 #if defined(OS_MACOSX)
     g_browser_process->SetApplicationLocale(l10n_util::GetLocaleOverride());
 #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)) {
+        !parsed_command_line().HasSwitch(switches::kNoErrorDialogs)) {
       ShowMissingLocaleMessageBox();
       return chrome::RESULT_CODE_MISSING_DATA;
     }
     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);
+      parsed_command_line().GetSwitchValueASCII(switches::kTryChromeAgain);
   if (!try_chrome.empty()) {
 #if defined(OS_WIN)
     // 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()) {
       // 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;
     }
@@ skipping 14 matching lines @@
 #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));
   // Launch the views desktop shell window and register it as the default parent
   // for all unparented views widgets.
-  if (parsed_command_line.HasSwitch(switches::kViewsDesktop)) {
+  if (parsed_command_line().HasSwitch(switches::kViewsDesktop)) {
     std::string desktop_type_cmd =
-        parsed_command_line.GetSwitchValueASCII(switches::kViewsDesktop);
+        parsed_command_line().GetSwitchValueASCII(switches::kViewsDesktop);
     views::desktop::DesktopWindowView::DesktopType desktop_type;
     if (desktop_type_cmd == "netbook")
       desktop_type = views::desktop::DesktopWindowView::DESKTOP_NETBOOK;
     else if (desktop_type_cmd == "other")
       desktop_type = views::desktop::DesktopWindowView::DESKTOP_OTHER;
     else
       desktop_type = views::desktop::DesktopWindowView::DESKTOP_DEFAULT;
     views::desktop::DesktopWindowView::CreateDesktopWindow(desktop_type);
     ChromeViewsDelegate* chrome_views_delegate =
         static_cast<ChromeViewsDelegate*>(views::ViewsDelegate::views_delegate);
@@ skipping 10 matching lines @@
   FirstRun::MasterPrefs master_prefs;
   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);
 
     // 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)))
+        (parsed_command_line().HasSwitch(switches::kApp) ||
+         parsed_command_line().HasSwitch(switches::kAppId) ||
+         parsed_command_line().HasSwitch(switches::kNoFirstRun)))
       first_run_ui_bypass = true;
   }
 
   // TODO(viettrungluu): why don't we run this earlier?
-  if (!parsed_command_line.HasSwitch(switches::kNoErrorDialogs))
+  if (!parsed_command_line().HasSwitch(switches::kNoErrorDialogs))
     WarnAboutMinimumSystemRequirements();
 
   // Enable print preview once for supported platforms.
 #if defined(GOOGLE_CHROME_BUILD) && !defined(OS_CHROMEOS)
   local_state->RegisterBooleanPref(prefs::kPrintingPrintPreviewEnabledOnce,
                                    false,
                                    PrefService::UNSYNCABLE_PREF);
   if (!local_state->GetBoolean(prefs::kPrintingPrintPreviewEnabledOnce)) {
     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);
+  InitializeNetworkOptions(parsed_command_line());
   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.
-  parts->SetupHistogramSynchronizer();
+  SetupHistogramSynchronizer();
 
   // Now the command line has been mutated based on about:flags, we can
   // set up metrics and initialize field trials.
-  MetricsService* metrics = parts->SetupMetricsAndFieldTrials(
-      parsed_command_line, local_state);
+  MetricsService* 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());
   }
@@ skipping 27 matching lines @@
   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))
+  if (parsed_command_line().HasSwitch(switches::kUninstall))
     return DoUninstallTasks(already_running);
 #endif
 
-  if (parsed_command_line.HasSwitch(switches::kHideIcons) ||
-      parsed_command_line.HasSwitch(switches::kShowIcons))
-    return HandleIconsCommands(parsed_command_line);
-  if (parsed_command_line.HasSwitch(switches::kMakeDefaultBrowser)) {
+  if (parsed_command_line().HasSwitch(switches::kHideIcons) ||
+      parsed_command_line().HasSwitch(switches::kShowIcons))
+    return HandleIconsCommands(parsed_command_line());
+  if (parsed_command_line().HasSwitch(switches::kMakeDefaultBrowser)) {
     return ShellIntegration::SetAsDefaultBrowser() ?
         static_cast<int>(content::RESULT_CODE_NORMAL_EXIT) :
         static_cast<int>(chrome::RESULT_CODE_SHELL_INTEGRATION_FAILED);
   }
 
   // If the command line specifies --pack-extension, attempt the pack extension
   // startup action and exit.
-  if (parsed_command_line.HasSwitch(switches::kPackExtension)) {
+  if (parsed_command_line().HasSwitch(switches::kPackExtension)) {
     ExtensionsStartupUtil extension_startup_util;
-    if (extension_startup_util.PackExtension(parsed_command_line)) {
+    if (extension_startup_util.PackExtension(parsed_command_line())) {
       return content::RESULT_CODE_NORMAL_EXIT;
     } else {
       return chrome::RESULT_CODE_PACK_EXTENSION_ERROR;
     }
   }
 
 #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))) {
+  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()) {
       case ProcessSingleton::PROCESS_NONE:
         // No process already running, fall through to starting a new one.
         break;
 
@@ skipping 32 matching lines @@
   // 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();
 
   // TODO(abarth): Should this move to InitializeNetworkOptions()?
   // Allow access to file:// on ChromeOS for tests.
-  if (parsed_command_line.HasSwitch(switches::kAllowFileAccess))
+  if (parsed_command_line().HasSwitch(switches::kAllowFileAccess))
     net::URLRequest::AllowFileAccess();
 
   // There are two use cases for kLoginUser:
   //   1) if passed in tandem with kLoginPassword, to drive a "StubLogin"
   //   2) if passed alone, to signal that the indicated user has already
   //      logged in and we should behave accordingly.
   // This handles case 2.
-  if (parsed_command_line.HasSwitch(switches::kLoginUser) &&
-      !parsed_command_line.HasSwitch(switches::kLoginPassword)) {
+  if (parsed_command_line().HasSwitch(switches::kLoginUser) &&
+      !parsed_command_line().HasSwitch(switches::kLoginPassword)) {
     std::string username =
-        parsed_command_line.GetSwitchValueASCII(switches::kLoginUser);
+        parsed_command_line().GetSwitchValueASCII(switches::kLoginUser);
     VLOG(1) << "Relaunching browser for user: " << username;
     chromeos::UserManager::Get()->UserLoggedIn(username);
 
     // Redirects Chrome logging to the user data dir.
-    logging::RedirectChromeLogging(parsed_command_line);
+    logging::RedirectChromeLogging(parsed_command_line());
 
     // Initialize user policy before creating the profile so the profile
     // initialization code sees policy settings.
     g_browser_process->browser_policy_connector()->InitializeUserPolicy(
         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);
+  Profile* profile = CreateProfile(parameters(), user_data_dir,
+                                   parsed_command_line());
   if (!profile)
     return content::RESULT_CODE_NORMAL_EXIT;
 
   // 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)) {
+  if (parsed_command_line().HasSwitch(switches::kLoginUser) &&
+      !parsed_command_line().HasSwitch(switches::kLoginPassword)) {
     g_browser_process->browser_policy_connector()->SetUserPolicyTokenService(
         profile->GetTokenService());
   }
 #endif
 
   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);
+  if (!parameters().ui_task) {
+    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);
+  if (parsed_command_line().HasSwitch(switches::kImport) ||
+      parsed_command_line().HasSwitch(switches::kImportFromFile)) {
+    return FirstRun::ImportNow(profile, parsed_command_line());
   }
 #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))
+  if (!already_running && upgrade_util::DoUpgradeTasks(parsed_command_line()))
     return content::RESULT_CODE_NORMAL_EXIT;
 #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) &&
+  if (!parsed_command_line().HasSwitch(switches::kChromeFrame) &&
       CheckMachineLevelInstall())
     return chrome::RESULT_CODE_MACHINE_LEVEL_INSTALL_EXISTS;
 
   // Create the TranslateManager singleton.
   TranslateManager* translate_manager = TranslateManager::GetInstance();
   DCHECK(translate_manager != NULL);
 
 #if defined(OS_MACOSX)
-  if (!parsed_command_line.HasSwitch(switches::kNoFirstRun)) {
+  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;
     }
   }
 #endif
 
@@ skipping 23 matching lines @@
 #endif  // OS_POSIX
     }  // if (!first_run_ui_bypass)
 
     Browser::SetNewHomePagePrefs(user_prefs);
     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);
+  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.
   // This could be run as late as WM_QUERYENDSESSION for system update reboots,
   // but should run on startup if extended to handle crashes/hangs/patches.
   // Also, better to run once here than once for each HWND's WM_QUERYENDSESSION.
   if (base::win::GetVersion() >= base::win::VERSION_VISTA)
-    RegisterApplicationRestart(parsed_command_line);
+    RegisterApplicationRestart(parsed_command_line());
 #endif  // OS_WIN
 
   // Initialize and maintain network predictor module, which handles DNS
   // pre-resolution, as well as TCP/IP connection pre-warming.
   // This also registers an observer to discard data when closing incognito
   // mode.
   bool preconnect_enabled = true;  // Default status (easy to change!).
-  if (parsed_command_line.HasSwitch(switches::kDisablePreconnect))
+  if (parsed_command_line().HasSwitch(switches::kDisablePreconnect))
     preconnect_enabled = false;
-  else if (parsed_command_line.HasSwitch(switches::kEnablePreconnect))
+  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)
@@ skipping 58 matching lines @@
   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",
           2011, 6, 30));
   int sdch_enabled = sdch_trial->kDefaultGroupNumber;
 
   // Use default of "" so that all domains are supported.
   std::string sdch_supported_domain("");
-  if (parsed_command_line.HasSwitch(switches::kSdchFilter)) {
+  if (parsed_command_line().HasSwitch(switches::kSdchFilter)) {
     sdch_supported_domain =
-        parsed_command_line.GetSwitchValueASCII(switches::kSdchFilter);
+        parsed_command_line().GetSwitchValueASCII(switches::kSdchFilter);
   } else {
     sdch_trial->AppendGroup("global_disable_sdch",
                             kSDCH_DISABLE_PROBABILITY);
     if (sdch_enabled != sdch_trial->group())
       sdch_supported_domain = "never_enabled_sdch_for_any_domain";
   }
 
   net::SdchManager sdch_manager;  // Singleton database.
   sdch_manager.set_sdch_fetcher(new SdchDictionaryFetcher);
   sdch_manager.EnableSdchSupport(sdch_supported_domain);
 
-  InstallJankometer(parsed_command_line);
+  InstallJankometer(parsed_command_line());
 
 #if defined(OS_WIN) && !defined(GOOGLE_CHROME_BUILD)
-  if (parsed_command_line.HasSwitch(switches::kDebugPrint)) {
+  if (parsed_command_line().HasSwitch(switches::kDebugPrint)) {
     FilePath path =
-        parsed_command_line.GetSwitchValuePath(switches::kDebugPrint);
+        parsed_command_line().GetSwitchValuePath(switches::kDebugPrint);
     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);
+  HandleTestParameters(parsed_command_line());
   RecordBreakpadStatusUMA(metrics);
   about_flags::RecordUMAStatistics(local_state);
   LanguageUsageMetrics::RecordAcceptLanguages(
       profile->GetPrefs()->GetString(prefs::kAcceptLanguages));
   LanguageUsageMetrics::RecordApplicationLanguage(
       g_browser_process->GetApplicationLocale());
 
 #if defined(OS_CHROMEOS)
   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)) {
+  if (parsed_command_line().HasSwitch(switches::kUninstallExtension)) {
     ExtensionsStartupUtil ext_startup_util;
-    if (ext_startup_util.UninstallExtension(parsed_command_line, profile)) {
+    if (ext_startup_util.UninstallExtension(parsed_command_line(), profile)) {
       return content::RESULT_CODE_NORMAL_EXIT;
     } else {
       return chrome::RESULT_CODE_UNINSTALL_EXTENSION_ERROR;
     }
   }
 
 #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();
 #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)) {
+  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);
 
   // 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);
+  ThreadWatcherList::StartWatchingAll(parsed_command_line());
 
   int result_code = content::RESULT_CODE_NORMAL_EXIT;
-  if (parameters.ui_task) {
+  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;
+    parameters().ui_task->Run();
+    delete parameters().ui_task;
   } 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);
       }
 #endif
 
       RunUIMessageLoop(browser_process.get());
     }
   }
 
   // Start watching for jank during shutdown. It gets disarmed when
-  // |shutdown_watcher| object is destructed.
-  shutdown_watcher.Arm(base::TimeDelta::FromSeconds(25));
+  // |shutdown_watcher_| object is destructed.
+  shutdown_watcher_->Arm(base::TimeDelta::FromSeconds(25));
 
 #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) {
     TemplateURLService* url_service =
         TemplateURLServiceFactory::GetForProfile(profile);
     const TemplateURL* default_search_engine =
@@ skipping 29 matching lines @@
           "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)
+  if (parameters().ui_task == NULL && translate_manager != NULL)
     translate_manager->CleanupPendingUlrFetcher();
 
 
   process_singleton.Cleanup();
 
   // Stop all tasks that might run on WatchDogThread.
   ThreadWatcherList::StopWatchingAll();
 
   metrics->Stop();
 
   // browser_shutdown takes care of deleting browser_process, so we need to
   // release it.
   ignore_result(browser_process.release());
   browser_shutdown::Shutdown();
 
-  // Release BrowserMainParts here, before shutting down CrosLibrary, since
-  // some of the classes initialized there have CrosLibrary dependencies.
-  parts.reset(NULL);

[satorux1, 2011/09/07 17:10:31]

The comment says the BrowserMainParts is explicitly released, before
CrosLibrary's shutdown. However, CrosLibrary's shutdown is now moved to
~BroserMainPartsChromeos. This is rather worrisome.


http://codereview.chromium.org/7779040/diff/11053/chrome/browser/chromeos/bro...

 55 BrowserMainPartsChromeos::~BrowserMainPartsChromeos() {
 56   if (!parameters().ui_task && chromeos::CrosLibrary::Get())
 57     chromeos::CrosLibrary::Shutdown();

[jam, 2011/09/07 17:37:48]

Do you have any specifics that worry you?

We need to be able to reorder startup/shutdown slightly as we refactor existing
code, otherwise we would have to add a lot of callbacks to keep the exact same
order, which may not be necessary at all. a lot, but not all of course, of the
code was put in whatever place where it worked, but that doesn't mean it can't
move around.

[satorux1, 2011/09/07 18:50:15]

I don't have specific concerns. Steven who added CrosLibrary::Shutdown() here
may have some comment on this. I'm fine as long as Steven is fine with this
reorganization. 

[stevenjb, 2011/09/07 22:27:55]

This definitely changes things. We need to change the comment, now at the bottom
of content/browser/browser_main.cc, as it is no longer accurate.

Because the destructor of BrowserMainPartsChromeos and all of its member
destructors occur before BrowserMainParts, we will not be able to shut down
CrosLibrary before members of BrowserMainParts.

This means that we need to ensure that any class that has CrosLibrary calls in
its destructor is shut down as part of BrowserMainPartsChromeos and not
BrowserMainParts. This is more correct anyway. We will however need to do an
audit before R15 goes to beta.

I am looking at a chromeos shutdown problem anyway so will try to make sure that
all of the auto tests, etc, get exercised in Debug mode and we catch any
shutdown issues.

[jam, 2011/09/08 00:33:56]

yep I have removed that in my next cl
With my change CrosLibrary is shutdown before members of BrowserMainParts. The
only thing that depended on CrosLibrary is
BrowserMainParts::network_change_notifier_ since the factory is overriden by
BrowserMainPartsChromeos::PreMainMessageLoopStart(). We can add a method to
BrowserMainParts to reset the networkchangenotifier, but that did look hacky to
me, so instead I had made the networkchangenotifier handle the case of
CrosLibrary being gone. The only usage of it that I had seen was removing
observers, so it seemed ok to me, but you know this better than me.

http://codereview.chromium.org/7779040/diff/11053/chrome/browser/chromeos/net...
Agreed.
I suspect that if there were anymore, we'd quickly see this as shutdown crashes.

-
-#if defined(OS_CHROMEOS)
-  if (!parameters.ui_task)
-    chromeos::CrosLibrary::Shutdown();
-
-  // To be precise, logout (browser shutdown) is not yet done, but the
-  // remaining work is negligible, hence we say LogoutDone here.
-  chromeos::BootTimesLoader::Get()->AddLogoutTimeMarker("LogoutDone",
-                                                        false);
-  chromeos::BootTimesLoader::Get()->WriteLogoutTimes();
-#endif
-  TRACE_EVENT_END_ETW("BrowserMain", 0, 0);
   return result_code;
 }
 
 // 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.
@@ skipping 10 matching lines @@
   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
 }