Move chromeos specific code to ChromeBrowserMainPartsChromeos

chrome/browser/chrome_browser_main.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chrome_browser_main.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 41 matching lines @@
 #include "chrome/browser/metrics/thread_watcher.h"
 #include "chrome/browser/metrics/tracking_synchronizer.h"
 #include "chrome/browser/nacl_host/nacl_process_host.h"
 #include "chrome/browser/net/chrome_dns_cert_provenance_checker.h"
 #include "chrome/browser/net/chrome_dns_cert_provenance_checker_factory.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "chrome/browser/net/predictor.h"
 #include "chrome/browser/notifications/desktop_notification_service.h"
 #include "chrome/browser/notifications/desktop_notification_service_factory.h"
 #include "chrome/browser/plugin_prefs.h"
-#include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/pref_value_store.h"
 #include "chrome/browser/prerender/prerender_field_trial.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service_factory.h"
 #include "chrome/browser/process_singleton.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/search_engines/search_engine_type.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/service/service_process_control.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/browser/translate/translate_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_init.h"
 #include "chrome/browser/ui/webui/chrome_url_data_manager_backend.h"
 #include "chrome/browser/web_resource/gpu_blacklist_updater.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_result_codes.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/env_vars.h"
 #include "chrome/common/json_pref_store.h"
 #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/renderer_host/resource_dispatcher_host.h"
 #include "content/common/child_process.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/main_function_params.h"
 #include "grit/app_locale_settings.h"
@@ skipping 19 matching lines @@
 #if defined(USE_LINUX_BREAKPAD)
 #include "base/linux_util.h"
 #include "chrome/app/breakpad_linux.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/audio_handler.h"
-#include "chrome/browser/chromeos/boot_times_loader.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
-#include "chrome/browser/chromeos/cros/screen_lock_library.h"
 #include "chrome/browser/chromeos/cros_settings.h"
 #include "chrome/browser/chromeos/cros_settings_names.h"
-#include "chrome/browser/chromeos/customization_document.h"
-#include "chrome/browser/chromeos/dbus/dbus_thread_manager.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/system/runtime_environment.h"
-#include "chrome/browser/chromeos/system_key_event_listener.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"

[satorux1, 2011/11/23 23:51:53]

Great to see them gone!

 #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/windows_version.h"
@@ skipping 304 matching lines @@
 #else
   // TODO(port): fix this.  See comments near the definition of
   // user_data_dir.  It is better to CHECK-fail here than it is to
   // silently exit because of missing code in the above test.
   CHECK(profile) << "Cannot get default profile.";
 #endif
 
   return NULL;
 }
 
