src/chrome/browser/chromeos/login/ui/login_display_host_impl.cc

   1 // Copyright 2014 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/login/ui/login_display_host_impl.h"
   6
   7 #include <vector>
   8
   9 #include "ash/audio/sounds.h"
  10 #include "ash/desktop_background/desktop_background_controller.h"
  11 #include "ash/desktop_background/user_wallpaper_delegate.h"
  12 #include "ash/shell.h"
  13 #include "ash/shell_window_ids.h"
  14 #include "base/bind.h"
  15 #include "base/command_line.h"
  16 #include "base/debug/trace_event.h"
  17 #include "base/logging.h"
  18 #include "base/prefs/pref_service.h"
  19 #include "base/strings/string_split.h"
  20 #include "base/strings/utf_string_conversions.h"
  21 #include "base/threading/thread_restrictions.h"
  22 #include "base/time/time.h"
  23 #include "base/values.h"
  24 #include "chrome/browser/browser_process.h"
  25 #include "chrome/browser/browser_shutdown.h"
  26 #include "chrome/browser/chrome_notification_types.h"
  27 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
  28 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
  29 #include "chrome/browser/chromeos/base/locale_util.h"
  30 #include "chrome/browser/chromeos/boot_times_loader.h"
  31 #include "chrome/browser/chromeos/charger_replace/charger_replacement_dialog.h"
  32 #include "chrome/browser/chromeos/first_run/drive_first_run_controller.h"
  33 #include "chrome/browser/chromeos/first_run/first_run.h"
  34 #include "chrome/browser/chromeos/input_method/input_method_util.h"
  35 #include "chrome/browser/chromeos/kiosk_mode/kiosk_mode_settings.h"
  36 #include "chrome/browser/chromeos/language_preferences.h"
  37 #include "chrome/browser/chromeos/login/demo_mode/demo_app_launcher.h"
  38 #include "chrome/browser/chromeos/login/existing_user_controller.h"
  39 #include "chrome/browser/chromeos/login/helper.h"
  40 #include "chrome/browser/chromeos/login/login_utils.h"
  41 #include "chrome/browser/chromeos/login/login_wizard.h"
  42 #include "chrome/browser/chromeos/login/screens/core_oobe_actor.h"
  43 #include "chrome/browser/chromeos/login/startup_utils.h"
  44 #include "chrome/browser/chromeos/login/ui/input_events_blocker.h"
  45 #include "chrome/browser/chromeos/login/ui/keyboard_driven_oobe_key_handler.h"
  46 #include "chrome/browser/chromeos/login/ui/oobe_display.h"
  47 #include "chrome/browser/chromeos/login/ui/webui_login_display.h"
  48 #include "chrome/browser/chromeos/login/ui/webui_login_view.h"
  49 #include "chrome/browser/chromeos/login/users/user_manager.h"
  50 #include "chrome/browser/chromeos/login/wizard_controller.h"
  51 #include "chrome/browser/chromeos/mobile_config.h"
  52 #include "chrome/browser/chromeos/net/delay_network_call.h"
  53 #include "chrome/browser/chromeos/policy/auto_enrollment_client.h"
  54 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
  55 #include "chrome/browser/chromeos/system/input_device_settings.h"
  56 #include "chrome/browser/chromeos/ui/focus_ring_controller.h"
  57 #include "chrome/browser/lifetime/application_lifetime.h"
  58 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
  59 #include "chrome/common/chrome_constants.h"
  60 #include "chrome/common/chrome_switches.h"
  61 #include "chrome/common/pref_names.h"
  62 #include "chromeos/audio/chromeos_sounds.h"
  63 #include "chromeos/chromeos_constants.h"
  64 #include "chromeos/chromeos_switches.h"
  65 #include "chromeos/dbus/dbus_thread_manager.h"
  66 #include "chromeos/dbus/session_manager_client.h"
  67 #include "chromeos/ime/extension_ime_util.h"
  68 #include "chromeos/ime/input_method_manager.h"
  69 #include "chromeos/login/login_state.h"
  70 #include "chromeos/settings/timezone_settings.h"
  71 #include "content/public/browser/notification_service.h"
  72 #include "content/public/browser/notification_types.h"
  73 #include "content/public/browser/render_frame_host.h"
  74 #include "content/public/browser/web_contents.h"
  75 #include "content/public/browser/web_ui.h"
  76 #include "grit/browser_resources.h"
  77 #include "media/audio/sounds/sounds_manager.h"
  78 #include "ui/aura/window.h"
  79 #include "ui/base/resource/resource_bundle.h"
  80 #include "ui/base/ui_base_switches_util.h"
  81 #include "ui/compositor/layer.h"
  82 #include "ui/compositor/layer_animation_observer.h"
  83 #include "ui/compositor/scoped_layer_animation_settings.h"
  84 #include "ui/events/event_utils.h"
  85 #include "ui/gfx/display.h"
  86 #include "ui/gfx/rect.h"
  87 #include "ui/gfx/screen.h"
  88 #include "ui/gfx/size.h"
  89 #include "ui/gfx/transform.h"
  90 #include "ui/keyboard/keyboard_controller.h"
  91 #include "ui/keyboard/keyboard_util.h"
  92 #include "ui/views/focus/focus_manager.h"
  93 #include "ui/views/widget/widget.h"
  94 #include "ui/views/widget/widget_delegate.h"
  95 #include "ui/wm/core/window_animations.h"
  96 #include "url/gurl.h"
  97
  98 namespace {
  99
 100 // Maximum delay for startup sound after 'loginPromptVisible' signal.
 101 const int kStartupSoundMaxDelayMs = 2000;
 102
 103 // URL which corresponds to the login WebUI.
 104 const char kLoginURL[] = "chrome://oobe/login";
 105
 106 // URL which corresponds to the OOBE WebUI.
 107 const char kOobeURL[] = "chrome://oobe/oobe";
 108
 109 // URL which corresponds to the user adding WebUI.
 110 const char kUserAddingURL[] = "chrome://oobe/user-adding";
 111
 112 // URL which corresponds to the app launch splash WebUI.
 113 const char kAppLaunchSplashURL[] = "chrome://oobe/app-launch-splash";
 114
 115 // Duration of sign-in transition animation.
 116 const int kLoginFadeoutTransitionDurationMs = 700;
 117
 118 // Number of times we try to reload OOBE/login WebUI if it crashes.
 119 const int kCrashCountLimit = 5;
 120
 121 // Whether to enable tnitializing WebUI in hidden state (see
 122 // |initialize_webui_hidden_|) by default.
 123 const bool kHiddenWebUIInitializationDefault = true;
 124
 125 // Switch values that might be used to override WebUI init type.
 126 const char kWebUIInitParallel[] = "parallel";
 127 const char kWebUIInitPostpone[] = "postpone";
 128
 129 // The delay of triggering initialization of the device policy subsystem
 130 // after the login screen is initialized. This makes sure that device policy
 131 // network requests are made while the system is idle waiting for user input.
 132 const int64 kPolicyServiceInitializationDelayMilliseconds = 100;
 133
 134 // A class to observe an implicit animation and invokes the callback after the
 135 // animation is completed.
 136 class AnimationObserver : public ui::ImplicitAnimationObserver {
 137  public:
 138   explicit AnimationObserver(const base::Closure& callback)
 139       : callback_(callback) {}
 140   virtual ~AnimationObserver() {}
 141
 142  private:
 143   // ui::ImplicitAnimationObserver implementation:
 144   virtual void OnImplicitAnimationsCompleted() OVERRIDE {
 145     callback_.Run();
 146     delete this;
 147   }
 148
 149   base::Closure callback_;
 150
 151   DISALLOW_COPY_AND_ASSIGN(AnimationObserver);
 152 };
 153
 154 // ShowLoginWizard is split into two parts. This function is sometimes called
 155 // from ShowLoginWizard(), and sometimes from OnLanguageSwitchedCallback()
 156 // (if locale was updated).
 157 void ShowLoginWizardFinish(
 158     const std::string& first_screen_name,
 159     const chromeos::StartupCustomizationDocument* startup_manifest,
 160     chromeos::LoginDisplayHost* display_host) {
 161   TRACE_EVENT0("chromeos", "ShowLoginWizard::ShowLoginWizardFinish");
 162
 163   scoped_ptr<base::DictionaryValue> params;
 164   display_host->StartWizard(first_screen_name, params.Pass());
 165
 166   // Set initial timezone if specified by customization.
 167   const std::string timezone_name = startup_manifest->initial_timezone();
 168   VLOG(1) << "Initial time zone: " << timezone_name;
 169   // Apply locale customizations only once to preserve whatever locale
 170   // user has changed to during OOBE.
 171   if (!timezone_name.empty()) {
 172     chromeos::system::TimezoneSettings::GetInstance()->SetTimezoneFromID(
 173         base::UTF8ToUTF16(timezone_name));
 174   }
 175 }
 176
 177 struct ShowLoginWizardSwitchLanguageCallbackData {
 178   explicit ShowLoginWizardSwitchLanguageCallbackData(
 179       const std::string& first_screen_name,
 180       const chromeos::StartupCustomizationDocument* startup_manifest,
 181       chromeos::LoginDisplayHost* display_host)
 182       : first_screen_name(first_screen_name),
 183         startup_manifest(startup_manifest),
 184         display_host(display_host) {}
 185
 186   const std::string first_screen_name;
 187   const chromeos::StartupCustomizationDocument* const startup_manifest;
 188   chromeos::LoginDisplayHost* const display_host;
 189
 190   // lock UI while resource bundle is being reloaded.
 191   chromeos::InputEventsBlocker events_blocker;
 192 };
 193
 194 void OnLanguageSwitchedCallback(
 195     scoped_ptr<ShowLoginWizardSwitchLanguageCallbackData> self,
 196     const std::string& locale,
 197     const std::string& loaded_locale,
 198     const bool success) {
 199   if (!success)
 200     LOG(WARNING) << "Locale could not be found for '" << locale << "'";
 201
 202   ShowLoginWizardFinish(
 203       self->first_screen_name, self->startup_manifest, self->display_host);
 204 }
 205
 206 void EnableSystemSoundsForAccessibility() {
 207   chromeos::AccessibilityManager::Get()->EnableSystemSounds(true);
 208 }
 209
 210 void AddToSetIfIsGaiaAuthIframe(std::set<content::RenderFrameHost*>* frame_set,
 211                                 content::RenderFrameHost* frame) {
 212   content::RenderFrameHost* parent = frame->GetParent();
 213   if (parent && parent->GetFrameName() == "signin-frame")
 214     frame_set->insert(frame);
 215 }
 216
 217 // A login implementation of WidgetDelegate.
 218 class LoginWidgetDelegate : public views::WidgetDelegate {
 219  public:
 220   explicit LoginWidgetDelegate(views::Widget* widget) : widget_(widget) {
 221   }
 222   virtual ~LoginWidgetDelegate() {}
 223
 224   // Overridden from WidgetDelegate:
 225   virtual void DeleteDelegate() OVERRIDE {
 226     delete this;
 227   }
 228   virtual views::Widget* GetWidget() OVERRIDE {
 229     return widget_;
 230   }
 231   virtual const views::Widget* GetWidget() const OVERRIDE {
 232     return widget_;
 233   }
 234   virtual bool CanActivate() const OVERRIDE {
 235     return true;
 236   }
 237   virtual bool ShouldAdvanceFocusToTopLevelWidget() const OVERRIDE {
 238     return true;
 239   }
 240
 241  private:
 242   views::Widget* widget_;
 243
 244   DISALLOW_COPY_AND_ASSIGN(LoginWidgetDelegate);
 245 };
 246
 247 // Disables virtual keyboard overscroll. Login UI will scroll user pods
 248 // into view on JS side when virtual keyboard is shown.
 249 void DisableKeyboardOverscroll() {
 250   keyboard::SetKeyboardOverscrollOverride(
 251       keyboard::KEYBOARD_OVERSCROLL_OVERRIDE_DISABLED);
 252 }
 253
 254 void ResetKeyboardOverscrollOverride() {
 255   keyboard::SetKeyboardOverscrollOverride(
 256       keyboard::KEYBOARD_OVERSCROLL_OVERRIDE_NONE);
 257 }
 258
 259 }  // namespace
 260
 261 namespace chromeos {
 262
 263 // static
 264 LoginDisplayHost* LoginDisplayHostImpl::default_host_ = NULL;
 265
 266 // static
 267 const int LoginDisplayHostImpl::kShowLoginWebUIid = 0x1111;
 268
 269 // static
 270 content::RenderFrameHost* LoginDisplayHostImpl::GetGaiaAuthIframe(
 271     content::WebContents* web_contents) {
 272   std::set<content::RenderFrameHost*> frame_set;
 273   web_contents->ForEachFrame(
 274       base::Bind(&AddToSetIfIsGaiaAuthIframe, &frame_set));
 275   DCHECK_EQ(1U, frame_set.size());
 276   return *frame_set.begin();
 277 }
 278
 279 ////////////////////////////////////////////////////////////////////////////////
 280 // LoginDisplayHostImpl, public
 281
 282 LoginDisplayHostImpl::LoginDisplayHostImpl(const gfx::Rect& background_bounds)
 283     : background_bounds_(background_bounds),
 284       pointer_factory_(this),
 285       shutting_down_(false),
 286       oobe_progress_bar_visible_(false),
 287       session_starting_(false),
 288       login_window_(NULL),
 289       login_view_(NULL),
 290       webui_login_display_(NULL),
 291       is_showing_login_(false),
 292       is_wallpaper_loaded_(false),
 293       status_area_saved_visibility_(false),
 294       crash_count_(0),
 295       restore_path_(RESTORE_UNKNOWN),
 296       finalize_animation_type_(ANIMATION_WORKSPACE),
 297       animation_weak_ptr_factory_(this),
 298       startup_sound_played_(false),
 299       startup_sound_honors_spoken_feedback_(false),
 300       is_observing_keyboard_(false) {
 301   DBusThreadManager::Get()->GetSessionManagerClient()->AddObserver(this);
 302   CrasAudioHandler::Get()->AddAudioObserver(this);
 303   if (keyboard::KeyboardController::GetInstance()) {
 304     keyboard::KeyboardController::GetInstance()->AddObserver(this);
 305     is_observing_keyboard_ = true;
 306   }
 307
 308   ash::Shell::GetInstance()->delegate()->AddVirtualKeyboardStateObserver(this);
 309   ash::Shell::GetScreen()->AddObserver(this);
 310
 311   // We need to listen to CLOSE_ALL_BROWSERS_REQUEST but not APP_TERMINATING
 312   // because/ APP_TERMINATING will never be fired as long as this keeps
 313   // ref-count. CLOSE_ALL_BROWSERS_REQUEST is safe here because there will be no
 314   // browser instance that will block the shutdown.
 315   registrar_.Add(this,
 316                  chrome::NOTIFICATION_CLOSE_ALL_BROWSERS_REQUEST,
 317                  content::NotificationService::AllSources());
 318
 319   // NOTIFICATION_BROWSER_OPENED is issued after browser is created, but
 320   // not shown yet. Lock window has to be closed at this point so that
 321   // a browser window exists and the window can acquire input focus.
 322   registrar_.Add(this,
 323                  chrome::NOTIFICATION_BROWSER_OPENED,
 324                  content::NotificationService::AllSources());
 325
 326   // Login screen is moved to lock screen container when user logs in.
 327   registrar_.Add(this,
 328                  chrome::NOTIFICATION_LOGIN_USER_CHANGED,
 329                  content::NotificationService::AllSources());
 330
 331   DCHECK(default_host_ == NULL);
 332   default_host_ = this;
 333
 334   // Make sure chrome won't exit while we are at login/oobe screen.
 335   chrome::IncrementKeepAliveCount();
 336
 337   bool is_registered = StartupUtils::IsDeviceRegistered();
 338   bool zero_delay_enabled = WizardController::IsZeroDelayEnabled();
 339   bool disable_boot_animation = CommandLine::ForCurrentProcess()->HasSwitch(
 340       switches::kDisableBootAnimation);
 341
 342   waiting_for_wallpaper_load_ = !zero_delay_enabled &&
 343                                 (!is_registered || !disable_boot_animation);
 344
 345   // For slower hardware we have boot animation disabled so
 346   // we'll be initializing WebUI hidden, waiting for user pods to load and then
 347   // show WebUI at once.
 348   waiting_for_user_pods_ = !zero_delay_enabled && !waiting_for_wallpaper_load_;
 349
 350   initialize_webui_hidden_ =
 351       kHiddenWebUIInitializationDefault && !zero_delay_enabled;
 352
 353   // Check if WebUI init type is overriden.
 354   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshWebUIInit)) {
 355     const std::string override_type =
 356         CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
 357             switches::kAshWebUIInit);
 358     if (override_type == kWebUIInitParallel)
 359       initialize_webui_hidden_ = true;
 360     else if (override_type == kWebUIInitPostpone)
 361       initialize_webui_hidden_ = false;
 362   }
 363
 364   // Always postpone WebUI initialization on first boot, otherwise we miss
 365   // initial animation.
 366   if (!StartupUtils::IsOobeCompleted())
 367     initialize_webui_hidden_ = false;
 368
 369   // There is no wallpaper for KioskMode, don't initialize the webui hidden.
 370   if (chromeos::KioskModeSettings::Get()->IsKioskModeEnabled())
 371     initialize_webui_hidden_ = false;
 372
 373   if (waiting_for_wallpaper_load_) {
 374     registrar_.Add(this,
 375                    chrome::NOTIFICATION_WALLPAPER_ANIMATION_FINISHED,
 376                    content::NotificationService::AllSources());
 377   }
 378
 379   // When we wait for WebUI to be initialized we wait for one of
 380   // these notifications.
 381   if ((waiting_for_user_pods_ || waiting_for_wallpaper_load_) &&
 382       initialize_webui_hidden_) {
 383     registrar_.Add(this,
 384                    chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
 385                    content::NotificationService::AllSources());
 386     registrar_.Add(this,
 387                    chrome::NOTIFICATION_LOGIN_NETWORK_ERROR_SHOWN,
 388                    content::NotificationService::AllSources());
 389   }
 390   LOG(WARNING) << "Login WebUI >> "
 391                << "zero_delay: " << zero_delay_enabled
 392                << " wait_for_wp_load_: " << waiting_for_wallpaper_load_
 393                << " wait_for_pods_: " << waiting_for_user_pods_
 394                << " init_webui_hidden_: " << initialize_webui_hidden_;
 395
 396   media::SoundsManager* manager = media::SoundsManager::Get();
 397   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
 398   manager->Initialize(chromeos::SOUND_STARTUP,
 399                       bundle.GetRawDataResource(IDR_SOUND_STARTUP_WAV));
 400 }
 401
 402 LoginDisplayHostImpl::~LoginDisplayHostImpl() {
 403   DBusThreadManager::Get()->GetSessionManagerClient()->RemoveObserver(this);
 404   CrasAudioHandler::Get()->RemoveAudioObserver(this);
 405   if (keyboard::KeyboardController::GetInstance() && is_observing_keyboard_) {
 406     keyboard::KeyboardController::GetInstance()->RemoveObserver(this);
 407     is_observing_keyboard_ = false;
 408   }
 409
 410   ash::Shell::GetInstance()->delegate()->
 411       RemoveVirtualKeyboardStateObserver(this);
 412   ash::Shell::GetScreen()->RemoveObserver(this);
 413
 414   if (login::LoginScrollIntoViewEnabled())
 415     ResetKeyboardOverscrollOverride();
 416
 417   views::FocusManager::set_arrow_key_traversal_enabled(false);
 418   ResetLoginWindowAndView();
 419
 420   // Let chrome process exit after login/oobe screen if needed.
 421   chrome::DecrementKeepAliveCount();
 422
 423   default_host_ = NULL;
 424   // TODO(tengs): This should be refactored. See crbug.com/314934.
 425   if (UserManager::Get()->IsCurrentUserNew()) {
 426     // DriveOptInController will delete itself when finished.
 427     (new DriveFirstRunController(
 428         ProfileManager::GetActiveUserProfile()))->EnableOfflineMode();
 429   }
 430 }
 431
 432 ////////////////////////////////////////////////////////////////////////////////
 433 // LoginDisplayHostImpl, LoginDisplayHost implementation:
 434
 435 LoginDisplay* LoginDisplayHostImpl::CreateLoginDisplay(
 436     LoginDisplay::Delegate* delegate) {
 437   webui_login_display_ = new WebUILoginDisplay(delegate);
 438   webui_login_display_->set_background_bounds(background_bounds());
 439   return webui_login_display_;
 440 }
 441
 442 gfx::NativeWindow LoginDisplayHostImpl::GetNativeWindow() const {
 443   return login_window_ ? login_window_->GetNativeWindow() : NULL;
 444 }
 445
 446 WebUILoginView* LoginDisplayHostImpl::GetWebUILoginView() const {
 447   return login_view_;
 448 }
 449
 450 void LoginDisplayHostImpl::BeforeSessionStart() {
 451   session_starting_ = true;
 452 }
 453
 454 void LoginDisplayHostImpl::Finalize() {
 455   DVLOG(1) << "Session starting";
 456   if (ash::Shell::HasInstance()) {
 457     ash::Shell::GetInstance()->
 458         desktop_background_controller()->MoveDesktopToUnlockedContainer();
 459   }
 460   if (wizard_controller_.get())
 461     wizard_controller_->OnSessionStart();
 462
 463   switch (finalize_animation_type_) {
 464     case ANIMATION_NONE:
 465       ShutdownDisplayHost(false);
 466       break;
 467     case ANIMATION_WORKSPACE:
 468       if (ash::Shell::HasInstance())
 469         ScheduleWorkspaceAnimation();
 470
 471       ShutdownDisplayHost(false);
 472       break;
 473     case ANIMATION_FADE_OUT:
 474       // Display host is deleted once animation is completed
 475       // since sign in screen widget has to stay alive.
 476       ScheduleFadeOutAnimation();
 477       break;
 478   }
 479 }
 480
 481 void LoginDisplayHostImpl::OnCompleteLogin() {
 482   if (auto_enrollment_controller_)
 483     auto_enrollment_controller_->Cancel();
 484 }
 485
 486 void LoginDisplayHostImpl::OpenProxySettings() {
 487   if (login_view_)
 488     login_view_->OpenProxySettings();
 489 }
 490
 491 void LoginDisplayHostImpl::SetStatusAreaVisible(bool visible) {
 492   if (initialize_webui_hidden_)
 493     status_area_saved_visibility_ = visible;
 494   else if (login_view_)
 495     login_view_->SetStatusAreaVisible(visible);
 496 }
 497
 498 AutoEnrollmentController* LoginDisplayHostImpl::GetAutoEnrollmentController() {
 499   if (!auto_enrollment_controller_) {
 500     auto_enrollment_controller_.reset(new AutoEnrollmentController());
 501     auto_enrollment_progress_subscription_ =
 502         auto_enrollment_controller_->RegisterProgressCallback(
 503             base::Bind(&LoginDisplayHostImpl::OnAutoEnrollmentProgress,
 504                        base::Unretained(this)));
 505   }
 506   return auto_enrollment_controller_.get();
 507 }
 508
 509 void LoginDisplayHostImpl::StartWizard(
 510     const std::string& first_screen_name,
 511     scoped_ptr<base::DictionaryValue> screen_parameters) {
 512   if (login::LoginScrollIntoViewEnabled())
 513     DisableKeyboardOverscroll();
 514
 515   startup_sound_honors_spoken_feedback_ = true;
 516   TryToPlayStartupSound();
 517
 518   // Keep parameters to restore if renderer crashes.
 519   restore_path_ = RESTORE_WIZARD;
 520   wizard_first_screen_name_ = first_screen_name;
 521   if (screen_parameters.get())
 522     wizard_screen_parameters_.reset(screen_parameters->DeepCopy());
 523   else
 524     wizard_screen_parameters_.reset();
 525   is_showing_login_ = false;
 526
 527   if (waiting_for_wallpaper_load_ && !initialize_webui_hidden_) {
 528     LOG(WARNING) << "Login WebUI >> wizard postponed";
 529     return;
 530   }
 531   LOG(WARNING) << "Login WebUI >> wizard";
 532
 533   if (!login_window_)
 534     LoadURL(GURL(kOobeURL));
 535
 536   DVLOG(1) << "Starting wizard, first_screen_name: " << first_screen_name;
 537   // Create and show the wizard.
 538   // Note, dtor of the old WizardController should be called before ctor of the
 539   // new one, because "default_controller()" is updated there. So pure "reset()"
 540   // is done before new controller creation.
 541   wizard_controller_.reset();
 542   wizard_controller_.reset(CreateWizardController());
 543
 544   oobe_progress_bar_visible_ = !StartupUtils::IsDeviceRegistered();
 545   SetOobeProgressBarVisible(oobe_progress_bar_visible_);
 546   wizard_controller_->Init(first_screen_name, screen_parameters.Pass());
 547 }
 548
 549 WizardController* LoginDisplayHostImpl::GetWizardController() {
 550   return wizard_controller_.get();
 551 }
 552
 553 AppLaunchController* LoginDisplayHostImpl::GetAppLaunchController() {
 554   return app_launch_controller_.get();
 555 }
 556
 557 void LoginDisplayHostImpl::StartUserAdding(
 558     const base::Closure& completion_callback) {
 559   if (login::LoginScrollIntoViewEnabled())
 560     DisableKeyboardOverscroll();
 561
 562   restore_path_ = RESTORE_ADD_USER_INTO_SESSION;
 563   completion_callback_ = completion_callback;
 564   finalize_animation_type_ = ANIMATION_NONE;
 565   LOG(WARNING) << "Login WebUI >> user adding";
 566   if (!login_window_)
 567     LoadURL(GURL(kUserAddingURL));
 568   // We should emit this signal only at login screen (after reboot or sign out).
 569   login_view_->set_should_emit_login_prompt_visible(false);
 570
 571   // Lock container can be transparent after lock screen animation.
 572   aura::Window* lock_container = ash::Shell::GetContainer(
 573       ash::Shell::GetPrimaryRootWindow(),
 574       ash::kShellWindowId_LockScreenContainersContainer);
 575   lock_container->layer()->SetOpacity(1.0);
 576
 577   ash::Shell::GetInstance()->
 578       desktop_background_controller()->MoveDesktopToLockedContainer();
 579
 580   sign_in_controller_.reset();  // Only one controller in a time.
 581   sign_in_controller_.reset(new chromeos::ExistingUserController(this));
 582   SetOobeProgressBarVisible(oobe_progress_bar_visible_ = false);
 583   SetStatusAreaVisible(true);
 584   sign_in_controller_->Init(
 585       chromeos::UserManager::Get()->GetUsersAdmittedForMultiProfile());
 586   CHECK(webui_login_display_);
 587   GetOobeUI()->ShowSigninScreen(LoginScreenContext(),
 588                                 webui_login_display_,
 589                                 webui_login_display_);
 590 }
 591
 592 void LoginDisplayHostImpl::StartSignInScreen(
 593     const LoginScreenContext& context) {
 594   if (login::LoginScrollIntoViewEnabled())
 595     DisableKeyboardOverscroll();
 596
 597   startup_sound_honors_spoken_feedback_ = true;
 598   TryToPlayStartupSound();
 599
 600   restore_path_ = RESTORE_SIGN_IN;
 601   is_showing_login_ = true;
 602   finalize_animation_type_ = ANIMATION_WORKSPACE;
 603
 604   PrewarmAuthentication();
 605
 606   if (waiting_for_wallpaper_load_ && !initialize_webui_hidden_) {
 607     LOG(WARNING) << "Login WebUI >> sign in postponed";
 608     return;
 609   }
 610   LOG(WARNING) << "Login WebUI >> sign in";
 611
 612   if (!login_window_) {
 613     TRACE_EVENT_ASYNC_BEGIN0("ui", "ShowLoginWebUI", kShowLoginWebUIid);
 614     TRACE_EVENT_ASYNC_STEP_INTO0(
 615         "ui", "ShowLoginWebUI", kShowLoginWebUIid, "StartSignInScreen");
 616     BootTimesLoader::Get()->RecordCurrentStats("login-start-signin-screen");
 617     LoadURL(GURL(kLoginURL));
 618   }
 619
 620   DVLOG(1) << "Starting sign in screen";
 621   const chromeos::UserList& users = chromeos::UserManager::Get()->GetUsers();
 622
 623   // Fix for users who updated device and thus never passed register screen.
 624   // If we already have users, we assume that it is not a second part of
 625   // OOBE. See http://crosbug.com/6289
 626   if (!StartupUtils::IsDeviceRegistered() && !users.empty()) {
 627     VLOG(1) << "Mark device registered because there are remembered users: "
 628             << users.size();
 629     StartupUtils::MarkDeviceRegistered(base::Closure());
 630   }
 631
 632   sign_in_controller_.reset();  // Only one controller in a time.
 633   sign_in_controller_.reset(new chromeos::ExistingUserController(this));
 634   oobe_progress_bar_visible_ = !StartupUtils::IsDeviceRegistered();
 635   SetOobeProgressBarVisible(oobe_progress_bar_visible_);
 636   SetStatusAreaVisible(true);
 637   sign_in_controller_->Init(users);
 638
 639   // We might be here after a reboot that was triggered after OOBE was complete,
 640   // so check for auto-enrollment again. This might catch a cached decision from
 641   // a previous oobe flow, or might start a new check with the server.
 642   if (GetAutoEnrollmentController()->ShouldEnrollSilently())
 643     sign_in_controller_->DoAutoEnrollment();
 644   else
 645     GetAutoEnrollmentController()->Start();
 646
 647   // Initiate mobile config load.
 648   MobileConfig::GetInstance();
 649
 650   // Initiate device policy fetching.
 651   policy::BrowserPolicyConnectorChromeOS* connector =
 652       g_browser_process->platform_part()->browser_policy_connector_chromeos();
 653   connector->ScheduleServiceInitialization(
 654       kPolicyServiceInitializationDelayMilliseconds);
 655
 656   CHECK(webui_login_display_);
 657   GetOobeUI()->ShowSigninScreen(context,
 658                                 webui_login_display_,
 659                                 webui_login_display_);
 660   if (chromeos::KioskModeSettings::Get()->IsKioskModeEnabled())
 661     SetStatusAreaVisible(false);
 662   TRACE_EVENT_ASYNC_STEP_INTO0("ui",
 663                                "ShowLoginWebUI",
 664                                kShowLoginWebUIid,
 665                                "WaitForScreenStateInitialize");
 666   BootTimesLoader::Get()->RecordCurrentStats(
 667       "login-wait-for-signin-state-initialize");
 668 }
 669
 670 void LoginDisplayHostImpl::ResumeSignInScreen() {
 671   // We only get here after a previous call the StartSignInScreen. That sign-in
 672   // was successful but was interrupted by an auto-enrollment execution; once
 673   // auto-enrollment is complete we resume the normal login flow from here.
 674   DVLOG(1) << "Resuming sign in screen";
 675   CHECK(sign_in_controller_.get());
 676   SetOobeProgressBarVisible(oobe_progress_bar_visible_);
 677   SetStatusAreaVisible(true);
 678   sign_in_controller_->ResumeLogin();
 679 }
 680
 681
 682 void LoginDisplayHostImpl::OnPreferencesChanged() {
 683   if (is_showing_login_)
 684     webui_login_display_->OnPreferencesChanged();
 685 }
 686
 687 void LoginDisplayHostImpl::PrewarmAuthentication() {
 688   auth_prewarmer_.reset(new AuthPrewarmer());
 689   auth_prewarmer_->PrewarmAuthentication(
 690       base::Bind(&LoginDisplayHostImpl::OnAuthPrewarmDone,
 691                  pointer_factory_.GetWeakPtr()));
 692 }
 693
 694 void LoginDisplayHostImpl::StartDemoAppLaunch() {
 695   LOG(WARNING) << "Login WebUI >> starting demo app.";
 696   SetStatusAreaVisible(false);
 697
 698   demo_app_launcher_.reset(new DemoAppLauncher());
 699   demo_app_launcher_->StartDemoAppLaunch();
 700 }
 701
 702 void LoginDisplayHostImpl::StartAppLaunch(const std::string& app_id,
 703                                           bool diagnostic_mode) {
 704   LOG(WARNING) << "Login WebUI >> start app launch.";
 705   SetStatusAreaVisible(false);
 706   finalize_animation_type_ = ANIMATION_FADE_OUT;
 707   if (!login_window_)
 708     LoadURL(GURL(kAppLaunchSplashURL));
 709
 710   login_view_->set_should_emit_login_prompt_visible(false);
 711
 712   app_launch_controller_.reset(new AppLaunchController(
 713       app_id, diagnostic_mode, this, GetOobeUI()));
 714
 715   app_launch_controller_->StartAppLaunch();
 716 }
 717
 718 ////////////////////////////////////////////////////////////////////////////////
 719 // LoginDisplayHostImpl, public
 720
 721 WizardController* LoginDisplayHostImpl::CreateWizardController() {
 722   // TODO(altimofeev): ensure that WebUI is ready.
 723   OobeDisplay* oobe_display = GetOobeUI();
 724   return new WizardController(this, oobe_display);
 725 }
 726
 727 void LoginDisplayHostImpl::OnBrowserCreated() {
 728   // Close lock window now so that the launched browser can receive focus.
 729   ResetLoginWindowAndView();
 730 }
 731
 732 OobeUI* LoginDisplayHostImpl::GetOobeUI() const {
 733   if (!login_view_)
 734     return NULL;
 735   return static_cast<OobeUI*>(login_view_->GetWebUI()->GetController());
 736 }
 737
 738 ////////////////////////////////////////////////////////////////////////////////
 739 // LoginDisplayHostImpl, content:NotificationObserver implementation:
 740
 741 void LoginDisplayHostImpl::Observe(
 742     int type,
 743     const content::NotificationSource& source,
 744     const content::NotificationDetails& details) {
 745   if (chrome::NOTIFICATION_WALLPAPER_ANIMATION_FINISHED == type) {
 746     LOG(WARNING) << "Login WebUI >> wp animation done";
 747     is_wallpaper_loaded_ = true;
 748     ash::Shell::GetInstance()->user_wallpaper_delegate()
 749         ->OnWallpaperBootAnimationFinished();
 750     if (waiting_for_wallpaper_load_) {
 751       // StartWizard / StartSignInScreen could be called multiple times through
 752       // the lifetime of host.
 753       // Make sure that subsequent calls are not postponed.
 754       waiting_for_wallpaper_load_ = false;
 755       if (initialize_webui_hidden_)
 756         ShowWebUI();
 757       else
 758         StartPostponedWebUI();
 759     }
 760     registrar_.Remove(this,
 761                       chrome::NOTIFICATION_WALLPAPER_ANIMATION_FINISHED,
 762                       content::NotificationService::AllSources());
 763   } else if (chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE == type ||
 764              chrome::NOTIFICATION_LOGIN_NETWORK_ERROR_SHOWN == type) {
 765     LOG(WARNING) << "Login WebUI >> WEBUI_VISIBLE";
 766     if (waiting_for_user_pods_ && initialize_webui_hidden_) {
 767       waiting_for_user_pods_ = false;
 768       ShowWebUI();
 769     } else if (waiting_for_wallpaper_load_ && initialize_webui_hidden_) {
 770       // Reduce time till login UI is shown - show it as soon as possible.
 771       waiting_for_wallpaper_load_ = false;
 772       ShowWebUI();
 773     }
 774     registrar_.Remove(this,
 775                       chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
 776                       content::NotificationService::AllSources());
 777     registrar_.Remove(this,
 778                       chrome::NOTIFICATION_LOGIN_NETWORK_ERROR_SHOWN,
 779                       content::NotificationService::AllSources());
 780   } else if (type == chrome::NOTIFICATION_CLOSE_ALL_BROWSERS_REQUEST) {
 781     ShutdownDisplayHost(true);
 782   } else if (type == chrome::NOTIFICATION_BROWSER_OPENED && session_starting_) {
 783     // Browsers created before session start (windows opened by extensions, for
 784     // example) are ignored.
 785     OnBrowserCreated();
 786     registrar_.Remove(this,
 787                       chrome::NOTIFICATION_CLOSE_ALL_BROWSERS_REQUEST,
 788                       content::NotificationService::AllSources());
 789     registrar_.Remove(this,
 790                       chrome::NOTIFICATION_BROWSER_OPENED,
 791                       content::NotificationService::AllSources());
 792   } else if (type == chrome::NOTIFICATION_LOGIN_USER_CHANGED &&
 793              chromeos::UserManager::Get()->IsCurrentUserNew()) {
 794     // For new user, move desktop to locker container so that windows created
 795     // during the user image picker step are below it.
 796     ash::Shell::GetInstance()->
 797         desktop_background_controller()->MoveDesktopToLockedContainer();
 798     registrar_.Remove(this,
 799                       chrome::NOTIFICATION_LOGIN_USER_CHANGED,
 800                       content::NotificationService::AllSources());
 801   }
 802 }
 803
 804 ////////////////////////////////////////////////////////////////////////////////
 805 // LoginDisplayHostImpl, WebContentsObserver implementation:
 806
 807 void LoginDisplayHostImpl::RenderProcessGone(base::TerminationStatus status) {
 808   // Do not try to restore on shutdown
 809   if (browser_shutdown::GetShutdownType() != browser_shutdown::NOT_VALID)
 810     return;
 811
 812   crash_count_++;
 813   if (crash_count_ > kCrashCountLimit)
 814     return;
 815
 816   if (status != base::TERMINATION_STATUS_NORMAL_TERMINATION) {
 817     // Render with login screen crashed. Let's crash browser process to let
 818     // session manager restart it properly. It is hard to reload the page
 819     // and get to controlled state that is fully functional.
 820     // If you see check, search for renderer crash for the same client.
 821     LOG(FATAL) << "Renderer crash on login window";
 822   }
 823 }
 824
 825 ////////////////////////////////////////////////////////////////////////////////
 826 // LoginDisplayHostImpl, chromeos::SessionManagerClient::Observer
 827 // implementation:
 828
 829 void LoginDisplayHostImpl::EmitLoginPromptVisibleCalled() {
 830   OnLoginPromptVisible();
 831 }
 832
 833 ////////////////////////////////////////////////////////////////////////////////
 834 // LoginDisplayHostImpl, chromeos::CrasAudioHandler::AudioObserver
 835 // implementation:
 836
 837 void LoginDisplayHostImpl::OnActiveOutputNodeChanged() {
 838   TryToPlayStartupSound();
 839 }
 840
 841 ////////////////////////////////////////////////////////////////////////////////
 842 // LoginDisplayHostImpl, ash::KeyboardStateObserver:
 843 // implementation:
 844
 845 void LoginDisplayHostImpl::OnVirtualKeyboardStateChanged(bool activated) {
 846   if (keyboard::KeyboardController::GetInstance()) {
 847     if (activated) {
 848       if (!is_observing_keyboard_) {
 849         keyboard::KeyboardController::GetInstance()->AddObserver(this);
 850         is_observing_keyboard_ = true;
 851       }
 852     } else {
 853       keyboard::KeyboardController::GetInstance()->RemoveObserver(this);
 854       is_observing_keyboard_ = false;
 855     }
 856   }
 857 }
 858
 859 ////////////////////////////////////////////////////////////////////////////////
 860 // LoginDisplayHostImpl, keyboard::KeyboardControllerObserver:
 861 // implementation:
 862
 863 void LoginDisplayHostImpl::OnKeyboardBoundsChanging(
 864     const gfx::Rect& new_bounds) {
 865   if (new_bounds.IsEmpty() && !keyboard_bounds_.IsEmpty()) {
 866     // Keyboard has been hidden.
 867     if (GetOobeUI()) {
 868       GetOobeUI()->GetCoreOobeActor()->ShowControlBar(true);
 869       if (login::LoginScrollIntoViewEnabled())
 870         GetOobeUI()->GetCoreOobeActor()->SetKeyboardState(false, new_bounds);
 871     }
 872   } else if (!new_bounds.IsEmpty() && keyboard_bounds_.IsEmpty()) {
 873     // Keyboard has been shown.
 874     if (GetOobeUI()) {
 875       GetOobeUI()->GetCoreOobeActor()->ShowControlBar(false);
 876       if (login::LoginScrollIntoViewEnabled())
 877         GetOobeUI()->GetCoreOobeActor()->SetKeyboardState(true, new_bounds);
 878     }
 879   }
 880
 881   keyboard_bounds_ = new_bounds;
 882 }
 883
 884 ////////////////////////////////////////////////////////////////////////////////
 885 // LoginDisplayHostImpl, gfx::DisplayObserver implementation:
 886
 887 void LoginDisplayHostImpl::OnDisplayAdded(const gfx::Display& new_display) {
 888 }
 889
 890 void LoginDisplayHostImpl::OnDisplayRemoved(const gfx::Display& old_display) {
 891 }
 892
 893 void LoginDisplayHostImpl::OnDisplayMetricsChanged(const gfx::Display& display,
 894                                                    uint32_t changed_metrics) {
 895   if (display.id() != ash::Shell::GetScreen()->GetPrimaryDisplay().id() ||
 896       !(changed_metrics & DISPLAY_METRIC_BOUNDS)) {
 897     return;
 898   }
 899
 900   if (GetOobeUI()) {
 901     const gfx::Size& size = ash::Shell::GetScreen()->GetPrimaryDisplay().size();
 902     GetOobeUI()->GetCoreOobeActor()->SetClientAreaSize(size.width(),
 903                                                        size.height());
 904   }
 905 }
 906
 907 ////////////////////////////////////////////////////////////////////////////////
 908 // LoginDisplayHostImpl, private
 909
 910 void LoginDisplayHostImpl::ShutdownDisplayHost(bool post_quit_task) {
 911   if (shutting_down_)
 912     return;
 913
 914   shutting_down_ = true;
 915   registrar_.RemoveAll();
 916   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 917   if (post_quit_task)
 918     base::MessageLoop::current()->Quit();
 919
 920   if (!completion_callback_.is_null())
 921     completion_callback_.Run();
 922 }
 923
 924 void LoginDisplayHostImpl::ScheduleWorkspaceAnimation() {
 925   if (ash::Shell::GetContainer(ash::Shell::GetPrimaryRootWindow(),
 926                                ash::kShellWindowId_DesktopBackgroundContainer)
 927           ->children()
 928           .empty()) {
 929     // If there is no background window, don't perform any animation on the
 930     // default and background layer because there is nothing behind it.
 931     return;
 932   }
 933
 934   if (!CommandLine::ForCurrentProcess()->HasSwitch(
 935           switches::kDisableLoginAnimations))
 936     ash::Shell::GetInstance()->DoInitialWorkspaceAnimation();
 937 }
 938
 939 void LoginDisplayHostImpl::ScheduleFadeOutAnimation() {
 940   ui::Layer* layer = login_window_->GetLayer();
 941   ui::ScopedLayerAnimationSettings animation(layer->GetAnimator());
 942   animation.AddObserver(new AnimationObserver(
 943       base::Bind(&LoginDisplayHostImpl::ShutdownDisplayHost,
 944                  animation_weak_ptr_factory_.GetWeakPtr(),
 945                  false)));
 946   layer->SetOpacity(0);
 947 }
 948
 949 void LoginDisplayHostImpl::OnAutoEnrollmentProgress(
 950     policy::AutoEnrollmentState state) {
 951   VLOG(1) << "OnAutoEnrollmentProgress, state " << state;
 952
 953   if (sign_in_controller_ &&
 954       auto_enrollment_controller_->ShouldEnrollSilently()) {
 955     sign_in_controller_->DoAutoEnrollment();
 956   }
 957 }
 958
 959 void LoginDisplayHostImpl::LoadURL(const GURL& url) {
 960   InitLoginWindowAndView();
 961   // Subscribe to crash events.
 962   content::WebContentsObserver::Observe(login_view_->GetWebContents());
 963   login_view_->LoadURL(url);
 964
 965   // LoadURL could be called after the spring charger dialog shows, and
 966   // take away the focus from it. Set the focus back to the charger dialog
 967   // if it is visible.
 968   // See crbug.com/328538.
 969   ChargerReplacementDialog::SetFocusOnChargerDialogIfVisible();
 970 }
 971
 972 void LoginDisplayHostImpl::ShowWebUI() {
 973   if (!login_window_ || !login_view_) {
 974     NOTREACHED();
 975     return;
 976   }
 977   LOG(WARNING) << "Login WebUI >> Show already initialized UI";
 978   login_window_->Show();
 979   login_view_->GetWebContents()->Focus();
 980   if (::switches::IsTextInputFocusManagerEnabled())
 981     login_view_->RequestFocus();
 982   login_view_->SetStatusAreaVisible(status_area_saved_visibility_);
 983   login_view_->OnPostponedShow();
 984
 985   // Login window could be shown after the spring charger dialog shows, and
 986   // take away the focus from it. Set the focus back to the charger dialog
 987   // if it is visible.
 988   // See crbug.com/328538.
 989   ChargerReplacementDialog::SetFocusOnChargerDialogIfVisible();
 990
 991   // We should reset this flag to allow changing of status area visibility.
 992   initialize_webui_hidden_ = false;
 993 }
 994
 995 void LoginDisplayHostImpl::StartPostponedWebUI() {
 996   if (!is_wallpaper_loaded_) {
 997     NOTREACHED();
 998     return;
 999   }
1000   LOG(WARNING) << "Login WebUI >> Init postponed WebUI";
1001
1002   // Wallpaper has finished loading before StartWizard/StartSignInScreen has
1003   // been called. In general this should not happen.
1004   // Let go through normal code path when one of those will be called.
1005   if (restore_path_ == RESTORE_UNKNOWN) {
1006     NOTREACHED();
1007     return;
1008   }
1009
1010   switch (restore_path_) {
1011     case RESTORE_WIZARD:
1012       StartWizard(wizard_first_screen_name_,
1013                   wizard_screen_parameters_.Pass());
1014       break;
1015     case RESTORE_SIGN_IN:
1016       StartSignInScreen(LoginScreenContext());
1017       break;
1018     case RESTORE_ADD_USER_INTO_SESSION:
1019       StartUserAdding(completion_callback_);
1020       break;
1021     default:
1022       NOTREACHED();
1023       break;
1024   }
1025 }
1026
1027 void LoginDisplayHostImpl::InitLoginWindowAndView() {
1028   if (login_window_)
1029     return;
1030
1031   if (system::InputDeviceSettings::Get()->ForceKeyboardDrivenUINavigation()) {
1032     views::FocusManager::set_arrow_key_traversal_enabled(true);
1033
1034     focus_ring_controller_.reset(new FocusRingController);
1035     focus_ring_controller_->SetVisible(true);
1036
1037     keyboard_driven_oobe_key_handler_.reset(new KeyboardDrivenOobeKeyHandler);
1038   }
1039
1040   views::Widget::InitParams params(
1041       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
1042   params.bounds = background_bounds();
1043   params.show_state = ui::SHOW_STATE_FULLSCREEN;
1044   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
1045   params.parent =
1046       ash::Shell::GetContainer(ash::Shell::GetPrimaryRootWindow(),
1047                                ash::kShellWindowId_LockScreenContainer);
1048
1049   login_window_ = new views::Widget;
1050   params.delegate = new LoginWidgetDelegate(login_window_);
1051   login_window_->Init(params);
1052
1053   login_view_ = new WebUILoginView();
1054   login_view_->Init();
1055   if (login_view_->webui_visible())
1056     OnLoginPromptVisible();
1057
1058   wm::SetWindowVisibilityAnimationDuration(
1059       login_window_->GetNativeView(),
1060       base::TimeDelta::FromMilliseconds(kLoginFadeoutTransitionDurationMs));
1061   wm::SetWindowVisibilityAnimationTransition(
1062       login_window_->GetNativeView(),
1063       wm::ANIMATE_HIDE);
1064
1065   login_window_->SetContentsView(login_view_);
1066
1067   // If WebUI is initialized in hidden state, show it only if we're no
1068   // longer waiting for wallpaper animation/user images loading. Otherwise,
1069   // always show it.
1070   if (!initialize_webui_hidden_ ||
1071       (!waiting_for_wallpaper_load_ && !waiting_for_user_pods_)) {
1072     LOG(WARNING) << "Login WebUI >> show login wnd on create";
1073     login_window_->Show();
1074   } else {
1075     LOG(WARNING) << "Login WebUI >> login wnd is hidden on create";
1076     login_view_->set_is_hidden(true);
1077   }
1078   login_window_->GetNativeView()->SetName("WebUILoginView");
1079 }
1080
1081 void LoginDisplayHostImpl::ResetLoginWindowAndView() {
1082   if (!login_window_)
1083     return;
1084   login_window_->Close();
1085   login_window_ = NULL;
1086   login_view_ = NULL;
1087 }
1088
1089 void LoginDisplayHostImpl::OnAuthPrewarmDone() {
1090   auth_prewarmer_.reset();
1091 }
1092
1093 void LoginDisplayHostImpl::SetOobeProgressBarVisible(bool visible) {
1094   GetOobeUI()->ShowOobeUI(visible);
1095 }
1096
1097 void LoginDisplayHostImpl::TryToPlayStartupSound() {
1098   if (startup_sound_played_ || login_prompt_visible_time_.is_null() ||
1099       !CrasAudioHandler::Get()->GetActiveOutputNode()) {
1100     return;
1101   }
1102
1103   startup_sound_played_ = true;
1104
1105   // Don't try play startup sound if login prompt is already visible
1106   // for a long time or can't be played.
1107   if (base::TimeTicks::Now() - login_prompt_visible_time_ >
1108       base::TimeDelta::FromMilliseconds(kStartupSoundMaxDelayMs)) {
1109     EnableSystemSoundsForAccessibility();
1110     return;
1111   }
1112
1113   if (!startup_sound_honors_spoken_feedback_ &&
1114       !ash::PlaySystemSoundAlways(SOUND_STARTUP)) {
1115     EnableSystemSoundsForAccessibility();
1116     return;
1117   }
1118
1119   if (startup_sound_honors_spoken_feedback_ &&
1120       !ash::PlaySystemSoundIfSpokenFeedback(SOUND_STARTUP)) {
1121     EnableSystemSoundsForAccessibility();
1122     return;
1123   }
1124
1125   base::MessageLoop::current()->PostDelayedTask(
1126       FROM_HERE,
1127       base::Bind(&EnableSystemSoundsForAccessibility),
1128       media::SoundsManager::Get()->GetDuration(SOUND_STARTUP));
1129 }
1130
1131 void LoginDisplayHostImpl::OnLoginPromptVisible() {
1132   if (!login_prompt_visible_time_.is_null())
1133     return;
1134   login_prompt_visible_time_ = base::TimeTicks::Now();
1135   TryToPlayStartupSound();
1136 }
1137
1138 ////////////////////////////////////////////////////////////////////////////////
1139 // external
1140
1141 // Declared in login_wizard.h so that others don't need to depend on our .h.
1142 // TODO(nkostylev): Split this into a smaller functions.
1143 void ShowLoginWizard(const std::string& first_screen_name) {
1144   if (browser_shutdown::IsTryingToQuit())
1145     return;
1146
1147   VLOG(1) << "Showing OOBE screen: " << first_screen_name;
1148
1149   chromeos::input_method::InputMethodManager* manager =
1150       chromeos::input_method::InputMethodManager::Get();
1151
1152   // Set up keyboards. For example, when |locale| is "en-US", enable US qwerty
1153   // and US dvorak keyboard layouts.
1154   if (g_browser_process && g_browser_process->local_state()) {
1155     manager->SetInputMethodLoginDefault();
1156
1157     PrefService* prefs = g_browser_process->local_state();
1158     // Apply owner preferences for tap-to-click and mouse buttons swap for
1159     // login screen.
1160     system::InputDeviceSettings::Get()->SetPrimaryButtonRight(
1161         prefs->GetBoolean(prefs::kOwnerPrimaryMouseButtonRight));
1162     system::InputDeviceSettings::Get()->SetTapToClick(
1163         prefs->GetBoolean(prefs::kOwnerTapToClickEnabled));
1164   }
1165   system::InputDeviceSettings::Get()->SetNaturalScroll(
1166       CommandLine::ForCurrentProcess()->HasSwitch(
1167           switches::kNaturalScrollDefault));
1168
1169   gfx::Rect screen_bounds(chromeos::CalculateScreenBounds(gfx::Size()));
1170
1171   // Check whether we need to execute OOBE process.
1172   bool oobe_complete = chromeos::StartupUtils::IsOobeCompleted();
1173   if (!oobe_complete) {
1174     LoginState::Get()->SetLoggedInState(
1175         LoginState::LOGGED_IN_OOBE, LoginState::LOGGED_IN_USER_NONE);
1176   } else {
1177     LoginState::Get()->SetLoggedInState(
1178         LoginState::LOGGED_IN_NONE, LoginState::LOGGED_IN_USER_NONE);
1179   }
1180
1181   LoginDisplayHost* display_host = new LoginDisplayHostImpl(screen_bounds);
1182
1183   bool show_app_launch_splash_screen = (first_screen_name ==
1184       chromeos::WizardController::kAppLaunchSplashScreenName);
1185   if (show_app_launch_splash_screen) {
1186     const std::string& auto_launch_app_id =
1187         chromeos::KioskAppManager::Get()->GetAutoLaunchApp();
1188     display_host->StartAppLaunch(auto_launch_app_id,
1189                                  false /* diagnostic_mode */);
1190     return;
1191   }
1192
1193   policy::BrowserPolicyConnectorChromeOS* connector =
1194       g_browser_process->platform_part()->browser_policy_connector_chromeos();
1195   bool enrollment_screen_wanted =
1196       chromeos::WizardController::ShouldRecoverEnrollment() ||
1197       (chromeos::WizardController::ShouldAutoStartEnrollment() &&
1198        oobe_complete &&
1199        !connector->IsEnterpriseManaged());
1200   if (enrollment_screen_wanted && first_screen_name.empty()) {
1201     // Shows networks screen instead of enrollment screen to resume the
1202     // interrupted auto start enrollment flow because enrollment screen does
1203     // not handle flaky network. See http://crbug.com/332572
1204     display_host->StartWizard(chromeos::WizardController::kNetworkScreenName,
1205                               scoped_ptr<base::DictionaryValue>());
1206     return;
1207   }
1208
1209   if (StartupUtils::IsEulaAccepted()) {
1210     DelayNetworkCall(
1211         ServicesCustomizationDocument::GetInstance()
1212             ->EnsureCustomizationAppliedClosure(),
1213         base::TimeDelta::FromMilliseconds(kDefaultNetworkRetryDelayMS));
1214   }
1215
1216   bool show_login_screen =
1217       (first_screen_name.empty() && oobe_complete) ||
1218       first_screen_name == chromeos::WizardController::kLoginScreenName;
1219
1220   if (show_login_screen) {
1221     display_host->StartSignInScreen(LoginScreenContext());
1222     return;
1223   }
1224
1225   // Load startup manifest.
1226   const chromeos::StartupCustomizationDocument* startup_manifest =
1227       chromeos::StartupCustomizationDocument::GetInstance();
1228
1229   // Switch to initial locale if specified by customization
1230   // and has not been set yet. We cannot call
1231   // chromeos::LanguageSwitchMenu::SwitchLanguage here before
1232   // EmitLoginPromptReady.
1233   PrefService* prefs = g_browser_process->local_state();
1234   const std::string& current_locale =
1235       prefs->GetString(prefs::kApplicationLocale);
1236   VLOG(1) << "Current locale: " << current_locale;
1237   const std::string& locale = startup_manifest->initial_locale_default();
1238
1239   const std::string& layout = startup_manifest->keyboard_layout();
1240   VLOG(1) << "Initial locale: " << locale << "keyboard layout " << layout;
1241
1242   // Determine keyboard layout from OEM customization (if provided) or
1243   // initial locale and save it in preferences.
1244   manager->SetInputMethodLoginDefaultFromVPD(locale, layout);
1245
1246   if (!current_locale.empty() || locale.empty()) {
1247     ShowLoginWizardFinish(first_screen_name, startup_manifest, display_host);
1248     return;
1249   }
1250
1251   // Save initial locale from VPD/customization manifest as current
1252   // Chrome locale. Otherwise it will be lost if Chrome restarts.
1253   // Don't need to schedule pref save because setting initial local
1254   // will enforce preference saving.
1255   prefs->SetString(prefs::kApplicationLocale, locale);
1256   chromeos::StartupUtils::SetInitialLocale(locale);
1257
1258   scoped_ptr<ShowLoginWizardSwitchLanguageCallbackData> data(
1259       new ShowLoginWizardSwitchLanguageCallbackData(
1260           first_screen_name, startup_manifest, display_host));
1261
1262   scoped_ptr<locale_util::SwitchLanguageCallback> callback(
1263       new locale_util::SwitchLanguageCallback(
1264           base::Bind(&OnLanguageSwitchedCallback, base::Passed(data.Pass()))));
1265
1266   // Load locale keyboards here. Hardware layout would be automatically enabled.
1267   locale_util::SwitchLanguage(
1268       locale, true, true /* login_layouts_only */, callback.Pass());
1269 }
1270
1271 }  // namespace chromeos