cros: UpdateStatusAreaVisibility in WizardControllor::ShowCurrentScreen()

chrome/browser/chromeos/login/wizard_controller.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 
 #include <signal.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <sys/types.h>
@@ skipping 411 matching lines @@
   } else if (screen == OobeScreen::SCREEN_ENCRYPTION_MIGRATION) {
     return new EncryptionMigrationScreen(
         this, oobe_ui_->GetEncryptionMigrationScreenView());
   }
 
   return nullptr;
 }
 
 void WizardController::ShowNetworkScreen() {
   VLOG(1) << "Showing network screen.";
-  // Hide the status area initially; it only appears after OOBE first animates
-  // in. Keep it visible if the user goes back to the existing network screen.
-  SetStatusAreaVisible(
-      screen_manager_->HasScreen(OobeScreen::SCREEN_OOBE_NETWORK));
+  UpdateStatusAreaVisibilityForScreen(OobeScreen::SCREEN_OOBE_NETWORK);
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_OOBE_NETWORK));
 
   // There are two possible screens where we listen to the incoming Bluetooth
   // connection request: the first one is the HID detection screen, which will
   // show up when there is no sufficient input devices. In this case, we just
   // keep the logic as it is today: always put the Bluetooth is discoverable
   // mode. The other place is the Network screen (here), which will show up when
   // there are input devices detected. In this case, we disable the Bluetooth by
   // default until the user explicitly enable it by pressing a key combo (Ctrl+
   // Alt+Shift+S).
   if (IsBootstrappingSlave())
     MaybeStartListeningForSharkConnection();
 }
 
 void WizardController::ShowLoginScreen(const LoginScreenContext& context) {
   // This may be triggered by multiply asynchronous events from the JS side.
   if (login_screen_started_)
     return;
 
   if (!time_eula_accepted_.is_null()) {
     base::TimeDelta delta = base::Time::Now() - time_eula_accepted_;
     UMA_HISTOGRAM_MEDIUM_TIMES("OOBE.EULAToSignInTime", delta);
   }
   VLOG(1) << "Showing login screen.";
-  SetStatusAreaVisible(true);
+  UpdateStatusAreaVisibilityForScreen(OobeScreen::SCREEN_SPECIAL_LOGIN);
   host_->StartSignInScreen(context);
   smooth_show_timer_.Stop();
   login_screen_started_ = true;
 }
 
 void WizardController::ShowUpdateScreen() {
   VLOG(1) << "Showing update screen.";
-  SetStatusAreaVisible(true);
+  UpdateStatusAreaVisibilityForScreen(OobeScreen::SCREEN_OOBE_UPDATE);
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_OOBE_UPDATE));
 }
 
 void WizardController::ShowUserImageScreen() {
   const user_manager::UserManager* user_manager =
       user_manager::UserManager::Get();
   // Skip user image selection for public sessions and ephemeral non-regual user
   // logins.
   if (user_manager->IsLoggedInAsPublicAccount() ||
       (user_manager->IsCurrentUserNonCryptohomeDataEphemeral() &&
        user_manager->GetActiveUser()->GetType() !=
            user_manager::USER_TYPE_REGULAR)) {
     OnUserImageSkipped();
     return;
   }
   VLOG(1) << "Showing user image screen.";
 
   // Status area has been already shown at sign in screen so it
   // doesn't make sense to hide it here and then show again at user session as
   // this produces undesired UX transitions.
-  SetStatusAreaVisible(true);
+  UpdateStatusAreaVisibilityForScreen(OobeScreen::SCREEN_USER_IMAGE_PICKER);
 
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_USER_IMAGE_PICKER));
 }
 
 void WizardController::ShowEulaScreen() {
   VLOG(1) << "Showing EULA screen.";
-  SetStatusAreaVisible(true);
+  UpdateStatusAreaVisibilityForScreen(OobeScreen::SCREEN_OOBE_EULA);
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_OOBE_EULA));
 }
 
 void WizardController::ShowEnrollmentScreen() {
   // Update the enrollment configuration and start the screen.
   prescribed_enrollment_config_ = g_browser_process->platform_part()
                                       ->browser_policy_connector_chromeos()
                                       ->GetPrescribedEnrollmentConfig();
   StartEnrollmentScreen(false);
 }
 
 void WizardController::ShowResetScreen() {
   VLOG(1) << "Showing reset screen.";
-  SetStatusAreaVisible(false);
+  UpdateStatusAreaVisibilityForScreen(OobeScreen::SCREEN_OOBE_RESET);
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_OOBE_RESET));
 }
 
 void WizardController::ShowKioskEnableScreen() {
   VLOG(1) << "Showing kiosk enable screen.";
-  SetStatusAreaVisible(false);
+  UpdateStatusAreaVisibilityForScreen(OobeScreen::SCREEN_KIOSK_ENABLE);
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_KIOSK_ENABLE));
 }
 
 void WizardController::ShowKioskAutolaunchScreen() {
   VLOG(1) << "Showing kiosk autolaunch screen.";
-  SetStatusAreaVisible(false);
+  UpdateStatusAreaVisibilityForScreen(OobeScreen::SCREEN_KIOSK_AUTOLAUNCH);
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_KIOSK_AUTOLAUNCH));
 }
 
 void WizardController::ShowEnableDebuggingScreen() {
   VLOG(1) << "Showing enable developer features screen.";
-  SetStatusAreaVisible(false);
+  UpdateStatusAreaVisibilityForScreen(OobeScreen::SCREEN_OOBE_ENABLE_DEBUGGING);
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_OOBE_ENABLE_DEBUGGING));
 }
 
 void WizardController::ShowTermsOfServiceScreen() {
   // Only show the Terms of Service when logging into a public account and Terms
   // of Service have been specified through policy. In all other cases, advance
   // to the ARC opt-in screen immediately.
   if (!user_manager::UserManager::Get()->IsLoggedInAsPublicAccount() ||
       !ProfileManager::GetActiveUserProfile()->GetPrefs()->IsManagedPreference(
           prefs::kTermsOfServiceURL)) {
     ShowArcTermsOfServiceScreen();
     return;
   }
 
   VLOG(1) << "Showing Terms of Service screen.";
-  SetStatusAreaVisible(true);
+  UpdateStatusAreaVisibilityForScreen(OobeScreen::SCREEN_TERMS_OF_SERVICE);
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_TERMS_OF_SERVICE));
 }
 
 void WizardController::ShowArcTermsOfServiceScreen() {
   bool show_arc_terms = false;
   const Profile* profile = ProfileManager::GetActiveUserProfile();
 
   const base::CommandLine* command_line =
       base::CommandLine::ForCurrentProcess();
   if (!command_line->HasSwitch(chromeos::switches::kEnableArcOOBEOptIn)) {
     VLOG(1) << "Skip ARC Terms of Service screen because ARC OOBE OptIn is "
             << "disabled.";
   } else if (!user_manager::UserManager::Get()->IsUserLoggedIn()) {
     VLOG(1) << "Skip ARC Terms of Service screen because user is not "
             << "logged in.";
   } else if (!arc::IsArcAllowedForProfile(profile)) {
     VLOG(1) << "Skip ARC Terms of Service screen because ARC is not allowed.";
   } else if (profile->GetPrefs()->IsManagedPreference(prefs::kArcEnabled) &&
              !profile->GetPrefs()->GetBoolean(prefs::kArcEnabled)) {
     VLOG(1) << "Skip ARC Terms of Service screen because ARC is disabled.";
   } else {
     show_arc_terms = true;
   }
 
   if (show_arc_terms) {
     VLOG(1) << "Showing ARC Terms of Service screen.";
-    SetStatusAreaVisible(true);
+    UpdateStatusAreaVisibilityForScreen(
+        OobeScreen::SCREEN_ARC_TERMS_OF_SERVICE);
     SetCurrentScreen(GetScreen(OobeScreen::SCREEN_ARC_TERMS_OF_SERVICE));
   } else {
     ShowUserImageScreen();
   }
 }
 
 void WizardController::ShowWrongHWIDScreen() {
   VLOG(1) << "Showing wrong HWID screen.";
-  SetStatusAreaVisible(false);
+  UpdateStatusAreaVisibilityForScreen(OobeScreen::SCREEN_WRONG_HWID);
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_WRONG_HWID));
 }
 
 void WizardController::ShowAutoEnrollmentCheckScreen() {
   VLOG(1) << "Showing Auto-enrollment check screen.";
-  SetStatusAreaVisible(true);
+  UpdateStatusAreaVisibilityForScreen(OobeScreen::SCREEN_AUTO_ENROLLMENT_CHECK);
   AutoEnrollmentCheckScreen* screen =
       AutoEnrollmentCheckScreen::Get(screen_manager());
   if (retry_auto_enrollment_check_)
     screen->ClearState();
   screen->set_auto_enrollment_controller(host_->GetAutoEnrollmentController());
   SetCurrentScreen(screen);
 }
 
 void WizardController::ShowSupervisedUserCreationScreen() {
   VLOG(1) << "Showing Locally managed user creation screen screen.";
-  SetStatusAreaVisible(true);
+  UpdateStatusAreaVisibilityForScreen(
+      OobeScreen::SCREEN_CREATE_SUPERVISED_USER_FLOW);
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_CREATE_SUPERVISED_USER_FLOW));
 }
 
 void WizardController::ShowArcKioskSplashScreen() {
   VLOG(1) << "Showing ARC kiosk splash screen.";
-  SetStatusAreaVisible(false);
+  UpdateStatusAreaVisibilityForScreen(OobeScreen::SCREEN_ARC_KIOSK_SPLASH);
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_ARC_KIOSK_SPLASH));
 }
 
 void WizardController::ShowHIDDetectionScreen() {
   VLOG(1) << "Showing HID discovery screen.";
-  SetStatusAreaVisible(true);
+  UpdateStatusAreaVisibilityForScreen(OobeScreen::SCREEN_OOBE_HID_DETECTION);
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_OOBE_HID_DETECTION));
   // In HID detection screen, puts the Bluetooth in discoverable mode and waits
   // for the incoming Bluetooth connection request. See the comments in
   // WizardController::ShowNetworkScreen() for more details.
   MaybeStartListeningForSharkConnection();
 }
 
 void WizardController::ShowControllerPairingScreen() {
   VLOG(1) << "Showing controller pairing screen.";
-  SetStatusAreaVisible(false);
+  UpdateStatusAreaVisibilityForScreen(
+      OobeScreen::SCREEN_OOBE_CONTROLLER_PAIRING);
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_OOBE_CONTROLLER_PAIRING));
 }
 
 void WizardController::ShowHostPairingScreen() {
   VLOG(1) << "Showing host pairing screen.";
-  SetStatusAreaVisible(false);
+  UpdateStatusAreaVisibilityForScreen(OobeScreen::SCREEN_OOBE_HOST_PAIRING);
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_OOBE_HOST_PAIRING));
 }
 
 void WizardController::ShowDeviceDisabledScreen() {
   VLOG(1) << "Showing device disabled screen.";
-  SetStatusAreaVisible(true);
+  UpdateStatusAreaVisibilityForScreen(OobeScreen::SCREEN_DEVICE_DISABLED);
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_DEVICE_DISABLED));
 }
 
 void WizardController::ShowEncryptionMigrationScreen() {
   VLOG(1) << "Showing encryption migration screen.";
-  SetStatusAreaVisible(true);
+  UpdateStatusAreaVisibilityForScreen(OobeScreen::SCREEN_ENCRYPTION_MIGRATION);
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_ENCRYPTION_MIGRATION));
 }
 
 void WizardController::SkipToLoginForTesting(
     const LoginScreenContext& context) {
   VLOG(1) << "SkipToLoginForTesting.";
   StartupUtils::MarkEulaAccepted();
   PerformPostEulaActions();
   OnDeviceDisabledChecked(false /* device_disabled */);
 }