-#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)
-      : pending_requests_(false),
-        profile_prepared_(false) {
-    authenticator_ = chromeos::LoginUtils::Get()->CreateAuthenticator(this);
-    authenticator_.get()->AuthenticateToLogin(
-        g_browser_process->profile_manager()->GetDefaultProfile(),
-        username,
-        password,
-        std::string(),
-        std::string());
-  }
-
-  ~StubLogin() {
-    chromeos::LoginUtils::Get()->DelegateDeleted(this);
-  }
-
-  void OnLoginFailure(const chromeos::LoginFailure& error) {
-    LOG(ERROR) << "Login Failure: " << error.GetErrorString();
-    delete this;
-  }
-
-  void OnLoginSuccess(const std::string& username,
-                      const std::string& password,
-                      const GaiaAuthConsumer::ClientLoginResult& credentials,
-                      bool pending_requests,
-                      bool using_oauth) {
-    pending_requests_ = pending_requests;
-    if (!profile_prepared_) {
-      // Will call OnProfilePrepared in the end.
-      chromeos::LoginUtils::Get()->PrepareProfile(username,
-                                                  password,
-                                                  credentials,
-                                                  pending_requests,
-                                                  using_oauth,
-                                                  false,
-                                                  this);
-    } else if (!pending_requests) {
-      delete this;
-    }
-  }
-
-  // LoginUtils::Delegate implementation:
-  virtual void OnProfilePrepared(Profile* profile) {
-    profile_prepared_ = true;
-    chromeos::LoginUtils::DoBrowserLaunch(profile, NULL);
-    if (!pending_requests_)
-      delete this;
-  }
-
-  scoped_refptr<chromeos::Authenticator> authenticator_;
-  bool pending_requests_;
-  bool profile_prepared_;
-};
-
-void OptionallyRunChromeOSLoginManager(const CommandLine& parsed_command_line,
-                                       Profile* profile) {
-  if (parsed_command_line.HasSwitch(switches::kLoginManager)) {
-    std::string first_screen =
-        parsed_command_line.GetSwitchValueASCII(switches::kLoginScreen);
-    std::string size_arg =
-        parsed_command_line.GetSwitchValueASCII(
-            switches::kLoginScreenSize);
-    gfx::Size size(0, 0);
-    // Allow the size of the login window to be set explicitly. If not set,
-    // default to the entire screen. This is mostly useful for testing.
-    if (size_arg.size()) {
-      std::vector<std::string> dimensions;
-      base::SplitString(size_arg, ',', &dimensions);
-      if (dimensions.size() == 2) {
-        int width, height;
-        if (base::StringToInt(dimensions[0], &width) &&
-            base::StringToInt(dimensions[1], &height))
-          size.SetSize(width, height);
-      }
-    }
-    browser::ShowLoginWizard(first_screen, size);
-  } else if (parsed_command_line.HasSwitch(switches::kLoginUser) &&
-      parsed_command_line.HasSwitch(switches::kLoginPassword)) {
-    chromeos::BootTimesLoader::Get()->RecordLoginAttempted();
-    new StubLogin(
-        parsed_command_line.GetSwitchValueASCII(switches::kLoginUser),
-        parsed_command_line.GetSwitchValueASCII(switches::kLoginPassword));
-  } else {
-    if (!parsed_command_line.HasSwitch(switches::kTestName)) {
-      // We did not log in (we crashed or are debugging), so we need to
-      // set the user name for sync.
-      chromeos::LoginUtils::Get()->RestoreAuthenticationSession(
-          chromeos::UserManager::Get()->logged_in_user().email(), profile);
-    }
-  }
-}
-
-#endif  // defined(OS_CHROMEOS)
-
 #if defined(OS_MACOSX)
 OSStatus KeychainCallback(SecKeychainEvent keychain_event,
                           SecKeychainCallbackInfo *info, void *context) {
   return noErr;
 }
 #endif
 
 #if defined(OS_CHROMEOS) && defined(TOOLKIT_USES_GTK)
 void RegisterTranslateableItems(void) {
   struct {
@@ skipping 564 matching lines @@
   SpdyFieldTrial();
   ConnectBackupJobsFieldTrial();
   WarmConnectionFieldTrial();
   PredictorFieldTrial();
   DefaultAppsFieldTrial();
 }
 
 // -----------------------------------------------------------------------------
 // TODO(viettrungluu): move more/rest of BrowserMain() into BrowserMainParts.
 
-#if defined(OS_CHROMEOS)
-// Allows authenticator to be invoked without adding refcounting. The instances
-// will delete themselves upon completion.
-DISABLE_RUNNABLE_METHOD_REFCOUNT(StubLogin);
-#endif
-
 #if defined(OS_WIN)
 #define DLLEXPORT __declspec(dllexport)
 
 // We use extern C for the prototype DLLEXPORT to avoid C++ name mangling.
 extern "C" {
 DLLEXPORT void __cdecl RelaunchChromeBrowserWithNewCommandLineIfNeeded();
 }
 
 DLLEXPORT void __cdecl RelaunchChromeBrowserWithNewCommandLineIfNeeded() {
   // Need an instance of AtExitManager to handle singleton creations and
@@ skipping 31 matching lines @@
     chrome_extra_parts_[i]->PostMainMessageLoopStart();
 }
 
 void ChromeBrowserMainParts::PreMainMessageLoopRun() {
   result_code_ = PreMainMessageLoopRunImpl();
 
   for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
     chrome_extra_parts_[i]->PreMainMessageLoopRun();
 }
 
+void ChromeBrowserMainParts::PostBrowserProcessInit() {
+  for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
+    chrome_extra_parts_[i]->PostBrowserProcessInit();
+}
+
+void ChromeBrowserMainParts::PostProfileInitialized() {
+  for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
+    chrome_extra_parts_[i]->PostProfileInitialized();
+}
+
+void ChromeBrowserMainParts::PreBrowserStart() {
+  for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
+    chrome_extra_parts_[i]->PreBrowserStart();
+}
+
+void ChromeBrowserMainParts::PostBrowserStart() {
+  for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
+    chrome_extra_parts_[i]->PostBrowserStart();
+}
+
 int ChromeBrowserMainParts::PreMainMessageLoopRunImpl() {
   run_message_loop_ = false;
   FilePath user_data_dir;
 #if defined(OS_WIN)
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
 #else
   // Getting the user data dir can fail if the directory isn't
   // creatable, for example; on Windows in code below we bring up a
   // dialog prompting the user to pick a different directory.
   // However, ProcessSingleton needs a real user_data_dir on Mac/Linux,
@@ skipping 189 matching lines @@
   // 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());
 
-#if defined(OS_CHROMEOS)
-  // Now that the file thread exists we can record our stats.
-  chromeos::BootTimesLoader::Get()->RecordChromeMainStats();
-
-#if defined(TOOLKIT_USES_GTK)
-  // 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());
-#else
-  // TODO(saintlou): Need to provide an Aura equivalent.
-  NOTIMPLEMENTED();
-#endif
-
-  // 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
@@ skipping 65 matching lines @@
     }
 #if !defined(OS_MACOSX)  // closing brace for if
   }
 #endif
 
 #if defined(USE_X11)
   SetBrowserX11ErrorHandlers();
 #endif
 
   // Desktop construction occurs here, (required before profile creation).
