cros: Replace WizardController string constants with OobeScreen values.

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 84 matching lines @@
 using content::BrowserThread;
 
 namespace {
 // Interval in ms which is used for smooth screen showing.
 static int kShowDelayMs = 400;
 
 // Total timezone resolving process timeout.
 const unsigned int kResolveTimeZoneTimeoutSeconds = 60;
 
 // Stores the list of all screens that should be shown when resuming OOBE.
-const char* kResumableScreens[] = {
-    chromeos::WizardController::kNetworkScreenName,
-    chromeos::WizardController::kUpdateScreenName,
-    chromeos::WizardController::kEulaScreenName,
-    chromeos::WizardController::kEnrollmentScreenName,
-    chromeos::WizardController::kTermsOfServiceScreenName,
-    chromeos::WizardController::kArcTermsOfServiceScreenName,
-    chromeos::WizardController::kAutoEnrollmentCheckScreenName};
+const chromeos::OobeScreen kResumableScreens[] = {
+    chromeos::OobeScreen::SCREEN_OOBE_NETWORK,
+    chromeos::OobeScreen::SCREEN_OOBE_UPDATE,
+    chromeos::OobeScreen::SCREEN_OOBE_EULA,
+    chromeos::OobeScreen::SCREEN_OOBE_ENROLLMENT,
+    chromeos::OobeScreen::SCREEN_TERMS_OF_SERVICE,
+    chromeos::OobeScreen::SCREEN_ARC_TERMS_OF_SERVICE,
+    chromeos::OobeScreen::SCREEN_AUTO_ENROLLMENT_CHECK};
 
 // Checks flag for HID-detection screen show.
 bool CanShowHIDDetectionScreen() {
   return !base::CommandLine::ForCurrentProcess()->HasSwitch(
       chromeos::switches::kDisableHIDDetectionOnOOBE);
 }
 
-bool IsResumableScreen(const std::string& screen) {
+bool IsResumableScreen(chromeos::OobeScreen screen) {
   for (size_t i = 0; i < arraysize(kResumableScreens); ++i) {
     if (screen == kResumableScreens[i])
       return true;
   }
   return false;
 }
 
-void RecordUMAHistogramForOOBEStepCompletionTime(std::string screen_name,
+void RecordUMAHistogramForOOBEStepCompletionTime(chromeos::OobeScreen screen,
                                                  base::TimeDelta step_time) {
+  // Fetch screen name. Some of the screens had multiple different names in the
+  // past which have been unified. We need to use the old names though when
+  // recording UMA histograms.
+  std::string screen_name = chromeos::GetOobeScreenName(screen);
+  if (screen == chromeos::OobeScreen::SCREEN_ARC_TERMS_OF_SERVICE)
+    screen_name = "arc_tos";
+  else if (screen == chromeos::OobeScreen::SCREEN_OOBE_ENROLLMENT)
+    screen_name = "enroll";
+  else if (screen == chromeos::OobeScreen::SCREEN_OOBE_NETWORK)
+    screen_name = "network";
+  else if (screen == chromeos::OobeScreen::SCREEN_CREATE_SUPERVISED_USER_FLOW)
+    screen_name = "supervised-user-creation-flow";
+  else if (screen == chromeos::OobeScreen::SCREEN_TERMS_OF_SERVICE)
+    screen_name = "tos";
+  else if (screen == chromeos::OobeScreen::SCREEN_USER_IMAGE_PICKER)
+    screen_name = "image";
+

[Alexander Alekseev, 2016/12/13 03:08:05]

Why is the full set of names not supported now?

[jdufault, 2016/12/13 22:30:27]

The full set of names is being used; these are just the string constants whose
names have changed (but we want to continue reporting under the same UMA key).

   screen_name[0] = std::toupper(screen_name[0]);
   std::string histogram_name = "OOBE.StepCompletionTime." + screen_name;
   // Equivalent to using UMA_HISTOGRAM_MEDIUM_TIMES. UMA_HISTOGRAM_MEDIUM_TIMES
   // can not be used here, because |histogram_name| is calculated dynamically
   // and changes from call to call.
   base::HistogramBase* histogram = base::Histogram::FactoryTimeGet(
       histogram_name,
       base::TimeDelta::FromMilliseconds(10),
       base::TimeDelta::FromMinutes(3),
       50,
@@ skipping 57 matching lines @@
   // The crash reporter initialization needs IO to complete.
   DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   breakpad::InitCrashReporter(std::string());
 }
 #endif
 
 }  // namespace
 
 namespace chromeos {
 
-const char WizardController::kNetworkScreenName[] = "network";
-const char WizardController::kLoginScreenName[] = "login";
-const char WizardController::kUpdateScreenName[] = "update";
-const char WizardController::kUserImageScreenName[] = "image";
-const char WizardController::kEulaScreenName[] = "eula";
-const char WizardController::kEnableDebuggingScreenName[] = "debugging";
-const char WizardController::kEnrollmentScreenName[] = "enroll";
-const char WizardController::kResetScreenName[] = "reset";
-const char WizardController::kKioskEnableScreenName[] = "kiosk-enable";
-const char WizardController::kKioskAutolaunchScreenName[] = "autolaunch";
-const char WizardController::kErrorScreenName[] = "error-message";
-const char WizardController::kTermsOfServiceScreenName[] = "tos";
-const char WizardController::kArcTermsOfServiceScreenName[] = "arc_tos";
-const char WizardController::kAutoEnrollmentCheckScreenName[] =
-  "auto-enrollment-check";
-const char WizardController::kWrongHWIDScreenName[] = "wrong-hwid";
-const char WizardController::kSupervisedUserCreationScreenName[] =
-  "supervised-user-creation-flow";
-const char WizardController::kAppLaunchSplashScreenName[] =
-  "app-launch-splash";
-const char WizardController::kHIDDetectionScreenName[] = "hid-detection";
-const char WizardController::kControllerPairingScreenName[] =
-    "controller-pairing";
-const char WizardController::kHostPairingScreenName[] = "host-pairing";
-const char WizardController::kDeviceDisabledScreenName[] = "device-disabled";
-
 // static
 const int WizardController::kMinAudibleOutputVolumePercent = 10;
 
-// Passing this parameter as a "first screen" initiates full OOBE flow.
-const char WizardController::kOutOfBoxScreenName[] = "oobe";
-
-// Special test value that commands not to create any window yet.
-const char WizardController::kTestNoScreenName[] = "test:nowindow";
-
 // Initialize default controller.
 // static
 WizardController* WizardController::default_controller_ = nullptr;
 
 // static
 bool WizardController::skip_post_login_screens_ = false;
 
 // static
 bool WizardController::zero_delay_enabled_ = false;
 
@@ skipping 22 matching lines @@
     base::ThreadTaskRunnerHandle::Get()->DeleteSoon(
         FROM_HERE, shark_connection_listener_.release());
   }
   if (default_controller_ == this) {
     default_controller_ = nullptr;
   } else {
     NOTREACHED() << "More than one controller are alive.";
   }
 }
 
-void WizardController::Init(const std::string& first_screen_name) {
-  VLOG(1) << "Starting OOBE wizard with screen: " << first_screen_name;
+void WizardController::Init(OobeScreen first_screen_name) {
+  VLOG(1) << "Starting OOBE wizard with screen: "
+          << GetOobeScreenName(first_screen_name);
   first_screen_name_ = first_screen_name;
 
   bool oobe_complete = StartupUtils::IsOobeCompleted();
-  if (!oobe_complete || first_screen_name == kOutOfBoxScreenName)
+  if (!oobe_complete || first_screen_name == OobeScreen::SCREEN_SPECIAL_OOBE)
     is_out_of_box_ = true;
 
   // This is a hacky way to check for local state corruption, because
   // it depends on the fact that the local state is loaded
   // synchronously and at the first demand. IsEnterpriseManaged()
   // check is required because currently powerwash is disabled for
   // enterprise-enrolled devices.
   //
   // TODO (ygorshenin@): implement handling of the local state
   // corruption in the case of asynchronious loading.
@@ skipping 15 matching lines @@
   // If the device is a Master device in bootstrapping process (mostly for demo
   // and test purpose), start the enrollment OOBE flow.
   if (IsBootstrappingMaster())
     connector->GetDeviceCloudPolicyManager()->SetDeviceEnrollmentAutoStart();
 
   // Use the saved screen preference from Local State.
   const std::string screen_pref =
       GetLocalState()->GetString(prefs::kOobeScreenPending);
   if (is_out_of_box_ && !screen_pref.empty() && !IsRemoraPairingOobe() &&
       !IsControllerDetected() &&
-      (first_screen_name.empty() ||
-       first_screen_name == WizardController::kTestNoScreenName)) {
-    first_screen_name_ = screen_pref;
+      (first_screen_name == OobeScreen::SCREEN_UNKNOWN ||
+       first_screen_name == OobeScreen::SCREEN_TEST_NO_WINDOW)) {
+    first_screen_name_ = GetOobeScreenFromName(screen_pref);
   }
   // We need to reset the kOobeControllerDetected pref to allow the user to have
   // the choice to setup the device manually. The pref will be set properly if
   // an eligible controller is detected later.
   SetControllerDetectedPref(false);
 
   // Show Material Design unless explicitly disabled or for an untested UX,
   // or when resuming an OOBE that had it disabled or unset. We use an if/else
   // here to try and not set state when it is the default value so it can
   // change and affect the OOBE again.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kDisableMdOobe))
     SetShowMdOobe(false);
   else if ((screen_pref.empty() ||
             GetLocalState()->HasPrefPath(prefs::kOobeMdMode)) ||
            GetLocalState()->GetBoolean(prefs::kOobeMdMode))
     SetShowMdOobe(true);
 
   // TODO(drcrash): Remove this after testing (http://crbug.com/647411).
   if (IsRemoraPairingOobe() || IsSharkRequisition() || IsRemoraRequisition()) {
     SetShowMdOobe(false);
   }
 
   AdvanceToScreen(first_screen_name_);
   if (!IsMachineHWIDCorrect() && !StartupUtils::IsDeviceRegistered() &&
-      first_screen_name_.empty())
+      first_screen_name_ == OobeScreen::SCREEN_UNKNOWN)
     ShowWrongHWIDScreen();
 }
 
 ErrorScreen* WizardController::GetErrorScreen() {
   return oobe_ui_->GetErrorScreen();
 }
 
-BaseScreen* WizardController::GetScreen(const std::string& screen_name) {
-  if (screen_name == kErrorScreenName)
+BaseScreen* WizardController::GetScreen(OobeScreen screen) {
+  if (screen == OobeScreen::SCREEN_ERROR_MESSAGE)
     return GetErrorScreen();
-  return ScreenManager::GetScreen(screen_name);
+  return ScreenManager::GetScreen(screen);
 }
 
-BaseScreen* WizardController::CreateScreen(const std::string& screen_name) {
-  if (screen_name == kNetworkScreenName) {
+BaseScreen* WizardController::CreateScreen(OobeScreen screen) {
+  if (screen == OobeScreen::SCREEN_OOBE_NETWORK) {
     std::unique_ptr<NetworkScreen> screen(
         new NetworkScreen(this, this, oobe_ui_->GetNetworkView()));
     screen->Initialize(nullptr /* context */);
     return screen.release();
-  } else if (screen_name == kUpdateScreenName) {
+  } else if (screen == OobeScreen::SCREEN_OOBE_UPDATE) {
     std::unique_ptr<UpdateScreen> screen(new UpdateScreen(
         this, oobe_ui_->GetUpdateView(), remora_controller_.get()));
     screen->Initialize(nullptr /* context */);
     return screen.release();
-  } else if (screen_name == kUserImageScreenName) {
+  } else if (screen == OobeScreen::SCREEN_USER_IMAGE_PICKER) {
     return new UserImageScreen(this, oobe_ui_->GetUserImageView());
-  } else if (screen_name == kEulaScreenName) {
+  } else if (screen == OobeScreen::SCREEN_OOBE_EULA) {
     return new EulaScreen(this, this, oobe_ui_->GetEulaView());
-  } else if (screen_name == kEnrollmentScreenName) {
+  } else if (screen == OobeScreen::SCREEN_OOBE_ENROLLMENT) {
     return new EnrollmentScreen(this, oobe_ui_->GetEnrollmentScreenActor());
-  } else if (screen_name == kResetScreenName) {
+  } else if (screen == OobeScreen::SCREEN_OOBE_RESET) {
     return new chromeos::ResetScreen(this, oobe_ui_->GetResetView());
-  } else if (screen_name == kEnableDebuggingScreenName) {
+  } else if (screen == OobeScreen::SCREEN_OOBE_ENABLE_DEBUGGING) {
     return new EnableDebuggingScreen(this,
                                      oobe_ui_->GetEnableDebuggingScreenActor());
-  } else if (screen_name == kKioskEnableScreenName) {
+  } else if (screen == OobeScreen::SCREEN_KIOSK_ENABLE) {
     return new KioskEnableScreen(this, oobe_ui_->GetKioskEnableScreenActor());
-  } else if (screen_name == kKioskAutolaunchScreenName) {
+  } else if (screen == OobeScreen::SCREEN_KIOSK_AUTOLAUNCH) {
     return new KioskAutolaunchScreen(this,
                                      oobe_ui_->GetKioskAutolaunchScreenActor());
-  } else if (screen_name == kTermsOfServiceScreenName) {
+  } else if (screen == OobeScreen::SCREEN_TERMS_OF_SERVICE) {
     return new TermsOfServiceScreen(this,
                                     oobe_ui_->GetTermsOfServiceScreenActor());
-  } else if (screen_name == kArcTermsOfServiceScreenName) {
+  } else if (screen == OobeScreen::SCREEN_ARC_TERMS_OF_SERVICE) {
     return new ArcTermsOfServiceScreen(
         this, oobe_ui_->GetArcTermsOfServiceScreenActor());
-  } else if (screen_name == kWrongHWIDScreenName) {
+  } else if (screen == OobeScreen::SCREEN_WRONG_HWID) {
     return new WrongHWIDScreen(this, oobe_ui_->GetWrongHWIDScreenActor());
-  } else if (screen_name == kSupervisedUserCreationScreenName) {
+  } else if (screen == OobeScreen::SCREEN_CREATE_SUPERVISED_USER_FLOW) {
     return new SupervisedUserCreationScreen(
         this, oobe_ui_->GetSupervisedUserCreationScreenActor());
-  } else if (screen_name == kHIDDetectionScreenName) {
+  } else if (screen == OobeScreen::SCREEN_OOBE_HID_DETECTION) {
     std::unique_ptr<HIDDetectionScreen> screen(new chromeos::HIDDetectionScreen(
         this, oobe_ui_->GetHIDDetectionView()));
     screen->Initialize(nullptr /* context */);
     return screen.release();
-  } else if (screen_name == kAutoEnrollmentCheckScreenName) {
+  } else if (screen == OobeScreen::SCREEN_AUTO_ENROLLMENT_CHECK) {
     return new AutoEnrollmentCheckScreen(
         this, oobe_ui_->GetAutoEnrollmentCheckScreenActor());
-  } else if (screen_name == kControllerPairingScreenName) {
+  } else if (screen == OobeScreen::SCREEN_OOBE_CONTROLLER_PAIRING) {
     if (!shark_controller_) {
       shark_controller_.reset(
           new pairing_chromeos::BluetoothControllerPairingController());
     }
     return new ControllerPairingScreen(
         this, this, oobe_ui_->GetControllerPairingScreenActor(),
         shark_controller_.get());
-  } else if (screen_name == kHostPairingScreenName) {
+  } else if (screen == OobeScreen::SCREEN_OOBE_HOST_PAIRING) {
     if (!remora_controller_) {
       remora_controller_.reset(
           new pairing_chromeos::BluetoothHostPairingController(
               BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE)));
       remora_controller_->StartPairing();
     }
     return new HostPairingScreen(this, this,
                                  oobe_ui_->GetHostPairingScreenActor(),
                                  remora_controller_.get());
-  } else if (screen_name == kDeviceDisabledScreenName) {
+  } else if (screen == OobeScreen::SCREEN_DEVICE_DISABLED) {
     return new DeviceDisabledScreen(this,
                                     oobe_ui_->GetDeviceDisabledScreenActor());
   }
 
   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(HasScreen(kNetworkScreenName));
-  SetCurrentScreen(GetScreen(kNetworkScreenName));
+  SetStatusAreaVisible(HasScreen(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())
@@ skipping 12 matching lines @@
   VLOG(1) << "Showing login screen.";
   SetStatusAreaVisible(true);
   host_->StartSignInScreen(context);
   smooth_show_timer_.Stop();
   login_screen_started_ = true;
 }
 
 void WizardController::ShowUpdateScreen() {
   VLOG(1) << "Showing update screen.";
   SetStatusAreaVisible(true);
-  SetCurrentScreen(GetScreen(kUpdateScreenName));
+  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);
 
-  SetCurrentScreen(GetScreen(kUserImageScreenName));
+  SetCurrentScreen(GetScreen(OobeScreen::SCREEN_USER_IMAGE_PICKER));
 }
 
 void WizardController::ShowEulaScreen() {
   VLOG(1) << "Showing EULA screen.";
   SetStatusAreaVisible(true);
-  SetCurrentScreen(GetScreen(kEulaScreenName));
+  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);
-  SetCurrentScreen(GetScreen(kResetScreenName));
+  SetCurrentScreen(GetScreen(OobeScreen::SCREEN_OOBE_RESET));
 }
 
 void WizardController::ShowKioskEnableScreen() {
   VLOG(1) << "Showing kiosk enable screen.";
   SetStatusAreaVisible(false);
-  SetCurrentScreen(GetScreen(kKioskEnableScreenName));
+  SetCurrentScreen(GetScreen(OobeScreen::SCREEN_KIOSK_ENABLE));
 }
 
 void WizardController::ShowKioskAutolaunchScreen() {
   VLOG(1) << "Showing kiosk autolaunch screen.";
   SetStatusAreaVisible(false);
-  SetCurrentScreen(GetScreen(kKioskAutolaunchScreenName));
+  SetCurrentScreen(GetScreen(OobeScreen::SCREEN_KIOSK_AUTOLAUNCH));
 }
 
 void WizardController::ShowEnableDebuggingScreen() {
   VLOG(1) << "Showing enable developer features screen.";
   SetStatusAreaVisible(false);
-  SetCurrentScreen(GetScreen(kEnableDebuggingScreenName));
+  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);
-  SetCurrentScreen(GetScreen(kTermsOfServiceScreenName));
+  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::ArcSessionManager::IsAllowedForProfile(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);
-    SetCurrentScreen(GetScreen(kArcTermsOfServiceScreenName));
+    SetCurrentScreen(GetScreen(OobeScreen::SCREEN_ARC_TERMS_OF_SERVICE));
   } else {
     ShowUserImageScreen();
   }
 }
 
 void WizardController::ShowWrongHWIDScreen() {
   VLOG(1) << "Showing wrong HWID screen.";
   SetStatusAreaVisible(false);
-  SetCurrentScreen(GetScreen(kWrongHWIDScreenName));
+  SetCurrentScreen(GetScreen(OobeScreen::SCREEN_WRONG_HWID));
 }
 
 void WizardController::ShowAutoEnrollmentCheckScreen() {
   VLOG(1) << "Showing Auto-enrollment check screen.";
   SetStatusAreaVisible(true);
   AutoEnrollmentCheckScreen* screen = AutoEnrollmentCheckScreen::Get(this);
   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);
-  SetCurrentScreen(GetScreen(kSupervisedUserCreationScreenName));
+  SetCurrentScreen(GetScreen(OobeScreen::SCREEN_CREATE_SUPERVISED_USER_FLOW));
 }
 
 void WizardController::ShowHIDDetectionScreen() {
   VLOG(1) << "Showing HID discovery screen.";
   // TODO(drcrash): Remove this after testing (http://crbug.com/647411).
   SetShowMdOobe(false);  // Disable the MD OOBE from there on.
   SetStatusAreaVisible(true);
-  SetCurrentScreen(GetScreen(kHIDDetectionScreenName));
+  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);
-  SetCurrentScreen(GetScreen(kControllerPairingScreenName));
+  SetCurrentScreen(GetScreen(OobeScreen::SCREEN_OOBE_CONTROLLER_PAIRING));
 }
 
 void WizardController::ShowHostPairingScreen() {
   VLOG(1) << "Showing host pairing screen.";
   SetStatusAreaVisible(false);
-  SetCurrentScreen(GetScreen(kHostPairingScreenName));
+  SetCurrentScreen(GetScreen(OobeScreen::SCREEN_OOBE_HOST_PAIRING));
 }
 
 void WizardController::ShowDeviceDisabledScreen() {
   VLOG(1) << "Showing device disabled screen.";
   SetStatusAreaVisible(true);
-  SetCurrentScreen(GetScreen(kDeviceDisabledScreenName));
+  SetCurrentScreen(GetScreen(OobeScreen::SCREEN_DEVICE_DISABLED));
 }
 
 void WizardController::SkipToLoginForTesting(
     const LoginScreenContext& context) {
   VLOG(1) << "SkipToLoginForTesting.";
   StartupUtils::MarkEulaAccepted();
   PerformPostEulaActions();
   OnDeviceDisabledChecked(false /* device_disabled */);
 }
 
