1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/browser/chromeos/chrome_browser_main_chromeos.h" 6 7 #include <string> 8 #include <vector> 9 10 #include "ash/ash_switches.h" 11 #include "ash/shell.h" 12 #include "base/bind.h" 13 #include "base/callback.h" 14 #include "base/command_line.h" 15 #include "base/file_util.h" 16 #include "base/lazy_instance.h" 17 #include "base/linux_util.h" 18 #include "base/path_service.h" 19 #include "base/prefs/pref_service.h" 20 #include "base/strings/string_number_conversions.h" 21 #include "base/strings/string_split.h" 22 #include "base/sys_info.h" 23 #include "chrome/browser/browser_process.h" 24 #include "chrome/browser/browser_process_platform_part_chromeos.h" 25 #include "chrome/browser/chrome_notification_types.h" 26 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h" 27 #include "chrome/browser/chromeos/accessibility/magnification_manager.h" 28 #include "chrome/browser/chromeos/app_mode/kiosk_app_launch_error.h" 29 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h" 30 #include "chrome/browser/chromeos/app_mode/kiosk_mode_idle_app_name_notification.h" 31 #include "chrome/browser/chromeos/boot_times_loader.h" 32 #include "chrome/browser/chromeos/dbus/cros_dbus_service.h" 33 #include "chrome/browser/chromeos/device/input_service_proxy.h" 34 #include "chrome/browser/chromeos/events/event_rewriter.h" 35 #include "chrome/browser/chromeos/events/event_rewriter_controller.h" 36 #include "chrome/browser/chromeos/events/keyboard_driven_event_rewriter.h" 37 #include "chrome/browser/chromeos/extensions/default_app_order.h" 38 #include "chrome/browser/chromeos/extensions/extension_system_event_observer.h" 39 #include "chrome/browser/chromeos/external_metrics.h" 40 #include "chrome/browser/chromeos/imageburner/burn_manager.h" 41 #include "chrome/browser/chromeos/input_method/input_method_configuration.h" 42 #include "chrome/browser/chromeos/input_method/input_method_util.h" 43 #include "chrome/browser/chromeos/kiosk_mode/kiosk_mode_idle_logout.h" 44 #include "chrome/browser/chromeos/kiosk_mode/kiosk_mode_screensaver.h" 45 #include "chrome/browser/chromeos/kiosk_mode/kiosk_mode_settings.h" 46 #include "chrome/browser/chromeos/language_preferences.h" 47 #include "chrome/browser/chromeos/login/auth/authenticator.h" 48 #include "chrome/browser/chromeos/login/auth/key.h" 49 #include "chrome/browser/chromeos/login/auth/user_context.h" 50 #include "chrome/browser/chromeos/login/helper.h" 51 #include "chrome/browser/chromeos/login/lock/screen_locker.h" 52 #include "chrome/browser/chromeos/login/login_utils.h" 53 #include "chrome/browser/chromeos/login/login_wizard.h" 54 #include "chrome/browser/chromeos/login/session/session_manager.h" 55 #include "chrome/browser/chromeos/login/startup_utils.h" 56 #include "chrome/browser/chromeos/login/users/user.h" 57 #include "chrome/browser/chromeos/login/users/user_manager.h" 58 #include "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h" 59 #include "chrome/browser/chromeos/login/wizard_controller.h" 60 #include "chrome/browser/chromeos/memory/oom_priority_manager.h" 61 #include "chrome/browser/chromeos/net/network_portal_detector.h" 62 #include "chrome/browser/chromeos/options/cert_library.h" 63 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h" 64 #include "chrome/browser/chromeos/policy/device_local_account.h" 65 #include "chrome/browser/chromeos/power/idle_action_warning_observer.h" 66 #include "chrome/browser/chromeos/power/peripheral_battery_observer.h" 67 #include "chrome/browser/chromeos/power/power_button_observer.h" 68 #include "chrome/browser/chromeos/power/power_data_collector.h" 69 #include "chrome/browser/chromeos/power/power_prefs.h" 70 #include "chrome/browser/chromeos/profiles/profile_helper.h" 71 #include "chrome/browser/chromeos/settings/device_oauth2_token_service_factory.h" 72 #include "chrome/browser/chromeos/settings/device_settings_service.h" 73 #include "chrome/browser/chromeos/settings/owner_key_util.h" 74 #include "chrome/browser/chromeos/status/data_promo_notification.h" 75 #include "chrome/browser/chromeos/system/input_device_settings.h" 76 #include "chrome/browser/chromeos/upgrade_detector_chromeos.h" 77 #include "chrome/browser/defaults.h" 78 #include "chrome/browser/lifetime/application_lifetime.h" 79 #include "chrome/browser/net/chrome_network_delegate.h" 80 #include "chrome/browser/profiles/profile.h" 81 #include "chrome/browser/profiles/profile_manager.h" 82 #include "chrome/browser/rlz/rlz.h" 83 #include "chrome/common/chrome_constants.h" 84 #include "chrome/common/chrome_paths.h" 85 #include "chrome/common/chrome_switches.h" 86 #include "chrome/common/chrome_version_info.h" 87 #include "chrome/common/logging_chrome.h" 88 #include "chrome/common/pref_names.h" 89 #include "chromeos/audio/audio_devices_pref_handler.h" 90 #include "chromeos/audio/cras_audio_handler.h" 91 #include "chromeos/cert_loader.h" 92 #include "chromeos/chromeos_paths.h" 93 #include "chromeos/chromeos_switches.h" 94 #include "chromeos/cryptohome/async_method_caller.h" 95 #include "chromeos/cryptohome/homedir_methods.h" 96 #include "chromeos/cryptohome/system_salt_getter.h" 97 #include "chromeos/dbus/dbus_thread_manager.h" 98 #include "chromeos/dbus/power_policy_controller.h" 99 #include "chromeos/dbus/session_manager_client.h" 100 #include "chromeos/disks/disk_mount_manager.h" 101 #include "chromeos/ime/ime_keyboard.h" 102 #include "chromeos/ime/input_method_manager.h" 103 #include "chromeos/login/login_state.h" 104 #include "chromeos/network/network_change_notifier_chromeos.h" 105 #include "chromeos/network/network_change_notifier_factory_chromeos.h" 106 #include "chromeos/network/network_handler.h" 107 #include "chromeos/system/statistics_provider.h" 108 #include "chromeos/tpm_token_loader.h" 109 #include "components/metrics/metrics_service.h" 110 #include "content/public/browser/browser_thread.h" 111 #include "content/public/browser/notification_service.h" 112 #include "content/public/browser/power_save_blocker.h" 113 #include "content/public/common/main_function_params.h" 114 #include "grit/platform_locale_settings.h" 115 #include "media/audio/sounds/sounds_manager.h" 116 #include "net/base/network_change_notifier.h" 117 #include "net/url_request/url_request.h" 118 #include "net/url_request/url_request_context_getter.h" 119 #include "ui/base/touch/touch_device.h" 120 #include "ui/events/event_utils.h" 121 122 // Exclude X11 dependents for ozone 123 #if defined(USE_X11) 124 #include "chrome/browser/chromeos/device_uma.h" 125 #include "chrome/browser/chromeos/events/system_key_event_listener.h" 126 #include "chrome/browser/chromeos/events/xinput_hierarchy_changed_event_listener.h" 127 #endif 128 129 namespace chromeos { 130 131 namespace { 132 133 void ChromeOSVersionCallback(const std::string& version) { 134 base::SetLinuxDistro(std::string("CrOS ") + version); 135 } 136 137 // Login ----------------------------------------------------------------------- 138 139 // Class is used to login using passed username and password. 140 // The instance will be deleted upon success or failure. 141 class StubLogin : public LoginStatusConsumer, 142 public LoginUtils::Delegate { 143 public: 144 StubLogin(std::string username, std::string password) 145 : profile_prepared_(false) { 146 authenticator_ = LoginUtils::Get()->CreateAuthenticator(this); 147 UserContext user_context(username); 148 user_context.SetKey(Key(password)); 149 authenticator_.get()->AuthenticateToLogin(ProfileHelper::GetSigninProfile(), 150 user_context); 151 } 152 153 virtual ~StubLogin() { 154 LoginUtils::Get()->DelegateDeleted(this); 155 } 156 157 virtual void OnLoginFailure(const LoginFailure& error) OVERRIDE { 158 LOG(ERROR) << "Login Failure: " << error.GetErrorString(); 159 delete this; 160 } 161 162 virtual void OnLoginSuccess(const UserContext& user_context) OVERRIDE { 163 if (!profile_prepared_) { 164 // Will call OnProfilePrepared in the end. 165 LoginUtils::Get()->PrepareProfile(user_context, 166 false, // has_cookies 167 true, // has_active_session 168 this); 169 } else { 170 delete this; 171 } 172 } 173 174 // LoginUtils::Delegate implementation: 175 virtual void OnProfilePrepared(Profile* profile) OVERRIDE { 176 const std::string login_user = login::CanonicalizeUserID( 177 CommandLine::ForCurrentProcess()->GetSwitchValueASCII( 178 switches::kLoginUser)); 179 if (!policy::IsDeviceLocalAccountUser(login_user, NULL)) { 180 profile->GetPrefs()->SetString(prefs::kGoogleServicesUsername, 181 login_user); 182 } 183 profile_prepared_ = true; 184 LoginUtils::Get()->DoBrowserLaunch(profile, NULL); 185 delete this; 186 } 187 188 scoped_refptr<Authenticator> authenticator_; 189 bool profile_prepared_; 190 }; 191 192 bool ShouldAutoLaunchKioskApp(const CommandLine& command_line) { 193 KioskAppManager* app_manager = KioskAppManager::Get(); 194 return command_line.HasSwitch(switches::kLoginManager) && 195 !command_line.HasSwitch(switches::kForceLoginManagerInTests) && 196 app_manager->IsAutoLaunchEnabled() && 197 KioskAppLaunchError::Get() == KioskAppLaunchError::NONE; 198 } 199 200 void RunAutoLaunchKioskApp() { 201 ShowLoginWizard(chromeos::WizardController::kAppLaunchSplashScreenName); 202 203 // Login screen is skipped but 'login-prompt-visible' signal is still needed. 204 VLOG(1) << "Kiosk app auto launch >> login-prompt-visible"; 205 DBusThreadManager::Get()->GetSessionManagerClient()-> 206 EmitLoginPromptVisible(); 207 } 208 209 void OptionallyRunChromeOSLoginManager(const CommandLine& parsed_command_line, 210 Profile* profile) { 211 if (ShouldAutoLaunchKioskApp(parsed_command_line)) { 212 RunAutoLaunchKioskApp(); 213 } else if (parsed_command_line.HasSwitch(switches::kLoginManager)) { 214 ShowLoginWizard(std::string()); 215 216 if (KioskModeSettings::Get()->IsKioskModeEnabled()) 217 InitializeKioskModeScreensaver(); 218 219 // Reset reboot after update flag when login screen is shown. 220 policy::BrowserPolicyConnectorChromeOS* connector = 221 g_browser_process->platform_part()->browser_policy_connector_chromeos(); 222 if (!connector->IsEnterpriseManaged()) { 223 PrefService* local_state = g_browser_process->local_state(); 224 local_state->ClearPref(prefs::kRebootAfterUpdate); 225 } 226 } else if (parsed_command_line.HasSwitch(switches::kLoginUser) && 227 parsed_command_line.HasSwitch(switches::kLoginPassword)) { 228 BootTimesLoader::Get()->RecordLoginAttempted(); 229 new StubLogin( 230 parsed_command_line.GetSwitchValueASCII(switches::kLoginUser), 231 parsed_command_line.GetSwitchValueASCII(switches::kLoginPassword)); 232 } else { 233 if (!parsed_command_line.HasSwitch(::switches::kTestName)) { 234 // Enable CrasAudioHandler logging when chrome restarts after crashing. 235 if (chromeos::CrasAudioHandler::IsInitialized()) 236 chromeos::CrasAudioHandler::Get()->LogErrors(); 237 238 // We did not log in (we crashed or are debugging), so we need to 239 // restore Sync. 240 SessionManager::GetInstance()->RestoreAuthenticationSession(profile); 241 } 242 } 243 } 244 245 } // namespace 246 247 namespace internal { 248 249 // Wrapper class for initializing dbus related services and shutting them 250 // down. This gets instantiated in a scoped_ptr so that shutdown methods in the 251 // destructor will get called if and only if this has been instantiated. 252 class DBusServices { 253 public: 254 explicit DBusServices(const content::MainFunctionParams& parameters) { 255 // Initialize DBusThreadManager for the browser. This must be done after 256 // the main message loop is started, as it uses the message loop. 257 DBusThreadManager::Initialize(); 258 CrosDBusService::Initialize(); 259 260 // Initialize PowerDataCollector after DBusThreadManager is initialized. 261 PowerDataCollector::Initialize(); 262 263 LoginState::Initialize(); 264 SystemSaltGetter::Initialize(); 265 TPMTokenLoader::Initialize(); 266 CertLoader::Initialize(); 267 268 // This function and SystemKeyEventListener use InputMethodManager. 269 chromeos::input_method::Initialize( 270 content::BrowserThread::GetMessageLoopProxyForThread( 271 content::BrowserThread::UI), 272 content::BrowserThread::GetMessageLoopProxyForThread( 273 content::BrowserThread::FILE)); 274 disks::DiskMountManager::Initialize(); 275 cryptohome::AsyncMethodCaller::Initialize(); 276 cryptohome::HomedirMethods::Initialize(); 277 278 NetworkHandler::Initialize(); 279 CertLibrary::Initialize(); 280 281 // Initialize the network change notifier for Chrome OS. The network 282 // change notifier starts to monitor changes from the power manager and 283 // the network manager. 284 NetworkChangeNotifierFactoryChromeos::GetInstance()->Initialize(); 285 286 // Likewise, initialize the upgrade detector for Chrome OS. The upgrade 287 // detector starts to monitor changes from the update engine. 288 UpgradeDetectorChromeos::GetInstance()->Init(); 289 290 if (base::SysInfo::IsRunningOnChromeOS()) { 291 // Disable Num Lock on X start up for http://crosbug.com/29169. 292 input_method::InputMethodManager::Get() 293 ->GetImeKeyboard() 294 ->DisableNumLock(); 295 } 296 297 // Initialize the device settings service so that we'll take actions per 298 // signals sent from the session manager. This needs to happen before 299 // g_browser_process initializes BrowserPolicyConnector. 300 DeviceSettingsService::Initialize(); 301 DeviceSettingsService::Get()->SetSessionManager( 302 DBusThreadManager::Get()->GetSessionManagerClient(), 303 OwnerKeyUtil::Create()); 304 } 305 306 ~DBusServices() { 307 CertLibrary::Shutdown(); 308 NetworkHandler::Shutdown(); 309 310 cryptohome::AsyncMethodCaller::Shutdown(); 311 disks::DiskMountManager::Shutdown(); 312 input_method::Shutdown(); 313 314 SystemSaltGetter::Shutdown(); 315 LoginState::Shutdown(); 316 CertLoader::Shutdown(); 317 TPMTokenLoader::Shutdown(); 318 319 CrosDBusService::Shutdown(); 320 321 // Shutdown the PowerDataCollector before shutting down DBusThreadManager. 322 PowerDataCollector::Shutdown(); 323 324 // NOTE: This must only be called if Initialize() was called. 325 DBusThreadManager::Shutdown(); 326 } 327 328 private: 329 330 DISALLOW_COPY_AND_ASSIGN(DBusServices); 331 }; 332 333 } // namespace internal 334 335 // ChromeBrowserMainPartsChromeos ---------------------------------------------- 336 337 ChromeBrowserMainPartsChromeos::ChromeBrowserMainPartsChromeos( 338 const content::MainFunctionParams& parameters) 339 : ChromeBrowserMainPartsLinux(parameters) { 340 } 341 342 ChromeBrowserMainPartsChromeos::~ChromeBrowserMainPartsChromeos() { 343 if (KioskModeSettings::Get()->IsKioskModeEnabled()) 344 ShutdownKioskModeScreensaver(); 345 346 // To be precise, logout (browser shutdown) is not yet done, but the 347 // remaining work is negligible, hence we say LogoutDone here. 348 BootTimesLoader::Get()->AddLogoutTimeMarker("LogoutDone", false); 349 BootTimesLoader::Get()->WriteLogoutTimes(); 350 } 351 352 // content::BrowserMainParts and ChromeBrowserMainExtraParts overrides --------- 353 354 void ChromeBrowserMainPartsChromeos::PreEarlyInitialization() { 355 CommandLine* singleton_command_line = CommandLine::ForCurrentProcess(); 356 357 if (parsed_command_line().HasSwitch(switches::kGuestSession)) { 358 // Disable sync and extensions if we're in "browse without sign-in" mode. 359 singleton_command_line->AppendSwitch(::switches::kDisableSync); 360 singleton_command_line->AppendSwitch(::switches::kDisableExtensions); 361 browser_defaults::bookmarks_enabled = false; 362 } 363 364 // If we're not running on real Chrome OS hardware (or under VM), and are not 365 // showing the login manager or attempting a command line login, login with a 366 // stub user. 367 if (!base::SysInfo::IsRunningOnChromeOS() && 368 !parsed_command_line().HasSwitch(switches::kLoginManager) && 369 !parsed_command_line().HasSwitch(switches::kLoginUser) && 370 !parsed_command_line().HasSwitch(switches::kGuestSession)) { 371 singleton_command_line->AppendSwitchASCII( 372 switches::kLoginUser, UserManager::kStubUser); 373 if (!parsed_command_line().HasSwitch(switches::kLoginProfile)) { 374 singleton_command_line->AppendSwitchASCII(switches::kLoginProfile, 375 chrome::kTestUserProfileDir); 376 } 377 LOG(WARNING) << "Running as stub user with profile dir: " 378 << singleton_command_line->GetSwitchValuePath( 379 switches::kLoginProfile).value(); 380 } 381 382 #if defined(GOOGLE_CHROME_BUILD) 383 const char kChromeOSReleaseTrack[] = "CHROMEOS_RELEASE_TRACK"; 384 std::string channel; 385 if (base::SysInfo::GetLsbReleaseValue(kChromeOSReleaseTrack, &channel)) 386 chrome::VersionInfo::SetChannel(channel); 387 #endif 388 389 ChromeBrowserMainPartsLinux::PreEarlyInitialization(); 390 } 391 392 void ChromeBrowserMainPartsChromeos::PreMainMessageLoopStart() { 393 // Replace the default NetworkChangeNotifierFactory with ChromeOS specific 394 // implementation. This must be done before BrowserMainLoop calls 395 // net::NetworkChangeNotifier::Create() in MainMessageLoopStart(). 396 net::NetworkChangeNotifier::SetFactory( 397 new NetworkChangeNotifierFactoryChromeos()); 398 ChromeBrowserMainPartsLinux::PreMainMessageLoopStart(); 399 } 400 401 void ChromeBrowserMainPartsChromeos::PostMainMessageLoopStart() { 402 base::FilePath user_data_dir; 403 if (!base::SysInfo::IsRunningOnChromeOS() && 404 PathService::Get(chrome::DIR_USER_DATA, &user_data_dir)) { 405 // Override some paths with stub locations so that cloud policy and 406 // enterprise enrollment work on desktop builds, for ease of 407 // development. 408 chromeos::RegisterStubPathOverrides(user_data_dir); 409 } 410 411 dbus_services_.reset(new internal::DBusServices(parameters())); 412 413 ChromeBrowserMainPartsLinux::PostMainMessageLoopStart(); 414 } 415 416 // Threads are initialized between MainMessageLoopStart and MainMessageLoopRun. 417 // about_flags settings are applied in ChromeBrowserMainParts::PreCreateThreads. 418 void ChromeBrowserMainPartsChromeos::PreMainMessageLoopRun() { 419 // Set the crypto thread after the IO thread has been created/started. 420 TPMTokenLoader::Get()->SetCryptoTaskRunner( 421 content::BrowserThread::GetMessageLoopProxyForThread( 422 content::BrowserThread::IO)); 423 424 CrasAudioHandler::Initialize( 425 AudioDevicesPrefHandler::Create(g_browser_process->local_state())); 426 427 // Start loading machine statistics here. StatisticsProvider::Shutdown() 428 // will ensure that loading is aborted on early exit. 429 bool load_oem_statistics = !StartupUtils::IsOobeCompleted(); 430 system::StatisticsProvider::GetInstance()->StartLoadingMachineStatistics( 431 content::BrowserThread::GetMessageLoopProxyForThread( 432 content::BrowserThread::FILE), 433 load_oem_statistics); 434 435 base::FilePath downloads_directory; 436 CHECK(PathService::Get(chrome::DIR_DEFAULT_DOWNLOADS, &downloads_directory)); 437 imageburner::BurnManager::Initialize( 438 downloads_directory, g_browser_process->system_request_context()); 439 440 DeviceOAuth2TokenServiceFactory::Initialize(); 441 442 ChromeBrowserMainPartsLinux::PreMainMessageLoopRun(); 443 } 444 445 void ChromeBrowserMainPartsChromeos::PreProfileInit() { 446 // -- This used to be in ChromeBrowserMainParts::PreMainMessageLoopRun() 447 // -- immediately before Profile creation(). 448 449 // Now that the file thread exists we can record our stats. 450 BootTimesLoader::Get()->RecordChromeMainStats(); 451 452 // Trigger prefetching of ownership status. 453 DeviceSettingsService::Get()->Load(); 454 455 // -- This used to be in ChromeBrowserMainParts::PreMainMessageLoopRun() 456 // -- just before CreateProfile(). 457 458 UserManager::Initialize(); 459 460 // Initialize the screen locker now so that it can receive 461 // LOGIN_USER_CHANGED notification from UserManager. 462 if (KioskModeSettings::Get()->IsKioskModeEnabled()) 463 KioskModeIdleLogout::Initialize(); 464 else 465 ScreenLocker::InitClass(); 466 467 // This forces the ProfileManager to be created and register for the 468 // notification it needs to track the logged in user. 469 g_browser_process->profile_manager(); 470 471 // ProfileHelper has to be initialized after UserManager instance is created. 472 g_browser_process->platform_part()->profile_helper()->Initialize(); 473 474 // TODO(abarth): Should this move to InitializeNetworkOptions()? 475 // Allow access to file:// on ChromeOS for tests. 476 if (parsed_command_line().HasSwitch(::switches::kAllowFileAccess)) 477 ChromeNetworkDelegate::AllowAccessToAllFiles(); 478 479 // There are two use cases for kLoginUser: 480 // 1) if passed in tandem with kLoginPassword, to drive a "StubLogin" 481 // 2) if passed alone, to signal that the indicated user has already 482 // logged in and we should behave accordingly. 483 // This handles case 2. 484 bool immediate_login = 485 parsed_command_line().HasSwitch(switches::kLoginUser) && 486 !parsed_command_line().HasSwitch(switches::kLoginPassword); 487 if (immediate_login){ 488 // Redirects Chrome logging to the user data dir. 489 logging::RedirectChromeLogging(parsed_command_line()); 490 491 // Load the default app order synchronously for restarting case. 492 app_order_loader_.reset( 493 new default_app_order::ExternalLoader(false /* async */)); 494 } 495 496 if (!app_order_loader_) { 497 app_order_loader_.reset( 498 new default_app_order::ExternalLoader(true /* async */)); 499 } 500 501 media::SoundsManager::Create(); 502 503 // Initialize magnification manager before ash tray is created. And this must 504 // be placed after UserManager::SessionStarted(); 505 AccessibilityManager::Initialize(); 506 MagnificationManager::Initialize(); 507 508 // Add observers for WallpaperManager. This depends on PowerManagerClient, 509 // TimezoneSettings and CrosSettings. 510 WallpaperManager::Get()->AddObservers(); 511 512 cros_version_loader_.GetVersion(VersionLoader::VERSION_FULL, 513 base::Bind(&ChromeOSVersionCallback), 514 &tracker_); 515 516 // Make sure that wallpaper boot transition and other delays in OOBE 517 // are disabled for tests and kiosk app launch by default. 518 // Individual tests may enable them if they want. 519 if (parsed_command_line().HasSwitch(::switches::kTestType) || 520 ShouldAutoLaunchKioskApp(parsed_command_line())) { 521 WizardController::SetZeroDelays(); 522 } 523 524 power_prefs_.reset(new PowerPrefs( 525 DBusThreadManager::Get()->GetPowerPolicyController())); 526 527 // In Aura builds this will initialize ash::Shell. 528 ChromeBrowserMainPartsLinux::PreProfileInit(); 529 530 if (immediate_login) { 531 const std::string user_id = login::CanonicalizeUserID( 532 parsed_command_line().GetSwitchValueASCII(switches::kLoginUser)); 533 UserManager* user_manager = UserManager::Get(); 534 535 if (policy::IsDeviceLocalAccountUser(user_id, NULL) && 536 !user_manager->IsKnownUser(user_id)) { 537 // When a device-local account is removed, its policy is deleted from disk 538 // immediately. If a session using this account happens to be in progress, 539 // the session is allowed to continue with policy served from an in-memory 540 // cache. If Chrome crashes later in the session, the policy becomes 541 // completely unavailable. Exit the session in that case, rather than 542 // allowing it to continue without policy. 543 chrome::AttemptUserExit(); 544 return; 545 } 546 547 // In case of multi-profiles --login-profile will contain user_id_hash. 548 std::string user_id_hash = 549 parsed_command_line().GetSwitchValueASCII(switches::kLoginProfile); 550 user_manager->UserLoggedIn(user_id, user_id_hash, true); 551 VLOG(1) << "Relaunching browser for user: " << user_id 552 << " with hash: " << user_id_hash; 553 } 554 } 555 556 class GuestLanguageSetCallbackData { 557 public: 558 explicit GuestLanguageSetCallbackData(Profile* profile) : profile(profile) { 559 } 560 561 // Must match SwitchLanguageCallback type. 562 static void Callback(const scoped_ptr<GuestLanguageSetCallbackData>& self, 563 const std::string& locale, 564 const std::string& loaded_locale, 565 bool success); 566 567 Profile* profile; 568 }; 569 570 // static 571 void GuestLanguageSetCallbackData::Callback( 572 const scoped_ptr<GuestLanguageSetCallbackData>& self, 573 const std::string& locale, 574 const std::string& loaded_locale, 575 bool success) { 576 input_method::InputMethodManager* const ime_manager = 577 input_method::InputMethodManager::Get(); 578 // Active layout must be hardware "login layout". 579 // The previous one must be "locale default layout". 580 // First, enable all hardware input methods. 581 const std::vector<std::string>& input_methods = 582 ime_manager->GetInputMethodUtil()->GetHardwareInputMethodIds(); 583 for (size_t i = 0; i < input_methods.size(); ++i) 584 ime_manager->EnableInputMethod(input_methods[i]); 585 586 // Second, enable locale based input methods. 587 const std::string locale_default_input_method = 588 ime_manager->GetInputMethodUtil()-> 589 GetLanguageDefaultInputMethodId(loaded_locale); 590 if (!locale_default_input_method.empty()) { 591 PrefService* user_prefs = self->profile->GetPrefs(); 592 user_prefs->SetString(prefs::kLanguagePreviousInputMethod, 593 locale_default_input_method); 594 ime_manager->EnableInputMethod(locale_default_input_method); 595 } 596 597 // Finally, activate the first login input method. 598 const std::vector<std::string>& login_input_methods = 599 ime_manager->GetInputMethodUtil()->GetHardwareLoginInputMethodIds(); 600 ime_manager->ChangeInputMethod(login_input_methods[0]); 601 } 602 603 void SetGuestLocale(UserManager* const usermanager, Profile* const profile) { 604 scoped_ptr<GuestLanguageSetCallbackData> data( 605 new GuestLanguageSetCallbackData(profile)); 606 scoped_ptr<locale_util::SwitchLanguageCallback> callback( 607 new locale_util::SwitchLanguageCallback(base::Bind( 608 &GuestLanguageSetCallbackData::Callback, base::Passed(data.Pass())))); 609 User* const user = usermanager->GetUserByProfile(profile); 610 usermanager->RespectLocalePreference(profile, user, callback.Pass()); 611 } 612 613 void ChromeBrowserMainPartsChromeos::PostProfileInit() { 614 // -- This used to be in ChromeBrowserMainParts::PreMainMessageLoopRun() 615 // -- just after CreateProfile(). 616 617 BootTimesLoader::Get()->OnChromeProcessStart(); 618 619 // Restarting Chrome inside existing user session. Possible cases: 620 // 1. Chrome is restarted after crash. 621 // 2. Chrome is started in browser_tests skipping the login flow 622 // 3. Chrome is started on dev machine 623 // i.e. not on Chrome OS device w/o login flow. 624 if (parsed_command_line().HasSwitch(switches::kLoginUser) && 625 !parsed_command_line().HasSwitch(switches::kLoginPassword)) { 626 std::string login_user = login::CanonicalizeUserID( 627 parsed_command_line().GetSwitchValueASCII( 628 chromeos::switches::kLoginUser)); 629 if (!base::SysInfo::IsRunningOnChromeOS() && 630 login_user == UserManager::kStubUser) { 631 // For dev machines and stub user emulate as if sync has been initialized. 632 profile()->GetPrefs()->SetString(prefs::kGoogleServicesUsername, 633 login_user); 634 } 635 636 // This is done in SessionManager::OnProfileCreated during normal login. 637 SessionManager::GetInstance()->InitRlz(profile()); 638 639 // Send the PROFILE_PREPARED notification and call SessionStarted() 640 // so that the Launcher and other Profile dependent classes are created. 641 content::NotificationService::current()->Notify( 642 chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED, 643 content::NotificationService::AllSources(), 644 content::Details<Profile>(profile())); 645 UserManager::Get()->SessionStarted(); 646 647 // Now is the good time to retrieve other logged in users for this session. 648 // First user has been already marked as logged in and active in 649 // PreProfileInit(). Chrome should tread other user in a session as active 650 // in the background. 651 UserManager::Get()->RestoreActiveSessions(); 652 } 653 654 // Initialize the network portal detector for Chrome OS. The network 655 // portal detector starts to listen for notifications from 656 // NetworkStateHandler and initiates captive portal detection for 657 // active networks. Shoule be called before call to 658 // OptionallyRunChromeOSLoginManager, because it depends on 659 // NetworkPortalDetector. 660 NetworkPortalDetector::Initialize(); 661 { 662 NetworkPortalDetector* detector = NetworkPortalDetector::Get(); 663 #if defined(GOOGLE_CHROME_BUILD) 664 bool is_official_build = true; 665 #else 666 bool is_official_build = false; 667 #endif 668 // Enable portal detector if EULA was previously accepted or if 669 // this is an unofficial build. 670 if (!is_official_build || StartupUtils::IsEulaAccepted()) 671 detector->Enable(true); 672 } 673 674 // Tests should be able to tune login manager before showing it. 675 // Thus only show login manager in normal (non-testing) mode. 676 if (!parameters().ui_task || 677 parsed_command_line().HasSwitch(switches::kForceLoginManagerInTests)) { 678 OptionallyRunChromeOSLoginManager(parsed_command_line(), profile()); 679 } 680 681 // Guest user profile is never initialized with locale settings, 682 // so we need special handling for Guest session. 683 UserManager* const usermanager = UserManager::Get(); 684 if (usermanager->IsLoggedInAsGuest()) 685 SetGuestLocale(usermanager, profile()); 686 687 // These observers must be initialized after the profile because 688 // they use the profile to dispatch extension events. 689 extension_system_event_observer_.reset(new ExtensionSystemEventObserver()); 690 if (KioskModeSettings::Get()->IsKioskModeEnabled()) { 691 retail_mode_power_save_blocker_ = content::PowerSaveBlocker::Create( 692 content::PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep, 693 "Retail mode"); 694 } 695 696 peripheral_battery_observer_.reset(new PeripheralBatteryObserver()); 697 698 g_browser_process->platform_part()->InitializeAutomaticRebootManager(); 699 700 // This observer cannot be created earlier because it requires the shell to be 701 // available. 702 idle_action_warning_observer_.reset(new IdleActionWarningObserver()); 703 704 ChromeBrowserMainPartsLinux::PostProfileInit(); 705 } 706 707 void ChromeBrowserMainPartsChromeos::PreBrowserStart() { 708 // -- This used to be in ChromeBrowserMainParts::PreMainMessageLoopRun() 709 // -- just before MetricsService::LogNeedForCleanShutdown(). 710 711 // Start the external metrics service, which collects metrics from Chrome OS 712 // and passes them to the browser process. 713 external_metrics_ = new chromeos::ExternalMetrics; 714 external_metrics_->Start(); 715 716 #if defined(USE_X11) 717 // Listen for system key events so that the user will be able to adjust the 718 // volume on the login screen, if Chrome is running on Chrome OS 719 // (i.e. not Linux desktop), and in non-test mode. 720 // Note: SystemKeyEventListener depends on the DBus thread. 721 if (base::SysInfo::IsRunningOnChromeOS() && 722 !parameters().ui_task) { // ui_task is non-NULL when running tests. 723 SystemKeyEventListener::Initialize(); 724 } 725 726 // Listen for XI_HierarchyChanged events. Note: if this is moved to 727 // PreMainMessageLoopRun() then desktopui_PageCyclerTests fail for unknown 728 // reasons, see http://crosbug.com/24833. 729 XInputHierarchyChangedEventListener::GetInstance(); 730 731 // Start the CrOS input device UMA watcher 732 DeviceUMA::GetInstance(); 733 #endif 734 keyboard_event_rewriters_.reset(new EventRewriterController()); 735 keyboard_event_rewriters_->AddEventRewriter( 736 scoped_ptr<ui::EventRewriter>(new KeyboardDrivenEventRewriter())); 737 keyboard_event_rewriters_->AddEventRewriter( 738 scoped_ptr<ui::EventRewriter>(new EventRewriter())); 739 740 // -- This used to be in ChromeBrowserMainParts::PreMainMessageLoopRun() 741 // -- immediately after ChildProcess::WaitForDebugger(). 742 743 // Start the out-of-memory priority manager here so that we give the most 744 // amount of time for the other services to start up before we start 745 // adjusting the oom priority. 746 g_browser_process->platform_part()->oom_priority_manager()->Start(); 747 748 if (ui::ShouldDefaultToNaturalScroll()) { 749 CommandLine::ForCurrentProcess()->AppendSwitch( 750 chromeos::switches::kNaturalScrollDefault); 751 system::InputDeviceSettings::Get()->SetTapToClick(true); 752 } 753 754 ChromeBrowserMainPartsLinux::PreBrowserStart(); 755 } 756 757 void ChromeBrowserMainPartsChromeos::PostBrowserStart() { 758 // These are dependent on the ash::Shell singleton already having been 759 // initialized. 760 power_button_observer_.reset(new PowerButtonObserver); 761 data_promo_notification_.reset(new DataPromoNotification()), 762 keyboard_event_rewriters_->Init(); 763 764 ChromeBrowserMainPartsLinux::PostBrowserStart(); 765 } 766 767 // Shut down services before the browser process, etc are destroyed. 768 void ChromeBrowserMainPartsChromeos::PostMainMessageLoopRun() { 769 BootTimesLoader::Get()->AddLogoutTimeMarker("UIMessageLoopEnded", true); 770 771 g_browser_process->platform_part()->oom_priority_manager()->Stop(); 772 773 // Early wake-up of HID device service. 774 InputServiceProxy::WarmUp(); 775 776 // Destroy the application name notifier for Kiosk mode. 777 KioskModeIdleAppNameNotification::Shutdown(); 778 779 // Shutdown the upgrade detector for Chrome OS. The upgrade detector 780 // stops monitoring changes from the update engine. 781 if (UpgradeDetectorChromeos::GetInstance()) 782 UpgradeDetectorChromeos::GetInstance()->Shutdown(); 783 784 // Shutdown the network change notifier for Chrome OS. The network 785 // change notifier stops monitoring changes from the power manager and 786 // the network manager. 787 if (NetworkChangeNotifierFactoryChromeos::GetInstance()) 788 NetworkChangeNotifierFactoryChromeos::GetInstance()->Shutdown(); 789 790 // Destroy UI related classes before destroying services that they may 791 // depend on. 792 data_promo_notification_.reset(); 793 794 // Tell DeviceSettingsService to stop talking to session_manager. Do not 795 // shutdown DeviceSettingsService yet, it might still be accessed by 796 // BrowserPolicyConnector (owned by g_browser_process). 797 DeviceSettingsService::Get()->UnsetSessionManager(); 798 799 // We should remove observers attached to D-Bus clients before 800 // DBusThreadManager is shut down. 801 extension_system_event_observer_.reset(); 802 retail_mode_power_save_blocker_.reset(); 803 peripheral_battery_observer_.reset(); 804 power_prefs_.reset(); 805 806 // Let the ScreenLocker unregister itself from SessionManagerClient before 807 // DBusThreadManager is shut down. 808 if (!KioskModeSettings::Get()->IsKioskModeEnabled()) 809 ScreenLocker::ShutDownClass(); 810 811 keyboard_event_rewriters_.reset(); 812 #if defined(USE_X11) 813 // The XInput2 event listener needs to be shut down earlier than when 814 // Singletons are finally destroyed in AtExitManager. 815 XInputHierarchyChangedEventListener::GetInstance()->Stop(); 816 817 DeviceUMA::GetInstance()->Stop(); 818 819 // SystemKeyEventListener::Shutdown() is always safe to call, 820 // even if Initialize() wasn't called. 821 SystemKeyEventListener::Shutdown(); 822 #endif 823 824 imageburner::BurnManager::Shutdown(); 825 CrasAudioHandler::Shutdown(); 826 827 // Detach D-Bus clients before DBusThreadManager is shut down. 828 power_button_observer_.reset(); 829 idle_action_warning_observer_.reset(); 830 831 MagnificationManager::Shutdown(); 832 AccessibilityManager::Shutdown(); 833 834 media::SoundsManager::Shutdown(); 835 836 system::StatisticsProvider::GetInstance()->Shutdown(); 837 838 // Let the UserManager and WallpaperManager unregister itself as an observer 839 // of the CrosSettings singleton before it is destroyed. This also ensures 840 // that the UserManager has no URLRequest pending (see 841 // http://crbug.com/276659). 842 UserManager::Get()->Shutdown(); 843 WallpaperManager::Get()->Shutdown(); 844 845 // Let the AutomaticRebootManager unregister itself as an observer of several 846 // subsystems. 847 g_browser_process->platform_part()->ShutdownAutomaticRebootManager(); 848 849 // Clean up dependency on CrosSettings and stop pending data fetches. 850 KioskAppManager::Shutdown(); 851 852 // We first call PostMainMessageLoopRun and then destroy UserManager, because 853 // Ash needs to be closed before UserManager is destroyed. 854 ChromeBrowserMainPartsLinux::PostMainMessageLoopRun(); 855 856 // Stops all in-flight OAuth2 token fetchers before the IO thread stops. 857 DeviceOAuth2TokenServiceFactory::Shutdown(); 858 859 // Called after 860 // ChromeBrowserMainPartsLinux::PostMainMessageLoopRun() to be 861 // executed after execution of chrome::CloseAsh(), because some 862 // parts of WebUI depends on NetworkPortalDetector. 863 NetworkPortalDetector::Shutdown(); 864 865 UserManager::Destroy(); 866 } 867 868 void ChromeBrowserMainPartsChromeos::PostDestroyThreads() { 869 // Destroy DBus services immediately after threads are stopped. 870 dbus_services_.reset(); 871 872 ChromeBrowserMainPartsLinux::PostDestroyThreads(); 873 874 // Destroy DeviceSettingsService after g_browser_process. 875 DeviceSettingsService::Shutdown(); 876 } 877 878 } // namespace chromeos 879