-  for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
-    chrome_extra_parts_[i]->PostBrowserProcessInit();
+  PostBrowserProcessInit();
 
   // Profile creation ----------------------------------------------------------
 
-#if defined(OS_CHROMEOS)
-  // Initialize the screen locker now so that it can receive
-  // LOGIN_USER_CHANGED notification from UserManager.
-  chromeos::ScreenLocker::InitClass();
-
-  // This forces the ProfileManager to be created and register for the
-  // notification it needs to track the logged in user.
-  g_browser_process->profile_manager();
-
-  // TODO(abarth): Should this move to InitializeNetworkOptions()?
-  // Allow access to file:// on ChromeOS for tests.
-  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)) {
-    std::string username =
-        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());
-
-    // Initialize user policy before creating the profile so the profile
-    // initialization code sees policy settings.
-    g_browser_process->browser_policy_connector()->InitializeUserPolicy(
-        username, false  /* wait_for_policy_fetch */);
-  }
-#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_ = CreateProfile(parameters(), user_data_dir, parsed_command_line());
   if (!profile_)
     return content::RESULT_CODE_NORMAL_EXIT;
 
   // Autoload any profiles which are running background apps.
   // TODO(rlp): Do this on a separate thread. See http://crbug.com/99075.
   if (!BackgroundModeManager::IsBackgroundModePermanentlyDisabled(
       &parsed_command_line())) {
     g_browser_process->profile_manager()->AutoloadProfiles();
   }
   // 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());
-  }
-
-  // Tests should be able to tune login manager before showing it.
-  // Thus only show login manager in normal (non-testing) mode.
-  if (!parameters().ui_task)
-    OptionallyRunChromeOSLoginManager(parsed_command_line(), profile_);
-#endif
-
 #if !defined(OS_MACOSX)
   // Importing other browser settings is done in a browser-like process
   // that exits when this task has finished.
   // TODO(port): Port the Mac's IPC-based implementation to other platforms to
   //             replace this implementation. http://crbug.com/22142
   if (parsed_command_line().HasSwitch(switches::kImport) ||
       parsed_command_line().HasSwitch(switches::kImportFromFile)) {
     return FirstRun::ImportNow(profile_, parsed_command_line());
   }
 #endif
@@ skipping 28 matching lines @@
     if (MaybeInstallFromDiskImage()) {
       // The application was installed and the installed copy has been
       // launched.  This process is now obsolete.  Exit.
       return content::RESULT_CODE_NORMAL_EXIT;
     }
   }
 #endif
 
   // TODO(stevenjb): Move ChromeOS login code into PostProfileInitialized().
   // (Requires making ChromeBrowserMainPartsChromeos a non "main" Parts).
-  for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
-    chrome_extra_parts_[i]->PostProfileInitialized();
+  PostProfileInitialized();
 
   // Show the First Run UI if this is the first time Chrome has been run on
   // this computer, or we're being compelled to do so by a command line flag.
   // Note that this be done _after_ the PrefService is initialized and all
   // preferences are registered, since some of the code that the importer
   // touches reads preferences.
   if (is_first_run) {
     if (!first_run_ui_bypass) {
       FirstRun::AutoImport(profile_,
                            master_prefs_->homepage_defined,
@@ skipping 137 matching lines @@
       profile_->GetPrefs()->GetString(prefs::kAcceptLanguages));
   LanguageUsageMetrics::RecordApplicationLanguage(
       g_browser_process->GetApplicationLocale());
 
 #if defined(OS_WIN)
   fragmentation_checker::RecordFragmentationMetricForCurrentModule();
 #endif
 
 #if defined(OS_CHROMEOS)
   metrics->StartExternalMetrics();
-
-  // Initialize the audio handler on ChromeOS.
-  chromeos::AudioHandler::Initialize();
-
-  // Listen for system key events so that the user will be able to adjust the
-  // volume on the login screen, if Chrome is running on Chrome OS
-  // (i.e. not Linux desktop), and in non-test mode.
-  if (chromeos::system::runtime_environment::IsRunningOnChromeOS() &&
-      !parameters().ui_task) {  // ui_task is non-NULL when running tests.
-    chromeos::SystemKeyEventListener::Initialize();
-  }
-
-  // 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;
     return chrome::RESULT_CODE_UNINSTALL_EXTENSION_ERROR;
   }
 
   // Start watching for a hang.
   MetricsService::LogNeedForCleanShutdown();
 
 #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.
   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)