@@ skipping 241 matching lines @@
 }
 
 void WizardController::InitiateOOBEUpdate() {
   if (IsRemoraRequisition()) {
     VLOG(1) << "Skip OOBE Update for remora.";
     OnUpdateCompleted();
     return;
   }
 
   VLOG(1) << "InitiateOOBEUpdate";
-  SetCurrentScreenSmooth(GetScreen(kUpdateScreenName), true);
+  SetCurrentScreenSmooth(GetScreen(OobeScreen::SCREEN_OOBE_UPDATE), true);
   UpdateScreen::Get(this)->StartNetworkCheck();
 }
 
 void WizardController::StartTimezoneResolve() {
   geolocation_provider_.reset(new SimpleGeolocationProvider(
       g_browser_process->system_request_context(),
       SimpleGeolocationProvider::DefaultGeolocationProviderURL()));
   geolocation_provider_->RequestGeolocation(
       base::TimeDelta::FromSeconds(kResolveTimeZoneTimeoutSeconds),
       false /* send_wifi_geolocation_data */,
@@ skipping 42 matching lines @@
   SetCurrentScreenSmooth(new_current, false);
 }
 
 void WizardController::ShowCurrentScreen() {
   // ShowCurrentScreen may get called by smooth_show_timer_ even after
   // flow has been switched to sign in screen (ExistingUserController).
   if (!oobe_ui_)
     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(current_screen_->screen_id());
+  if (is_out_of_box_ && IsResumableScreen(current_screen_->screen_id())) {
+    StartupUtils::SaveOobePendingScreen(
+        GetOobeScreenName(current_screen_->screen_id()));
+  }
 
   smooth_show_timer_.Stop();
 
   for (auto& observer : observer_list_)
     observer.OnScreenChanged(current_screen_);
 
   current_screen_->Show();
 }
 
 void WizardController::SetCurrentScreenSmooth(BaseScreen* new_current,
                                               bool use_smoothing) {
   if (current_screen_ == new_current || new_current == nullptr ||
       oobe_ui_ == nullptr) {
     return;
   }
 
   smooth_show_timer_.Stop();
 
   if (current_screen_)
     current_screen_->Hide();
 
-  std::string screen_id = new_current->screen_id();
-  if (IsOOBEStepToTrack(screen_id))
-    screen_show_times_[screen_id] = base::Time::Now();
+  OobeScreen screen = new_current->screen_id();
+  if (IsOOBEStepToTrack(screen))
+    screen_show_times_[GetOobeScreenName(screen)] = base::Time::Now();
 
   previous_screen_ = current_screen_;
   current_screen_ = new_current;
 
   if (use_smoothing) {
     smooth_show_timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromMilliseconds(kShowDelayMs),
         this,
         &WizardController::ShowCurrentScreen);
@@ skipping 14 matching lines @@
   if (!oobe_ui_)
     return;
 
   if (screen_needed) {
     ShowHIDDetectionScreen();
   } else {
     ShowNetworkScreen();
   }
 }
 
-void WizardController::AdvanceToScreen(const std::string& screen_name) {
-  if (screen_name == kNetworkScreenName) {
+void WizardController::AdvanceToScreen(OobeScreen screen) {
+  if (screen == OobeScreen::SCREEN_OOBE_NETWORK) {
     ShowNetworkScreen();
-  } else if (screen_name == kLoginScreenName) {
+  } else if (screen == OobeScreen::SCREEN_SPECIAL_LOGIN) {
     ShowLoginScreen(LoginScreenContext());
-  } else if (screen_name == kUpdateScreenName) {
+  } else if (screen == OobeScreen::SCREEN_OOBE_UPDATE) {
     InitiateOOBEUpdate();
-  } else if (screen_name == kUserImageScreenName) {
+  } else if (screen == OobeScreen::SCREEN_USER_IMAGE_PICKER) {
     ShowUserImageScreen();
-  } else if (screen_name == kEulaScreenName) {
+  } else if (screen == OobeScreen::SCREEN_OOBE_EULA) {
     ShowEulaScreen();
-  } else if (screen_name == kResetScreenName) {
+  } else if (screen == OobeScreen::SCREEN_OOBE_RESET) {
     ShowResetScreen();
-  } else if (screen_name == kKioskEnableScreenName) {
+  } else if (screen == OobeScreen::SCREEN_KIOSK_ENABLE) {
     ShowKioskEnableScreen();
-  } else if (screen_name == kKioskAutolaunchScreenName) {
+  } else if (screen == OobeScreen::SCREEN_KIOSK_AUTOLAUNCH) {
     ShowKioskAutolaunchScreen();
-  } else if (screen_name == kEnableDebuggingScreenName) {
+  } else if (screen == OobeScreen::SCREEN_OOBE_ENABLE_DEBUGGING) {
     ShowEnableDebuggingScreen();
-  } else if (screen_name == kEnrollmentScreenName) {
+  } else if (screen == OobeScreen::SCREEN_OOBE_ENROLLMENT) {
     ShowEnrollmentScreen();
-  } else if (screen_name == kTermsOfServiceScreenName) {
+  } else if (screen == OobeScreen::SCREEN_TERMS_OF_SERVICE) {
     ShowTermsOfServiceScreen();
-  } else if (screen_name == kArcTermsOfServiceScreenName) {
+  } else if (screen == OobeScreen::SCREEN_ARC_TERMS_OF_SERVICE) {
     ShowArcTermsOfServiceScreen();
-  } else if (screen_name == kWrongHWIDScreenName) {
+  } else if (screen == OobeScreen::SCREEN_WRONG_HWID) {
     ShowWrongHWIDScreen();
-  } else if (screen_name == kAutoEnrollmentCheckScreenName) {
+  } else if (screen == OobeScreen::SCREEN_AUTO_ENROLLMENT_CHECK) {
     ShowAutoEnrollmentCheckScreen();
-  } else if (screen_name == kSupervisedUserCreationScreenName) {
+  } else if (screen == OobeScreen::SCREEN_CREATE_SUPERVISED_USER_FLOW) {
     ShowSupervisedUserCreationScreen();
-  } else if (screen_name == kAppLaunchSplashScreenName) {
+  } else if (screen == OobeScreen::SCREEN_APP_LAUNCH_SPLASH) {
     AutoLaunchKioskApp();
-  } else if (screen_name == kHIDDetectionScreenName) {
+  } else if (screen == OobeScreen::SCREEN_OOBE_HID_DETECTION) {
     ShowHIDDetectionScreen();
-  } else if (screen_name == kControllerPairingScreenName) {
+  } else if (screen == OobeScreen::SCREEN_OOBE_CONTROLLER_PAIRING) {
     ShowControllerPairingScreen();
-  } else if (screen_name == kHostPairingScreenName) {
+  } else if (screen == OobeScreen::SCREEN_OOBE_HOST_PAIRING) {
     ShowHostPairingScreen();
-  } else if (screen_name == kDeviceDisabledScreenName) {
+  } else if (screen == OobeScreen::SCREEN_DEVICE_DISABLED) {
     ShowDeviceDisabledScreen();
-  } else if (screen_name != kTestNoScreenName) {
+  } else if (screen != OobeScreen::SCREEN_TEST_NO_WINDOW) {
     if (is_out_of_box_) {
       time_oobe_started_ = base::Time::Now();
       if (IsRemoraPairingOobe() || IsControllerDetected()) {
         ShowHostPairingScreen();
       } else if (CanShowHIDDetectionScreen()) {
-        hid_screen_ = GetScreen(kHIDDetectionScreenName);
+        hid_screen_ = GetScreen(OobeScreen::SCREEN_OOBE_HID_DETECTION);
         base::Callback<void(bool)> on_check = base::Bind(
             &WizardController::OnHIDScreenNecessityCheck,
             weak_factory_.GetWeakPtr());
         oobe_ui_->GetHIDDetectionView()->CheckIsScreenRequired(on_check);
       } else {
         ShowNetworkScreen();
       }
     } else {
       ShowLoginScreen(LoginScreenContext());
     }
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WizardController, BaseScreenDelegate overrides:
 void WizardController::OnExit(BaseScreen& /* screen */,
                               ExitCodes exit_code,
                               const ::login::ScreenContext* /* context */) {
   VLOG(1) << "Wizard screen exit code: " << exit_code;
-  std::string previous_screen_id = current_screen_->screen_id();
-  if (IsOOBEStepToTrack(previous_screen_id)) {
+  OobeScreen previous_screen = current_screen_->screen_id();
+  if (IsOOBEStepToTrack(previous_screen)) {
     RecordUMAHistogramForOOBEStepCompletionTime(
-        previous_screen_id,
-        base::Time::Now() - screen_show_times_[previous_screen_id]);
+        previous_screen,
+        base::Time::Now() -
+            screen_show_times_[GetOobeScreenName(previous_screen)]);
   }
   switch (exit_code) {
     case HID_DETECTION_COMPLETED:
       OnHIDDetectionCompleted();
       break;
     case NETWORK_CONNECTED:
       OnNetworkConnected();
       break;
     case CONNECTION_FAILED:
       OnConnectionFailed();
@@ skipping 60 matching lines @@
     case CONTROLLER_PAIRING_FINISHED:
       OnControllerPairingFinished();
       break;
     default:
       NOTREACHED();
   }
 }
 
 void WizardController::ShowErrorScreen() {
   VLOG(1) << "Showing error screen.";
-  SetCurrentScreen(GetScreen(kErrorScreenName));
+  SetCurrentScreen(GetScreen(OobeScreen::SCREEN_ERROR_MESSAGE));
 }
 
 void WizardController::HideErrorScreen(BaseScreen* parent_screen) {
   DCHECK(parent_screen);
   VLOG(1) << "Hiding error screen.";
   SetCurrentScreen(parent_screen);
 }
 
 void WizardController::SetUsageStatisticsReporting(bool val) {
   usage_statistics_reporting_ = val;
@@ skipping 64 matching lines @@
     network_screen->CreateAndConnectNetworkFromOnc(
         onc_spec, base::Bind(&WizardController::OnSetHostNetworkSuccessful,
                              weak_factory_.GetWeakPtr()),
         base::Bind(&WizardController::OnSetHostNetworkFailed,
                    weak_factory_.GetWeakPtr()));
   }
 }
 
 void WizardController::OnEnableDebuggingScreenRequested() {
   if (!login_screen_started())
-    AdvanceToScreen(WizardController::kEnableDebuggingScreenName);
+    AdvanceToScreen(OobeScreen::SCREEN_OOBE_ENABLE_DEBUGGING);
 }
 
 void WizardController::OnAccessibilityStatusChanged(
     const AccessibilityStatusEventDetails& details) {
   enum AccessibilityNotificationType type = details.notification_type;
   if (type == ACCESSIBILITY_MANAGER_SHUTDOWN) {
     accessibility_subscription_.reset();
     return;
   } else if (type != ACCESSIBILITY_TOGGLE_SPOKEN_FEEDBACK || !details.enabled) {
     return;
@@ skipping 50 matching lines @@
   kShowDelayMs = 0;
   zero_delay_enabled_ = true;
 }
 
 // static
 bool WizardController::IsZeroDelayEnabled() {
   return zero_delay_enabled_;
 }
 
 // static
-bool WizardController::IsOOBEStepToTrack(const std::string& screen_id) {
-  return (screen_id == kHIDDetectionScreenName ||
-          screen_id == kNetworkScreenName ||
-          screen_id == kUpdateScreenName ||
-          screen_id == kUserImageScreenName ||
-          screen_id == kEulaScreenName ||
-          screen_id == kLoginScreenName ||
-          screen_id == kWrongHWIDScreenName);
+bool WizardController::IsOOBEStepToTrack(OobeScreen screen) {
+  return (screen == OobeScreen::SCREEN_OOBE_HID_DETECTION ||
+          screen == OobeScreen::SCREEN_OOBE_NETWORK ||
+          screen == OobeScreen::SCREEN_OOBE_UPDATE ||
+          screen == OobeScreen::SCREEN_USER_IMAGE_PICKER ||
+          screen == OobeScreen::SCREEN_OOBE_EULA ||
+          screen == OobeScreen::SCREEN_SPECIAL_LOGIN ||
+          screen == OobeScreen::SCREEN_WRONG_HWID);
 }
 
 // static
 void WizardController::SkipPostLoginScreensForTesting() {
   skip_post_login_screens_ = true;
 }
 
 void WizardController::OnLocalStateInitialized(bool /* succeeded */) {
   if (GetLocalState()->GetInitializationStatus() !=
       PrefService::INITIALIZATION_STATUS_ERROR) {
@@ skipping 154 matching lines @@
             : policy::EnrollmentConfig::MODE_MANUAL_REENROLLMENT;
   }
 
   EnrollmentScreen* screen = EnrollmentScreen::Get(this);
   screen->SetParameters(effective_config, shark_controller_.get());
   SetStatusAreaVisible(true);
   SetCurrentScreen(screen);
 }
 
 }  // namespace chromeos