@@ skipping 316 matching lines @@
     return;
 
   // First remember how far have we reached so that we can resume if needed.
   if (is_out_of_box_ && IsResumableScreen(current_screen_->screen_id())) {
     StartupUtils::SaveOobePendingScreen(
         GetOobeScreenName(current_screen_->screen_id()));
   }
 
   smooth_show_timer_.Stop();
 
+  UpdateStatusAreaVisibilityForScreen(current_screen_->screen_id());
   current_screen_->Show();
 }
 
 void WizardController::SetCurrentScreenSmooth(BaseScreen* new_current,
                                               bool use_smoothing) {
   if (current_screen_ == new_current || new_current == nullptr ||
       oobe_ui_ == nullptr) {
     return;
   }
 
@@ skipping 15 matching lines @@
     smooth_show_timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromMilliseconds(kShowDelayMs),
         this,
         &WizardController::ShowCurrentScreen);
   } else {
     ShowCurrentScreen();
   }
 }
 
-void WizardController::SetStatusAreaVisible(bool visible) {
-  host_->SetStatusAreaVisible(visible);
+void WizardController::UpdateStatusAreaVisibilityForScreen(OobeScreen screen) {
+  if (screen == OobeScreen::SCREEN_OOBE_NETWORK) {
+    // Hide the status area initially; it only appears after OOBE first animates
+    // in. Keep it visible if the user goes back to the existing network screen.
+    host_->SetStatusAreaVisible(
+        screen_manager_->HasScreen(OobeScreen::SCREEN_OOBE_NETWORK));
+  } else if (screen == OobeScreen::SCREEN_OOBE_RESET ||
+             screen == OobeScreen::SCREEN_KIOSK_ENABLE ||
+             screen == OobeScreen::SCREEN_KIOSK_AUTOLAUNCH ||
+             screen == OobeScreen::SCREEN_OOBE_ENABLE_DEBUGGING ||
+             screen == OobeScreen::SCREEN_WRONG_HWID ||
+             screen == OobeScreen::SCREEN_ARC_KIOSK_SPLASH ||
+             screen == OobeScreen::SCREEN_OOBE_CONTROLLER_PAIRING ||
+             screen == OobeScreen::SCREEN_OOBE_HOST_PAIRING) {
+    host_->SetStatusAreaVisible(false);
+  } else {
+    host_->SetStatusAreaVisible(true);
+  }
 }
 
 void WizardController::SetShowMdOobe(bool show) {
   GetLocalState()->SetBoolean(prefs::kOobeMdMode, show);
 }
 
 void WizardController::OnHIDScreenNecessityCheck(bool screen_needed) {
   if (!oobe_ui_)
     return;
 
@@ skipping 282 matching lines @@
       CrosSettings::Get()->PrepareTrustedValues(base::Bind(
           &WizardController::AutoLaunchKioskApp,
           weak_factory_.GetWeakPtr()));
   if (status == CrosSettingsProvider::TEMPORARILY_UNTRUSTED)
     return;
 
   if (status == CrosSettingsProvider::PERMANENTLY_UNTRUSTED) {
     // If the |cros_settings_| are permanently untrusted, show an error message
     // and refuse to auto-launch the kiosk app.
     GetErrorScreen()->SetUIState(NetworkError::UI_STATE_LOCAL_STATE_ERROR);
-    SetStatusAreaVisible(false);
+    host_->SetStatusAreaVisible(false);
     ShowErrorScreen();
     return;
   }
 
   bool device_disabled = false;
   CrosSettings::Get()->GetBoolean(kDeviceDisabled, &device_disabled);
   if (device_disabled && system::DeviceDisablingManager::
                              HonorDeviceDisablingDuringNormalOperation()) {
     // If the device is disabled, bail out. A device disabled screen will be
     // shown by the DeviceDisablingManager.
@@ skipping 31 matching lines @@
 void WizardController::SkipPostLoginScreensForTesting() {
   skip_post_login_screens_ = true;
 }
 
 void WizardController::OnLocalStateInitialized(bool /* succeeded */) {
   if (GetLocalState()->GetInitializationStatus() !=
       PrefService::INITIALIZATION_STATUS_ERROR) {
     return;
   }
   GetErrorScreen()->SetUIState(NetworkError::UI_STATE_LOCAL_STATE_ERROR);
-  SetStatusAreaVisible(false);
+  host_->SetStatusAreaVisible(false);
   ShowErrorScreen();
 }
 
 PrefService* WizardController::GetLocalState() {
   if (local_state_for_testing_)
     return local_state_for_testing_;
   return g_browser_process->local_state();
 }
 
 void WizardController::OnTimezoneResolved(
@@ skipping 135 matching lines @@
   if (!effective_config.should_enroll() ||
       (force_interactive && !effective_config.should_enroll_interactively())) {
     effective_config.mode =
         prescribed_enrollment_config_.management_domain.empty()
             ? policy::EnrollmentConfig::MODE_MANUAL
             : policy::EnrollmentConfig::MODE_MANUAL_REENROLLMENT;
   }
 
   EnrollmentScreen* screen = EnrollmentScreen::Get(screen_manager());
   screen->SetParameters(effective_config, shark_controller_.get());
-  SetStatusAreaVisible(true);
+  UpdateStatusAreaVisibilityForScreen(OobeScreen::SCREEN_OOBE_ENROLLMENT);
   SetCurrentScreen(screen);
 }
 
 }  // namespace chromeos