-  // Wait until here to start the out-of-memory priority manager so that
-  // we give the most amount of time for the other services to start up
-  // before we start adjusting the oom priority.
-  g_browser_process->oom_priority_manager()->Start();
-#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.
   GpuBlacklistUpdater::Setup();
 
   // Start watching all browser threads for responsiveness.
   ThreadWatcherList::StartWatchingAll(parsed_command_line());
 
 #if !defined(DISABLE_NACL)
   NaClProcessHost::EarlyStartup();
 #endif
 
+  PreBrowserStart();
+
   // Instantiate the notification UI manager, as this triggers a perf timer
   // used to measure startup time. TODO(stevenjb): Figure out what is actually
   // triggering the timer and call that explicitly in the approprate place.
   // http://crbug.com/105065.
   g_browser_process->notification_ui_manager();
 
   if (parameters().ui_task) {
     // We are in test mode. Run one task and enter the main message loop.
 #if defined(OS_MACOSX)
     if (parameters().autorelease_pool)
@@ skipping 55 matching lines @@
             profile_->GetPrefs());
       }
 #endif
 
       run_message_loop_ = true;
     } else {
       run_message_loop_ = false;
     }
   }
   browser_init_.reset();
+
+  PostBrowserStart();
+
   return result_code_;
 }
 
 bool ChromeBrowserMainParts::MainMessageLoopRun(int* result_code) {
   // Set the result code set in PreMainMessageLoopRun or set above.
   *result_code = result_code_;
 
   if (!run_message_loop_)
     return true;  // Don't run the default message loop.
 
   // This should be invoked as close to the start of the browser's
   // UI thread message loop as possible to get a stable measurement
   // across versions.
   RecordBrowserStartupTime();
 
 #if defined(USE_AURA)
   aura::Desktop::GetInstance()->Run();
 #elif defined(TOOLKIT_VIEWS)
   views::AcceleratorHandler accelerator_handler;
   MessageLoopForUI::current()->RunWithDispatcher(&accelerator_handler);
 #elif defined(USE_X11)
   MessageLoopForUI::current()->RunWithDispatcher(NULL);
 #elif defined(OS_POSIX)
   MessageLoopForUI::current()->Run();
 #endif
-#if defined(OS_CHROMEOS)
-  chromeos::BootTimesLoader::Get()->AddLogoutTimeMarker("UIMessageLoopEnded",
-                                                        true);
-#endif
 
   return true;
 }
 
 void ChromeBrowserMainParts::PostMainMessageLoopRun() {
   // Start watching for jank during shutdown. It gets disarmed when
   // |shutdown_watcher_| object is destructed.
   shutdown_watcher_->Arm(base::TimeDelta::FromSeconds(90));
 
   // Disarm the startup hang detector time bomb if it is still Arm'ed.
@@ skipping 37 matching lines @@
       }
     } else {
       UMA_HISTOGRAM_ENUMERATION(
           "Chrome.SearchSelectExempt",
           search_engine_type,
           SEARCH_ENGINE_MAX);
     }
   }
 #endif
 
-#if defined(OS_CHROMEOS)
-  g_browser_process->oom_priority_manager()->Stop();
-#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 (notify_result_ == ProcessSingleton::PROCESS_NONE)
     process_singleton_->Cleanup();
 
   // Stop all tasks that might run on WatchDogThread.
   ThreadWatcherList::StopWatchingAll();
 
   g_browser_process->metrics_service()->Stop();
 
-#if defined(OS_CHROMEOS)
-  // The XInput2 event listener needs to be shut down earlier than when
-  // Singletons are finally destroyed in AtExitManager.
-  chromeos::XInputHierarchyChangedEventListener::GetInstance()->Stop();
-
-  // chromeos::SystemKeyEventListener::Shutdown() is always safe to call,
-  // even if Initialize() wasn't called.
-  chromeos::SystemKeyEventListener::Shutdown();
-  chromeos::AudioHandler::Shutdown();
-#endif
-
   // browser_shutdown takes care of deleting browser_process, so we need to
   // release it.
   ignore_result(browser_process_.release());
   browser_shutdown::Shutdown();
   master_prefs_.reset();
   process_singleton_.reset();
 
   // We need to do this check as late as possible, but due to modularity, this
   // may be the last point in Chrome.  This would be more effective if done at
   // a higher level on the stack, so that it is impossible for an early return
@@ skipping 33 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
 }