src/chrome/browser/chromeos/login/wizard_controller.cc

   1 // Copyright (c) 2012 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/wizard_controller.h"
   6
   7 #include <signal.h>
   8 #include <stdlib.h>
   9 #include <sys/types.h>
  10
  11 #include <string>
  12 #include <vector>
  13
  14 #include "base/bind.h"
  15 #include "base/command_line.h"
  16 #include "base/logging.h"
  17 #include "base/metrics/histogram.h"
  18 #include "base/prefs/pref_registry_simple.h"
  19 #include "base/prefs/pref_service.h"
  20 #include "base/threading/thread_restrictions.h"
  21 #include "base/values.h"
  22 #include "chrome/browser/browser_process.h"
  23 #include "chrome/browser/chrome_notification_types.h"
  24 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
  25 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
  26 #include "chrome/browser/chromeos/customization_document.h"
  27 #include "chrome/browser/chromeos/login/enrollment/enrollment_screen.h"
  28 #include "chrome/browser/chromeos/login/existing_user_controller.h"
  29 #include "chrome/browser/chromeos/login/helper.h"
  30 #include "chrome/browser/chromeos/login/hwid_checker.h"
  31 #include "chrome/browser/chromeos/login/login_display_host.h"
  32 #include "chrome/browser/chromeos/login/login_utils.h"
  33 #include "chrome/browser/chromeos/login/managed/locally_managed_user_creation_screen.h"
  34 #include "chrome/browser/chromeos/login/oobe_display.h"
  35 #include "chrome/browser/chromeos/login/screens/error_screen.h"
  36 #include "chrome/browser/chromeos/login/screens/eula_screen.h"
  37 #include "chrome/browser/chromeos/login/screens/kiosk_autolaunch_screen.h"
  38 #include "chrome/browser/chromeos/login/screens/kiosk_enable_screen.h"
  39 #include "chrome/browser/chromeos/login/screens/network_screen.h"
  40 #include "chrome/browser/chromeos/login/screens/reset_screen.h"
  41 #include "chrome/browser/chromeos/login/screens/terms_of_service_screen.h"
  42 #include "chrome/browser/chromeos/login/screens/update_screen.h"
  43 #include "chrome/browser/chromeos/login/screens/user_image_screen.h"
  44 #include "chrome/browser/chromeos/login/screens/wrong_hwid_screen.h"
  45 #include "chrome/browser/chromeos/login/startup_utils.h"
  46 #include "chrome/browser/chromeos/login/user_manager.h"
  47 #include "chrome/browser/chromeos/net/network_portal_detector.h"
  48 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
  49 #include "chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos.h"
  50 #include "chrome/browser/chromeos/settings/cros_settings.h"
  51 #include "chrome/browser/profiles/profile.h"
  52 #include "chrome/browser/profiles/profile_manager.h"
  53 #include "chrome/browser/ui/options/options_util.h"
  54 #include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
  55 #include "chrome/common/chrome_constants.h"
  56 #include "chrome/common/pref_names.h"
  57 #include "chromeos/audio/cras_audio_handler.h"
  58 #include "chromeos/chromeos_constants.h"
  59 #include "chromeos/dbus/dbus_thread_manager.h"
  60 #include "chromeos/dbus/session_manager_client.h"
  61 #include "chromeos/network/network_state_handler.h"
  62 #include "chromeos/settings/cros_settings_names.h"
  63 #include "components/breakpad/app/breakpad_linux.h"
  64 #include "content/public/browser/browser_thread.h"
  65 #include "content/public/browser/notification_types.h"
  66 #include "ui/base/accelerators/accelerator.h"
  67 #include "ui/base/l10n/l10n_util.h"
  68
  69 using content::BrowserThread;
  70
  71 // If reboot didn't happen, ask user to reboot device manually.
  72 const int kWaitForRebootTimeSec = 3;
  73
  74 // Interval in ms which is used for smooth screen showing.
  75 static int kShowDelayMs = 400;
  76
  77 namespace chromeos {
  78
  79 const char WizardController::kNetworkScreenName[] = "network";
  80 const char WizardController::kLoginScreenName[] = "login";
  81 const char WizardController::kUpdateScreenName[] = "update";
  82 const char WizardController::kUserImageScreenName[] = "image";
  83 const char WizardController::kEulaScreenName[] = "eula";
  84 const char WizardController::kEnrollmentScreenName[] = "enroll";
  85 const char WizardController::kResetScreenName[] = "reset";
  86 const char WizardController::kKioskEnableScreenName[] = "kiosk-enable";
  87 const char WizardController::kKioskAutolaunchScreenName[] = "autolaunch";
  88 const char WizardController::kErrorScreenName[] = "error-message";
  89 const char WizardController::kTermsOfServiceScreenName[] = "tos";
  90 const char WizardController::kWrongHWIDScreenName[] = "wrong-hwid";
  91 const char WizardController::kLocallyManagedUserCreationScreenName[] =
  92   "locally-managed-user-creation-flow";
  93 const char WizardController::kAppLaunchSplashScreenName[] =
  94   "app-launch-splash";
  95
  96 // static
  97 const int WizardController::kMinAudibleOutputVolumePercent = 10;
  98
  99 // Passing this parameter as a "first screen" initiates full OOBE flow.
 100 const char WizardController::kOutOfBoxScreenName[] = "oobe";
 101
 102 // Special test value that commands not to create any window yet.
 103 const char WizardController::kTestNoScreenName[] = "test:nowindow";
 104
 105 // Initialize default controller.
 106 // static
 107 WizardController* WizardController::default_controller_ = NULL;
 108
 109 // static
 110 bool WizardController::skip_post_login_screens_ = false;
 111
 112 // static
 113 bool WizardController::zero_delay_enabled_ = false;
 114
 115 ///////////////////////////////////////////////////////////////////////////////
 116 // WizardController, public:
 117
 118 PrefService* WizardController::local_state_for_testing_ = NULL;
 119
 120 WizardController::WizardController(chromeos::LoginDisplayHost* host,
 121                                    chromeos::OobeDisplay* oobe_display)
 122     : current_screen_(NULL),
 123       previous_screen_(NULL),
 124 #if defined(GOOGLE_CHROME_BUILD)
 125       is_official_build_(true),
 126 #else
 127       is_official_build_(false),
 128 #endif
 129       is_out_of_box_(false),
 130       host_(host),
 131       oobe_display_(oobe_display),
 132       usage_statistics_reporting_(true),
 133       skip_update_enroll_after_eula_(false),
 134       login_screen_started_(false),
 135       user_image_screen_return_to_previous_hack_(false),
 136       weak_factory_(this) {
 137   DCHECK(default_controller_ == NULL);
 138   default_controller_ = this;
 139
 140   registrar_.Add(
 141       this,
 142       chrome::NOTIFICATION_CROS_ACCESSIBILITY_TOGGLE_SPOKEN_FEEDBACK,
 143       content::NotificationService::AllSources());
 144 }
 145
 146 WizardController::~WizardController() {
 147   if (default_controller_ == this) {
 148     default_controller_ = NULL;
 149   } else {
 150     NOTREACHED() << "More than one controller are alive.";
 151   }
 152 }
 153
 154 void WizardController::Init(
 155     const std::string& first_screen_name,
 156     scoped_ptr<base::DictionaryValue> screen_parameters) {
 157   VLOG(1) << "Starting OOBE wizard with screen: " << first_screen_name;
 158   first_screen_name_ = first_screen_name;
 159   screen_parameters_ = screen_parameters.Pass();
 160
 161   bool oobe_complete = StartupUtils::IsOobeCompleted();
 162   if (!oobe_complete || first_screen_name == kOutOfBoxScreenName)
 163     is_out_of_box_ = true;
 164
 165   // This is a hacky way to check for local state corruption, because
 166   // it depends on the fact that the local state is loaded
 167   // synchroniously and at the first demand. IsEnterpriseManaged()
 168   // check is required because currently powerwash is disabled for
 169   // enterprise-entrolled devices.
 170   //
 171   // TODO (ygorshenin@): implement handling of the local state
 172   // corruption in the case of asynchronious loading.
 173   //
 174   // TODO (ygorshenin@): remove IsEnterpriseManaged() check once
 175   // crbug.com/241313 will be fixed.
 176   policy::BrowserPolicyConnectorChromeOS* connector =
 177       g_browser_process->platform_part()->browser_policy_connector_chromeos();
 178   if (!connector->IsEnterpriseManaged()) {
 179     const PrefService::PrefInitializationStatus status =
 180         GetLocalState()->GetInitializationStatus();
 181     if (status == PrefService::INITIALIZATION_STATUS_ERROR) {
 182       OnLocalStateInitialized(false);
 183       return;
 184     } else if (status == PrefService::INITIALIZATION_STATUS_WAITING) {
 185       GetLocalState()->AddPrefInitObserver(
 186           base::Bind(&WizardController::OnLocalStateInitialized,
 187                      weak_factory_.GetWeakPtr()));
 188     }
 189   }
 190
 191   AdvanceToScreen(first_screen_name);
 192   if (!IsMachineHWIDCorrect() && !StartupUtils::IsDeviceRegistered() &&
 193       first_screen_name.empty())
 194     ShowWrongHWIDScreen();
 195 }
 196
 197 chromeos::NetworkScreen* WizardController::GetNetworkScreen() {
 198   if (!network_screen_.get())
 199     network_screen_.reset(new chromeos::NetworkScreen(
 200         this, oobe_display_->GetNetworkScreenActor()));
 201   return network_screen_.get();
 202 }
 203
 204 chromeos::UpdateScreen* WizardController::GetUpdateScreen() {
 205   if (!update_screen_.get()) {
 206     update_screen_.reset(new chromeos::UpdateScreen(
 207         this, oobe_display_->GetUpdateScreenActor()));
 208     update_screen_->SetRebootCheckDelay(kWaitForRebootTimeSec);
 209   }
 210   return update_screen_.get();
 211 }
 212
 213 chromeos::UserImageScreen* WizardController::GetUserImageScreen() {
 214   if (!user_image_screen_.get())
 215     user_image_screen_.reset(
 216         new chromeos::UserImageScreen(
 217             this, oobe_display_->GetUserImageScreenActor()));
 218   return user_image_screen_.get();
 219 }
 220
 221 chromeos::EulaScreen* WizardController::GetEulaScreen() {
 222   if (!eula_screen_.get())
 223     eula_screen_.reset(new chromeos::EulaScreen(
 224         this, oobe_display_->GetEulaScreenActor()));
 225   return eula_screen_.get();
 226 }
 227
 228 chromeos::EnrollmentScreen*
 229     WizardController::GetEnrollmentScreen() {
 230   if (!enrollment_screen_.get()) {
 231     enrollment_screen_.reset(
 232         new chromeos::EnrollmentScreen(
 233             this, oobe_display_->GetEnrollmentScreenActor()));
 234   }
 235   return enrollment_screen_.get();
 236 }
 237
 238 chromeos::ResetScreen* WizardController::GetResetScreen() {
 239   if (!reset_screen_.get()) {
 240     reset_screen_.reset(
 241         new chromeos::ResetScreen(this, oobe_display_->GetResetScreenActor()));
 242   }
 243   return reset_screen_.get();
 244 }
 245
 246 chromeos::KioskEnableScreen* WizardController::GetKioskEnableScreen() {
 247   if (!kiosk_enable_screen_.get()) {
 248     kiosk_enable_screen_.reset(
 249         new chromeos::KioskEnableScreen(
 250             this,
 251             oobe_display_->GetKioskEnableScreenActor()));
 252   }
 253   return kiosk_enable_screen_.get();
 254 }
 255
 256 chromeos::KioskAutolaunchScreen* WizardController::GetKioskAutolaunchScreen() {
 257   if (!autolaunch_screen_.get()) {
 258     autolaunch_screen_.reset(
 259         new chromeos::KioskAutolaunchScreen(
 260             this, oobe_display_->GetKioskAutolaunchScreenActor()));
 261   }
 262   return autolaunch_screen_.get();
 263 }
 264
 265 chromeos::TermsOfServiceScreen* WizardController::GetTermsOfServiceScreen() {
 266   if (!terms_of_service_screen_.get()) {
 267     terms_of_service_screen_.reset(
 268         new chromeos::TermsOfServiceScreen(
 269             this, oobe_display_->GetTermsOfServiceScreenActor()));
 270   }
 271   return terms_of_service_screen_.get();
 272 }
 273
 274 chromeos::WrongHWIDScreen* WizardController::GetWrongHWIDScreen() {
 275   if (!wrong_hwid_screen_.get()) {
 276     wrong_hwid_screen_.reset(
 277         new chromeos::WrongHWIDScreen(
 278             this, oobe_display_->GetWrongHWIDScreenActor()));
 279   }
 280   return wrong_hwid_screen_.get();
 281 }
 282
 283 chromeos::LocallyManagedUserCreationScreen*
 284     WizardController::GetLocallyManagedUserCreationScreen() {
 285   if (!locally_managed_user_creation_screen_.get()) {
 286     locally_managed_user_creation_screen_.reset(
 287         new chromeos::LocallyManagedUserCreationScreen(
 288             this, oobe_display_->GetLocallyManagedUserCreationScreenActor()));
 289   }
 290   return locally_managed_user_creation_screen_.get();
 291 }
 292
 293 void WizardController::ShowNetworkScreen() {
 294   VLOG(1) << "Showing network screen.";
 295   SetStatusAreaVisible(false);
 296   SetCurrentScreen(GetNetworkScreen());
 297 }
 298
 299 void WizardController::ShowLoginScreen(const LoginScreenContext& context) {
 300   if (!time_eula_accepted_.is_null()) {
 301     base::TimeDelta delta = base::Time::Now() - time_eula_accepted_;
 302     UMA_HISTOGRAM_MEDIUM_TIMES("OOBE.EULAToSignInTime", delta);
 303   }
 304   VLOG(1) << "Showing login screen.";
 305   SetStatusAreaVisible(true);
 306   host_->StartSignInScreen(context);
 307   smooth_show_timer_.Stop();
 308   oobe_display_ = NULL;
 309   login_screen_started_ = true;
 310 }
 311
 312 void WizardController::ResumeLoginScreen() {
 313   VLOG(1) << "Resuming login screen.";
 314   SetStatusAreaVisible(true);
 315   host_->ResumeSignInScreen();
 316   smooth_show_timer_.Stop();
 317   oobe_display_ = NULL;
 318 }
 319
 320 void WizardController::ShowUpdateScreen() {
 321   VLOG(1) << "Showing update screen.";
 322   SetStatusAreaVisible(true);
 323   SetCurrentScreen(GetUpdateScreen());
 324 }
 325
 326 void WizardController::ShowUserImageScreen() {
 327   const chromeos::UserManager* user_manager = chromeos::UserManager::Get();
 328   // Skip user image selection for public sessions and ephemeral logins.
 329   if (user_manager->IsLoggedInAsPublicAccount() ||
 330       user_manager->IsCurrentUserNonCryptohomeDataEphemeral()) {
 331     OnUserImageSkipped();
 332     return;
 333   }
 334   VLOG(1) << "Showing user image screen.";
 335
 336   bool profile_picture_enabled = true;
 337   std::string user_id;
 338   if (screen_parameters_.get()) {
 339     screen_parameters_->GetBoolean("profile_picture_enabled",
 340         &profile_picture_enabled);
 341     screen_parameters_->GetString("user_id", &user_id);
 342   }
 343
 344   // Status area has been already shown at sign in screen so it
 345   // doesn't make sense to hide it here and then show again at user session as
 346   // this produces undesired UX transitions.
 347   SetStatusAreaVisible(true);
 348
 349   UserImageScreen* screen = GetUserImageScreen();
 350   if (!user_id.empty())
 351     screen->SetUserID(user_id);
 352   screen->SetProfilePictureEnabled(profile_picture_enabled);
 353
 354   SetCurrentScreen(screen);
 355 }
 356
 357 void WizardController::ShowEulaScreen() {
 358   VLOG(1) << "Showing EULA screen.";
 359   SetStatusAreaVisible(false);
 360   SetCurrentScreen(GetEulaScreen());
 361 }
 362
 363 void WizardController::ShowEnrollmentScreen() {
 364   SetStatusAreaVisible(true);
 365
 366   bool is_auto_enrollment = false;
 367   std::string user;
 368   if (screen_parameters_.get()) {
 369     screen_parameters_->GetBoolean("is_auto_enrollment", &is_auto_enrollment);
 370     screen_parameters_->GetString("user", &user);
 371   }
 372
 373   EnrollmentScreen* screen = GetEnrollmentScreen();
 374   screen->SetParameters(is_auto_enrollment,
 375                         !ShouldAutoStartEnrollment() || CanExitEnrollment(),
 376                         user);
 377   SetCurrentScreen(screen);
 378 }
 379
 380 void WizardController::ShowResetScreen() {
 381   VLOG(1) << "Showing reset screen.";
 382   SetStatusAreaVisible(false);
 383   SetCurrentScreen(GetResetScreen());
 384 }
 385
 386 void WizardController::ShowKioskEnableScreen() {
 387   VLOG(1) << "Showing kiosk enable screen.";
 388   SetStatusAreaVisible(false);
 389   SetCurrentScreen(GetKioskEnableScreen());
 390 }
 391
 392 void WizardController::ShowKioskAutolaunchScreen() {
 393   VLOG(1) << "Showing kiosk autolaunch screen.";
 394   SetStatusAreaVisible(false);
 395   SetCurrentScreen(GetKioskAutolaunchScreen());
 396 }
 397
 398 void WizardController::ShowTermsOfServiceScreen() {
 399   // Only show the Terms of Service when logging into a public account and Terms
 400   // of Service have been specified through policy. In all other cases, advance
 401   // to the user image screen immediately.
 402   if (!chromeos::UserManager::Get()->IsLoggedInAsPublicAccount() ||
 403       !ProfileManager::GetActiveUserProfile()->GetPrefs()->
 404           IsManagedPreference(prefs::kTermsOfServiceURL)) {
 405     ShowUserImageScreen();
 406     return;
 407   }
 408
 409   VLOG(1) << "Showing Terms of Service screen.";
 410   SetStatusAreaVisible(true);
 411   SetCurrentScreen(GetTermsOfServiceScreen());
 412 }
 413
 414 void WizardController::ShowWrongHWIDScreen() {
 415   VLOG(1) << "Showing wrong HWID screen.";
 416   SetStatusAreaVisible(false);
 417   SetCurrentScreen(GetWrongHWIDScreen());
 418 }
 419
 420 void WizardController::ShowLocallyManagedUserCreationScreen() {
 421   VLOG(1) << "Showing Locally managed user creation screen screen.";
 422   SetStatusAreaVisible(true);
 423   LocallyManagedUserCreationScreen* screen =
 424       GetLocallyManagedUserCreationScreen();
 425   SetCurrentScreen(screen);
 426 }
 427
 428 void WizardController::SkipToLoginForTesting(
 429     const LoginScreenContext& context) {
 430   StartupUtils::MarkEulaAccepted();
 431   PerformPostEulaActions();
 432   PerformPostUpdateActions();
 433   ShowLoginScreen(context);
 434 }
 435
 436 void WizardController::AddObserver(Observer* observer) {
 437   observer_list_.AddObserver(observer);
 438 }
 439
 440 void WizardController::RemoveObserver(Observer* observer) {
 441   observer_list_.RemoveObserver(observer);
 442 }
 443
 444 void WizardController::OnSessionStart() {
 445   FOR_EACH_OBSERVER(Observer, observer_list_, OnSessionStart());
 446 }
 447
 448 void WizardController::SkipUpdateEnrollAfterEula() {
 449   skip_update_enroll_after_eula_ = true;
 450 }
 451
 452 ///////////////////////////////////////////////////////////////////////////////
 453 // WizardController, ExitHandlers:
 454 void WizardController::OnNetworkConnected() {
 455   if (is_official_build_) {
 456     if (!StartupUtils::IsEulaAccepted()) {
 457       ShowEulaScreen();
 458     } else {
 459       // Possible cases:
 460       // 1. EULA was accepted, forced shutdown/reboot during update.
 461       // 2. EULA was accepted, planned reboot after update.
 462       // Make sure that device is up-to-date.
 463       InitiateOOBEUpdate();
 464     }
 465   } else {
 466     InitiateOOBEUpdate();
 467   }
 468 }
 469
 470 void WizardController::OnNetworkOffline() {
 471   // TODO(dpolukhin): if(is_out_of_box_) we cannot work offline and
 472   // should report some error message here and stay on the same screen.
 473   ShowLoginScreen(LoginScreenContext());
 474 }
 475
 476 void WizardController::OnConnectionFailed() {
 477   // TODO(dpolukhin): show error message after login screen is displayed.
 478   ShowLoginScreen(LoginScreenContext());
 479 }
 480
 481 void WizardController::OnUpdateCompleted() {
 482   OnOOBECompleted();
 483 }
 484
 485 void WizardController::OnEulaAccepted() {
 486   time_eula_accepted_ = base::Time::Now();
 487   StartupUtils::MarkEulaAccepted();
 488   bool uma_enabled =
 489       OptionsUtil::ResolveMetricsReportingEnabled(usage_statistics_reporting_);
 490
 491   CrosSettings::Get()->SetBoolean(kStatsReportingPref, uma_enabled);
 492   if (uma_enabled) {
 493 #if defined(GOOGLE_CHROME_BUILD)
 494     // The crash reporter initialization needs IO to complete.
 495     base::ThreadRestrictions::ScopedAllowIO allow_io;
 496     breakpad::InitCrashReporter(std::string());
 497 #endif
 498   }
 499
 500   if (skip_update_enroll_after_eula_) {
 501     PerformPostEulaActions();
 502     PerformPostUpdateActions();
 503     ShowEnrollmentScreen();
 504   } else {
 505     InitiateOOBEUpdate();
 506   }
 507 }
 508
 509 void WizardController::OnUpdateErrorCheckingForUpdate() {
 510   // TODO(nkostylev): Update should be required during OOBE.
 511   // We do not want to block users from being able to proceed to the login
 512   // screen if there is any error checking for an update.
 513   // They could use "browse without sign-in" feature to set up the network to be
 514   // able to perform the update later.
 515   OnOOBECompleted();
 516 }
 517
 518 void WizardController::OnUpdateErrorUpdating() {
 519   // If there was an error while getting or applying the update,
 520   // return to network selection screen.
 521   // TODO(nkostylev): Show message to the user explaining update error.
 522   // TODO(nkostylev): Update should be required during OOBE.
 523   // Temporary fix, need to migrate to new API. http://crosbug.com/4321
 524   OnOOBECompleted();
 525 }
 526
 527 void WizardController::EnableUserImageScreenReturnToPreviousHack() {
 528   user_image_screen_return_to_previous_hack_ = true;
 529 }
 530
 531 void WizardController::OnUserImageSelected() {
 532   if (user_image_screen_return_to_previous_hack_) {
 533     user_image_screen_return_to_previous_hack_ = false;
 534     DCHECK(previous_screen_);
 535     if (previous_screen_) {
 536       SetCurrentScreen(previous_screen_);
 537       return;
 538     }
 539   }
 540   // Launch browser and delete login host controller.
 541   BrowserThread::PostTask(
 542       BrowserThread::UI,
 543       FROM_HERE,
 544       base::Bind(&chromeos::LoginUtils::DoBrowserLaunch,
 545                  base::Unretained(chromeos::LoginUtils::Get()),
 546                  ProfileManager::GetActiveUserProfile(), host_));
 547   host_ = NULL;
 548 }
 549
 550 void WizardController::OnUserImageSkipped() {
 551   OnUserImageSelected();
 552 }
 553
 554 void WizardController::OnEnrollmentDone() {
 555   // Mark OOBE as completed only if enterprise enrollment was part of the
 556   // forced flow (i.e. app kiosk).
 557   if (ShouldAutoStartEnrollment())
 558     PerformPostUpdateActions();
 559
 560   // TODO(mnissler): Unify the logic for auto-login for Public Sessions and
 561   // Kiosk Apps and make this code cover both cases: http://crbug.com/234694.
 562   if (KioskAppManager::Get()->IsAutoLaunchEnabled())
 563     AutoLaunchKioskApp();
 564   else
 565     ShowLoginScreen(LoginScreenContext());
 566 }
 567
 568 void WizardController::OnResetCanceled() {
 569   if (previous_screen_)
 570     SetCurrentScreen(previous_screen_);
 571   else
 572     ShowLoginScreen(LoginScreenContext());
 573 }
 574
 575 void WizardController::OnKioskAutolaunchCanceled() {
 576   ShowLoginScreen(LoginScreenContext());
 577 }
 578
 579 void WizardController::OnKioskAutolaunchConfirmed() {
 580   DCHECK(KioskAppManager::Get()->IsAutoLaunchEnabled());
 581   AutoLaunchKioskApp();
 582 }
 583
 584 void WizardController::OnKioskEnableCompleted() {
 585   ShowLoginScreen(LoginScreenContext());
 586 }
 587
 588 void WizardController::OnWrongHWIDWarningSkipped() {
 589   if (previous_screen_)
 590     SetCurrentScreen(previous_screen_);
 591   else
 592     ShowLoginScreen(LoginScreenContext());
 593 }
 594
 595 void WizardController::OnAutoEnrollmentDone() {
 596   VLOG(1) << "Automagic enrollment done, resuming previous signin";
 597   ResumeLoginScreen();
 598 }
 599
 600 void WizardController::OnOOBECompleted() {
 601   if (ShouldAutoStartEnrollment()) {
 602     ShowEnrollmentScreen();
 603   } else {
 604     PerformPostUpdateActions();
 605     ShowLoginScreen(LoginScreenContext());
 606   }
 607 }
 608
 609 void WizardController::OnTermsOfServiceDeclined() {
 610   // If the user declines the Terms of Service, end the session and return to
 611   // the login screen.
 612   DBusThreadManager::Get()->GetSessionManagerClient()->StopSession();
 613 }
 614
 615 void WizardController::OnTermsOfServiceAccepted() {
 616   // If the user accepts the Terms of Service, advance to the user image screen.
 617   ShowUserImageScreen();
 618 }
 619
 620 void WizardController::InitiateOOBEUpdate() {
 621   PerformPostEulaActions();
 622   SetCurrentScreenSmooth(GetUpdateScreen(), true);
 623   GetUpdateScreen()->StartNetworkCheck();
 624 }
 625
 626 void WizardController::PerformPostEulaActions() {
 627   // Now that EULA has been accepted (for official builds), enable portal check.
 628   // ChromiumOS builds would go though this code path too.
 629   NetworkHandler::Get()->network_state_handler()->SetCheckPortalList(
 630       NetworkStateHandler::kDefaultCheckPortalList);
 631   host_->CheckForAutoEnrollment();
 632   host_->PrewarmAuthentication();
 633   NetworkPortalDetector::Get()->Enable(true);
 634 }
 635
 636 void WizardController::PerformPostUpdateActions() {
 637   StartupUtils::MarkOobeCompleted();
 638 }
 639
 640 void WizardController::SetCurrentScreen(WizardScreen* new_current) {
 641   SetCurrentScreenSmooth(new_current, false);
 642 }
 643
 644 void WizardController::ShowCurrentScreen() {
 645   // ShowCurrentScreen may get called by smooth_show_timer_ even after
 646   // flow has been switched to sign in screen (ExistingUserController).
 647   if (!oobe_display_)
 648     return;
 649
 650   smooth_show_timer_.Stop();
 651
 652   FOR_EACH_OBSERVER(Observer, observer_list_, OnScreenChanged(current_screen_));
 653
 654   oobe_display_->ShowScreen(current_screen_);
 655 }
 656
 657 void WizardController::SetCurrentScreenSmooth(WizardScreen* new_current,
 658                                               bool use_smoothing) {
 659   if (current_screen_ == new_current ||
 660       new_current == NULL ||
 661       oobe_display_ == NULL) {
 662     return;
 663   }
 664
 665   smooth_show_timer_.Stop();
 666
 667   if (current_screen_)
 668     oobe_display_->HideScreen(current_screen_);
 669
 670   previous_screen_ = current_screen_;
 671   current_screen_ = new_current;
 672
 673   if (use_smoothing) {
 674     smooth_show_timer_.Start(
 675         FROM_HERE,
 676         base::TimeDelta::FromMilliseconds(kShowDelayMs),
 677         this,
 678         &WizardController::ShowCurrentScreen);
 679   } else {
 680     ShowCurrentScreen();
 681   }
 682 }
 683
 684 void WizardController::SetStatusAreaVisible(bool visible) {
 685   host_->SetStatusAreaVisible(visible);
 686 }
 687
 688 void WizardController::AdvanceToScreenWithParams(
 689     const std::string& screen_name,
 690     base::DictionaryValue* screen_parameters) {
 691   screen_parameters_.reset(screen_parameters);
 692   AdvanceToScreen(screen_name);
 693 }
 694
 695 void WizardController::AdvanceToScreen(const std::string& screen_name) {
 696   if (screen_name == kNetworkScreenName) {
 697     ShowNetworkScreen();
 698   } else if (screen_name == kLoginScreenName) {
 699     ShowLoginScreen(LoginScreenContext());
 700   } else if (screen_name == kUpdateScreenName) {
 701     InitiateOOBEUpdate();
 702   } else if (screen_name == kUserImageScreenName) {
 703     ShowUserImageScreen();
 704   } else if (screen_name == kEulaScreenName) {
 705     ShowEulaScreen();
 706   } else if (screen_name == kResetScreenName) {
 707     ShowResetScreen();
 708   } else if (screen_name == kKioskEnableScreenName) {
 709     ShowKioskEnableScreen();
 710   } else if (screen_name == kKioskAutolaunchScreenName) {
 711     ShowKioskAutolaunchScreen();
 712   } else if (screen_name == kEnrollmentScreenName) {
 713     ShowEnrollmentScreen();
 714   } else if (screen_name == kTermsOfServiceScreenName) {
 715     ShowTermsOfServiceScreen();
 716   } else if (screen_name == kWrongHWIDScreenName) {
 717     ShowWrongHWIDScreen();
 718   } else if (screen_name == kLocallyManagedUserCreationScreenName) {
 719     ShowLocallyManagedUserCreationScreen();
 720   } else if (screen_name == kAppLaunchSplashScreenName) {
 721     AutoLaunchKioskApp();
 722   } else if (screen_name != kTestNoScreenName) {
 723     if (is_out_of_box_) {
 724       ShowNetworkScreen();
 725     } else {
 726       ShowLoginScreen(LoginScreenContext());
 727     }
 728   }
 729 }
 730
 731 ///////////////////////////////////////////////////////////////////////////////
 732 // WizardController, chromeos::ScreenObserver overrides:
 733 void WizardController::OnExit(ExitCodes exit_code) {
 734   VLOG(1) << "Wizard screen exit code: " << exit_code;
 735   switch (exit_code) {
 736     case NETWORK_CONNECTED:
 737       OnNetworkConnected();
 738       break;
 739     case CONNECTION_FAILED:
 740       OnConnectionFailed();
 741       break;
 742     case UPDATE_INSTALLED:
 743     case UPDATE_NOUPDATE:
 744       OnUpdateCompleted();
 745       break;
 746     case UPDATE_ERROR_CHECKING_FOR_UPDATE:
 747       OnUpdateErrorCheckingForUpdate();
 748       break;
 749     case UPDATE_ERROR_UPDATING:
 750       OnUpdateErrorUpdating();
 751       break;
 752     case USER_IMAGE_SELECTED:
 753       OnUserImageSelected();
 754       break;
 755     case EULA_ACCEPTED:
 756       OnEulaAccepted();
 757       break;
 758     case EULA_BACK:
 759       ShowNetworkScreen();
 760       break;
 761     case ENTERPRISE_ENROLLMENT_COMPLETED:
 762       OnEnrollmentDone();
 763       break;
 764     case ENTERPRISE_ENROLLMENT_BACK:
 765       ShowNetworkScreen();
 766       break;
 767     case RESET_CANCELED:
 768       OnResetCanceled();
 769       break;
 770     case KIOSK_AUTOLAUNCH_CANCELED:
 771       OnKioskAutolaunchCanceled();
 772       break;
 773     case KIOSK_AUTOLAUNCH_CONFIRMED:
 774       OnKioskAutolaunchConfirmed();
 775       break;
 776     case KIOSK_ENABLE_COMPLETED:
 777       OnKioskEnableCompleted();
 778       break;
 779     case ENTERPRISE_AUTO_MAGIC_ENROLLMENT_COMPLETED:
 780       OnAutoEnrollmentDone();
 781       break;
 782     case TERMS_OF_SERVICE_DECLINED:
 783       OnTermsOfServiceDeclined();
 784       break;
 785     case TERMS_OF_SERVICE_ACCEPTED:
 786       OnTermsOfServiceAccepted();
 787       break;
 788     case WRONG_HWID_WARNING_SKIPPED:
 789       OnWrongHWIDWarningSkipped();
 790       break;
 791     default:
 792       NOTREACHED();
 793   }
 794 }
 795
 796 void WizardController::OnSetUserNamePassword(const std::string& username,
 797                                              const std::string& password) {
 798   username_ = username;
 799   password_ = password;
 800 }
 801
 802 void WizardController::SetUsageStatisticsReporting(bool val) {
 803   usage_statistics_reporting_ = val;
 804 }
 805
 806 bool WizardController::GetUsageStatisticsReporting() const {
 807   return usage_statistics_reporting_;
 808 }
 809
 810 chromeos::ErrorScreen* WizardController::GetErrorScreen() {
 811   if (!error_screen_.get()) {
 812     error_screen_.reset(
 813         new chromeos::ErrorScreen(this, oobe_display_->GetErrorScreenActor()));
 814   }
 815   return error_screen_.get();
 816 }
 817
 818 void WizardController::ShowErrorScreen() {
 819   VLOG(1) << "Showing error screen.";
 820   SetCurrentScreen(GetErrorScreen());
 821 }
 822
 823 void WizardController::HideErrorScreen(WizardScreen* parent_screen) {
 824   DCHECK(parent_screen);
 825   VLOG(1) << "Hiding error screen.";
 826   SetCurrentScreen(parent_screen);
 827 }
 828
 829 void WizardController::Observe(int type,
 830                                const content::NotificationSource& source,
 831                                const content::NotificationDetails& details) {
 832   if (type != chrome::NOTIFICATION_CROS_ACCESSIBILITY_TOGGLE_SPOKEN_FEEDBACK) {
 833     NOTREACHED();
 834     return;
 835   }
 836   const AccessibilityStatusEventDetails* a11y_details =
 837       content::Details<const AccessibilityStatusEventDetails>(details).ptr();
 838   CrasAudioHandler* cras = CrasAudioHandler::Get();
 839   if (!a11y_details->enabled)
 840     return;
 841   if (cras->IsOutputMuted()) {
 842     cras->SetOutputMute(false);
 843     cras->SetOutputVolumePercent(kMinAudibleOutputVolumePercent);
 844   } else if (cras->GetOutputVolumePercent() < kMinAudibleOutputVolumePercent) {
 845     cras->SetOutputVolumePercent(kMinAudibleOutputVolumePercent);
 846   }
 847 }
 848
 849 void WizardController::AutoLaunchKioskApp() {
 850   KioskAppManager::App app_data;
 851   std::string app_id = KioskAppManager::Get()->GetAutoLaunchApp();
 852   CHECK(KioskAppManager::Get()->GetApp(app_id, &app_data));
 853
 854   host_->StartAppLaunch(app_id, false /* diagnostic_mode */);
 855 }
 856
 857 // static
 858 void WizardController::SetZeroDelays() {
 859   kShowDelayMs = 0;
 860   zero_delay_enabled_ = true;
 861 }
 862
 863 // static
 864 bool WizardController::IsZeroDelayEnabled() {
 865   return zero_delay_enabled_;
 866 }
 867
 868 // static
 869 void WizardController::SkipPostLoginScreensForTesting() {
 870   skip_post_login_screens_ = true;
 871 }
 872
 873 // static
 874 bool WizardController::ShouldAutoStartEnrollment() {
 875   policy::BrowserPolicyConnectorChromeOS* connector =
 876       g_browser_process->platform_part()->browser_policy_connector_chromeos();
 877   return connector->GetDeviceCloudPolicyManager()->ShouldAutoStartEnrollment();
 878 }
 879
 880 bool WizardController::CanExitEnrollment() const {
 881   policy::BrowserPolicyConnectorChromeOS* connector =
 882       g_browser_process->platform_part()->browser_policy_connector_chromeos();
 883   return connector->GetDeviceCloudPolicyManager()->CanExitEnrollment();
 884 }
 885
 886 void WizardController::OnLocalStateInitialized(bool /* succeeded */) {
 887   if (GetLocalState()->GetInitializationStatus() !=
 888       PrefService::INITIALIZATION_STATUS_ERROR) {
 889     return;
 890   }
 891   GetErrorScreen()->SetUIState(ErrorScreen::UI_STATE_LOCAL_STATE_ERROR);
 892   SetStatusAreaVisible(false);
 893   ShowErrorScreen();
 894 }
 895
 896 PrefService* WizardController::GetLocalState() {
 897   if (local_state_for_testing_)
 898     return local_state_for_testing_;
 899   return g_browser_process->local_state();
 900 }
 901
 902 }  // namespace chromeos