cros: Replace WizardController string constants with OobeScreen values.

chrome/browser/chromeos/login/wizard_controller_browsertest.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 "ash/common/accessibility_types.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
 #include "chrome/browser/chromeos/base/locale_util.h"
 #include "chrome/browser/chromeos/login/enrollment/enrollment_screen.h"
 #include "chrome/browser/chromeos/login/enrollment/enterprise_enrollment_helper.h"
 #include "chrome/browser/chromeos/login/enrollment/mock_auto_enrollment_check_screen.h"
 #include "chrome/browser/chromeos/login/enrollment/mock_enrollment_screen.h"
 #include "chrome/browser/chromeos/login/existing_user_controller.h"
+#include "chrome/browser/chromeos/login/oobe_screen.h"
 #include "chrome/browser/chromeos/login/screens/device_disabled_screen.h"
 #include "chrome/browser/chromeos/login/screens/error_screen.h"
 #include "chrome/browser/chromeos/login/screens/hid_detection_screen.h"
 #include "chrome/browser/chromeos/login/screens/mock_device_disabled_screen_actor.h"
 #include "chrome/browser/chromeos/login/screens/mock_enable_debugging_screen.h"
 #include "chrome/browser/chromeos/login/screens/mock_eula_screen.h"
 #include "chrome/browser/chromeos/login/screens/mock_network_screen.h"
 #include "chrome/browser/chromeos/login/screens/mock_update_screen.h"
 #include "chrome/browser/chromeos/login/screens/mock_wrong_hwid_screen.h"
 #include "chrome/browser/chromeos/login/screens/network_screen.h"
@@ skipping 181 matching lines @@
   }
 
   void RealHide() {
     T::Hide();
   }
 
  private:
   std::unique_ptr<H> actor_;
 };
 
-#define MOCK(mock_var, screen_name, mocked_class, actor_class)               \
-  mock_var = new MockOutShowHide<mocked_class, actor_class>(                 \
-      WizardController::default_controller(), new actor_class);              \
-  WizardController::default_controller()                                     \
-      ->screens_[WizardController::screen_name] = make_linked_ptr(mock_var); \
-  EXPECT_CALL(*mock_var, Show()).Times(0);                                   \
+#define MOCK(mock_var, screen_name, mocked_class, actor_class)    \
+  mock_var = new MockOutShowHide<mocked_class, actor_class>(      \
+      WizardController::default_controller(), new actor_class);   \
+  WizardController::default_controller()->screens_[screen_name] = \
+      make_linked_ptr(mock_var);                                  \
+  EXPECT_CALL(*mock_var, Show()).Times(0);                        \
   EXPECT_CALL(*mock_var, Hide()).Times(0);
 
 #define MOCK_WITH_DELEGATE(mock_var, screen_name, mocked_class, actor_class) \
   mock_var = new MockOutShowHide<mocked_class, actor_class>(                 \
       WizardController::default_controller(),                                \
-      WizardController::default_controller(),                                \
-      new actor_class);                                                      \
-  WizardController::default_controller()                                     \
-      ->screens_[WizardController::screen_name] = make_linked_ptr(mock_var); \
+      WizardController::default_controller(), new actor_class);              \
+  WizardController::default_controller()->screens_[screen_name] =            \
+      make_linked_ptr(mock_var);                                             \
   EXPECT_CALL(*mock_var, Show()).Times(0);                                   \
   EXPECT_CALL(*mock_var, Hide()).Times(0);
 
 class WizardControllerTest : public WizardInProcessBrowserTest {
  protected:
-  WizardControllerTest() : WizardInProcessBrowserTest(
-      WizardController::kTestNoScreenName) {}
+  WizardControllerTest()
+      : WizardInProcessBrowserTest(OobeScreen::SCREEN_TEST_NO_WINDOW) {}
   ~WizardControllerTest() override {}
 
   void SetUpOnMainThread() override {
     AccessibilityManager::Get()->
         SetProfileForTest(ProfileHelper::GetSigninProfile());
     WizardInProcessBrowserTest::SetUpOnMainThread();
   }
 
   ErrorScreen* GetErrorScreen() {
     return static_cast<BaseScreenDelegate*>(
@@ skipping 33 matching lines @@
 
   bool JSExecuteBooleanExpression(const std::string& expression) {
     bool result;
     EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
         GetWebContents(),
         "window.domAutomationController.send(!!(" + expression + "));",
         &result));
     return result;
   }
 
-  void CheckCurrentScreen(const std::string& screen_name) {
-    EXPECT_EQ(WizardController::default_controller()->GetScreen(screen_name),
+  void CheckCurrentScreen(OobeScreen screen) {
+    EXPECT_EQ(WizardController::default_controller()->GetScreen(screen),
               WizardController::default_controller()->current_screen());
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WizardControllerTest);
 };
 
 IN_PROC_BROWSER_TEST_F(WizardControllerTest, SwitchLanguage) {
   ASSERT_TRUE(WizardController::default_controller() != NULL);
   WizardController::default_controller()->AdvanceToScreen(
-      WizardController::kNetworkScreenName);
+      OobeScreen::SCREEN_OOBE_NETWORK);
 
   // Checking the default locale. Provided that the profile is cleared in SetUp.
   EXPECT_EQ("en-US", g_browser_process->GetApplicationLocale());
   EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
   EXPECT_FALSE(base::i18n::IsRTL());
   const base::string16 en_str =
       l10n_util::GetStringUTF16(IDS_NETWORK_SELECTION_TITLE);
 
   RunSwitchLanguageTest("fr", "fr", true);
   EXPECT_EQ("fr", g_browser_process->GetApplicationLocale());
@@ skipping 95 matching lines @@
 
     // Clear portal list (as it is by default in OOBE).
     NetworkHandler::Get()->network_state_handler()->SetCheckPortalList("");
 
     // Set up the mocks for all screens.
     mock_network_screen_.reset(new MockNetworkScreen(
         WizardController::default_controller(),
         WizardController::default_controller(), GetOobeUI()->GetNetworkView()));
     mock_network_screen_->Initialize(nullptr /* context */);
     WizardController::default_controller()
-        ->screens_[WizardController::kNetworkScreenName] = mock_network_screen_;
+        ->screens_[OobeScreen::SCREEN_OOBE_NETWORK] = mock_network_screen_;
     EXPECT_CALL(*mock_network_screen_, Show()).Times(0);
     EXPECT_CALL(*mock_network_screen_, Hide()).Times(0);
 
-    MOCK(mock_update_screen_, kUpdateScreenName, MockUpdateScreen,
+    MOCK(mock_update_screen_, OobeScreen::SCREEN_OOBE_UPDATE, MockUpdateScreen,
          MockUpdateView);
-    MOCK_WITH_DELEGATE(mock_eula_screen_, kEulaScreenName, MockEulaScreen,
-                       MockEulaView);
-    MOCK(mock_enrollment_screen_,
-         kEnrollmentScreenName,
-         MockEnrollmentScreen,
-         MockEnrollmentScreenActor);
+    MOCK_WITH_DELEGATE(mock_eula_screen_, OobeScreen::SCREEN_OOBE_EULA,
+                       MockEulaScreen, MockEulaView);
+    MOCK(mock_enrollment_screen_, OobeScreen::SCREEN_OOBE_ENROLLMENT,
+         MockEnrollmentScreen, MockEnrollmentScreenActor);
     MOCK(mock_auto_enrollment_check_screen_,
-         kAutoEnrollmentCheckScreenName,
-         MockAutoEnrollmentCheckScreen,
-         MockAutoEnrollmentCheckScreenActor);
-    MOCK(mock_wrong_hwid_screen_, kWrongHWIDScreenName, MockWrongHWIDScreen,
-         MockWrongHWIDScreenActor);
+         OobeScreen::SCREEN_AUTO_ENROLLMENT_CHECK,
+         MockAutoEnrollmentCheckScreen, MockAutoEnrollmentCheckScreenActor);
+    MOCK(mock_wrong_hwid_screen_, OobeScreen::SCREEN_WRONG_HWID,
+         MockWrongHWIDScreen, MockWrongHWIDScreenActor);
     MOCK(mock_enable_debugging_screen_,
-         kEnableDebuggingScreenName,
-         MockEnableDebuggingScreen,
+         OobeScreen::SCREEN_OOBE_ENABLE_DEBUGGING, MockEnableDebuggingScreen,
          MockEnableDebuggingScreenActor);
     device_disabled_screen_actor_.reset(new MockDeviceDisabledScreenActor);
-    wizard_controller->screens_[WizardController::kDeviceDisabledScreenName] =
+    wizard_controller->screens_[OobeScreen::SCREEN_DEVICE_DISABLED] =
         make_linked_ptr(new DeviceDisabledScreen(
-            wizard_controller,
-            device_disabled_screen_actor_.get()));
+            wizard_controller, device_disabled_screen_actor_.get()));
     EXPECT_CALL(*device_disabled_screen_actor_, Show()).Times(0);
 
     // Switch to the initial screen.
     EXPECT_EQ(NULL, wizard_controller->current_screen());
     EXPECT_CALL(*mock_network_screen_, Show()).Times(1);
-    wizard_controller->AdvanceToScreen(WizardController::kNetworkScreenName);
+    wizard_controller->AdvanceToScreen(OobeScreen::SCREEN_OOBE_NETWORK);
   }
 
   void TearDownOnMainThread() override {
     mock_network_screen_.reset();
     device_disabled_screen_actor_.reset();
     WizardControllerTest::TearDownOnMainThread();
   }
 
   void TearDown() override {
     if (fallback_fetcher_factory_) {
@@ skipping 42 matching lines @@
              ->SetOnTimeZoneResolvedForTesting(
                  base::Bind(&TimeZoneTestRunner::OnResolved,
                             base::Unretained(runner.get()))))
       return;
 
     runner->Run();
   }
 
   void ResetAutoEnrollmentCheckScreen() {
     WizardController::default_controller()->screens_.erase(
-        WizardController::kAutoEnrollmentCheckScreenName);
+        OobeScreen::SCREEN_AUTO_ENROLLMENT_CHECK);
   }
 
   linked_ptr<MockNetworkScreen> mock_network_screen_;
   MockOutShowHide<MockUpdateScreen, MockUpdateView>* mock_update_screen_;
   MockOutShowHide<MockEulaScreen, MockEulaView>* mock_eula_screen_;
   MockOutShowHide<MockEnrollmentScreen,
       MockEnrollmentScreenActor>* mock_enrollment_screen_;
   MockOutShowHide<MockAutoEnrollmentCheckScreen,
       MockAutoEnrollmentCheckScreenActor>* mock_auto_enrollment_check_screen_;
   MockOutShowHide<MockWrongHWIDScreen, MockWrongHWIDScreenActor>*
       mock_wrong_hwid_screen_;
   MockOutShowHide<MockEnableDebuggingScreen,
       MockEnableDebuggingScreenActor>* mock_enable_debugging_screen_;
   std::unique_ptr<MockDeviceDisabledScreenActor> device_disabled_screen_actor_;
 
  private:
   NetworkPortalDetectorTestImpl* network_portal_detector_;
 
   // Use a test factory as a fallback so we don't have to deal with other
   // requests.
   std::unique_ptr<WizardControllerTestURLFetcherFactory>
       fallback_fetcher_factory_;
   std::unique_ptr<net::FakeURLFetcherFactory> fetcher_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WizardControllerFlowTest);
 };
 
 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowMain) {
-  CheckCurrentScreen(WizardController::kNetworkScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_NETWORK);
 
   WaitUntilJSIsReady();
 
   // Check visibility of the header bar.
   ASSERT_FALSE(JSExecuteBooleanExpression("$('login-header-bar').hidden"));
 
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
   OnExit(*mock_network_screen_, BaseScreenDelegate::NETWORK_CONNECTED);
 
-  CheckCurrentScreen(WizardController::kEulaScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_EULA);
 
   // Header bar should still be visible.
   ASSERT_FALSE(JSExecuteBooleanExpression("$('login-header-bar').hidden"));
 
   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
   // Enable TimeZone resolve
   InitTimezoneResolver();
   OnExit(*mock_eula_screen_, BaseScreenDelegate::EULA_ACCEPTED);
   EXPECT_TRUE(GetGeolocationProvider());
 
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
-  CheckCurrentScreen(WizardController::kUpdateScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_UPDATE);
   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
   OnExit(*mock_update_screen_, BaseScreenDelegate::UPDATE_INSTALLED);
 
-  CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_AUTO_ENROLLMENT_CHECK);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(0);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(0);
   OnExit(*mock_auto_enrollment_check_screen_,
          BaseScreenDelegate::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 
   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
   EXPECT_EQ("ethernet,wifi,cellular",
             NetworkHandler::Get()->network_state_handler()
             ->GetCheckPortalListForTest());
 
   WaitUntilTimezoneResolved();
   EXPECT_EQ("America/Anchorage",
             base::UTF16ToUTF8(chromeos::system::TimezoneSettings::GetInstance()
                                   ->GetCurrentTimezoneID()));
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowErrorUpdate) {
-  CheckCurrentScreen(WizardController::kNetworkScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_NETWORK);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(0);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
   OnExit(*mock_network_screen_, BaseScreenDelegate::NETWORK_CONNECTED);
 
-  CheckCurrentScreen(WizardController::kEulaScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_EULA);
   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
   OnExit(*mock_eula_screen_, BaseScreenDelegate::EULA_ACCEPTED);
 
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
-  CheckCurrentScreen(WizardController::kUpdateScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_UPDATE);
   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
   OnExit(*mock_update_screen_, BaseScreenDelegate::UPDATE_ERROR_UPDATING);
 
-  CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_AUTO_ENROLLMENT_CHECK);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(0);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(0);
   OnExit(*mock_auto_enrollment_check_screen_,
          BaseScreenDelegate::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 
   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowSkipUpdateEnroll) {
-  CheckCurrentScreen(WizardController::kNetworkScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_NETWORK);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(0);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
   OnExit(*mock_network_screen_, BaseScreenDelegate::NETWORK_CONNECTED);
 
-  CheckCurrentScreen(WizardController::kEulaScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_EULA);
   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(0);
   WizardController::default_controller()->SkipUpdateEnrollAfterEula();
   EXPECT_CALL(*mock_enrollment_screen_->actor(),
               SetParameters(
                   mock_enrollment_screen_,
                   EnrollmentModeMatches(policy::EnrollmentConfig::MODE_MANUAL)))
       .Times(1);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
   OnExit(*mock_eula_screen_, BaseScreenDelegate::EULA_ACCEPTED);
   content::RunAllPendingInMessageLoop();
 
-  CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_AUTO_ENROLLMENT_CHECK);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
   EXPECT_CALL(*mock_enrollment_screen_, Hide()).Times(0);
   OnExit(*mock_auto_enrollment_check_screen_,
          BaseScreenDelegate::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
   content::RunAllPendingInMessageLoop();
 
-  CheckCurrentScreen(WizardController::kEnrollmentScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_ENROLLMENT);
   EXPECT_EQ("ethernet,wifi,cellular",
             NetworkHandler::Get()->network_state_handler()
             ->GetCheckPortalListForTest());
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowEulaDeclined) {
-  CheckCurrentScreen(WizardController::kNetworkScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_NETWORK);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
   OnExit(*mock_network_screen_, BaseScreenDelegate::NETWORK_CONNECTED);
 
-  CheckCurrentScreen(WizardController::kEulaScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_EULA);
   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_network_screen_, Show()).Times(1);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(0);  // last transition
   OnExit(*mock_eula_screen_, BaseScreenDelegate::EULA_BACK);
 
-  CheckCurrentScreen(WizardController::kNetworkScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_NETWORK);
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest,
                        ControlFlowEnrollmentCompleted) {
-  CheckCurrentScreen(WizardController::kNetworkScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_NETWORK);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
   EXPECT_CALL(*mock_enrollment_screen_->actor(),
               SetParameters(
                   mock_enrollment_screen_,
                   EnrollmentModeMatches(policy::EnrollmentConfig::MODE_MANUAL)))
       .Times(1);
   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 
   WizardController::default_controller()->AdvanceToScreen(
-      WizardController::kEnrollmentScreenName);
-  CheckCurrentScreen(WizardController::kEnrollmentScreenName);
+      OobeScreen::SCREEN_OOBE_ENROLLMENT);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_ENROLLMENT);
   OnExit(*mock_enrollment_screen_,
          BaseScreenDelegate::ENTERPRISE_ENROLLMENT_COMPLETED);
 
   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest,
                        ControlFlowWrongHWIDScreenFromLogin) {
-  CheckCurrentScreen(WizardController::kNetworkScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_NETWORK);
 
   LoginDisplayHost::default_host()->StartSignInScreen(LoginScreenContext());
   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
   ExistingUserController::current_controller()->ShowWrongHWIDScreen();
 
-  CheckCurrentScreen(WizardController::kWrongHWIDScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_WRONG_HWID);
 
   // After warning is skipped, user returns to sign-in screen.
   // And this destroys WizardController.
   OnExit(*mock_wrong_hwid_screen_,
          BaseScreenDelegate::WRONG_HWID_WARNING_SKIPPED);
   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 }
 
 class WizardControllerDeviceStateTest : public WizardControllerFlowTest {
  protected:
@@ skipping 20 matching lines @@
   system::ScopedFakeStatisticsProvider fake_statistics_provider_;
 
  private:
   ScopedStubInstallAttributes install_attributes_;
 
   DISALLOW_COPY_AND_ASSIGN(WizardControllerDeviceStateTest);
 };
 
 IN_PROC_BROWSER_TEST_F(WizardControllerDeviceStateTest,
                        ControlFlowForcedReEnrollment) {
-  CheckCurrentScreen(WizardController::kNetworkScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_NETWORK);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
   OnExit(*mock_network_screen_, BaseScreenDelegate::NETWORK_CONNECTED);
 
-  CheckCurrentScreen(WizardController::kEulaScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_EULA);
   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
   OnExit(*mock_eula_screen_, BaseScreenDelegate::EULA_ACCEPTED);
 
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
-  CheckCurrentScreen(WizardController::kUpdateScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_UPDATE);
   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
   OnExit(*mock_update_screen_, BaseScreenDelegate::UPDATE_INSTALLED);
 
-  CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_AUTO_ENROLLMENT_CHECK);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(1);
   mock_auto_enrollment_check_screen_->RealShow();
 
   // Wait for auto-enrollment controller to encounter the connection error.
   WaitForAutoEnrollmentState(policy::AUTO_ENROLLMENT_STATE_CONNECTION_ERROR);
 
   // The error screen shows up if there's no auto-enrollment decision.
   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
   EXPECT_EQ(GetErrorScreen(),
             WizardController::default_controller()->current_screen());
   base::DictionaryValue device_state;
   device_state.SetString(policy::kDeviceStateRestoreMode,
                          policy::kDeviceStateRestoreModeReEnrollmentEnforced);
   g_browser_process->local_state()->Set(prefs::kServerBackedDeviceState,
                                         device_state);
   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
   EXPECT_CALL(*mock_enrollment_screen_->actor(),
               SetParameters(mock_enrollment_screen_,
                             EnrollmentModeMatches(
                                 policy::EnrollmentConfig::MODE_SERVER_FORCED)))
       .Times(1);
   OnExit(*mock_auto_enrollment_check_screen_,
          BaseScreenDelegate::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 
   ResetAutoEnrollmentCheckScreen();
 
   // Make sure enterprise enrollment page shows up.
-  CheckCurrentScreen(WizardController::kEnrollmentScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_ENROLLMENT);
   OnExit(*mock_enrollment_screen_,
          BaseScreenDelegate::ENTERPRISE_ENROLLMENT_COMPLETED);
 
   EXPECT_TRUE(StartupUtils::IsOobeCompleted());
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerDeviceStateTest,
                        ControlFlowNoForcedReEnrollmentOnFirstBoot) {
   fake_statistics_provider_.ClearMachineStatistic(system::kActivateDateKey);
   EXPECT_NE(
       policy::AUTO_ENROLLMENT_STATE_NO_ENROLLMENT,
       LoginDisplayHost::default_host()->GetAutoEnrollmentController()->state());
 
-  CheckCurrentScreen(WizardController::kNetworkScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_NETWORK);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
   OnExit(*mock_network_screen_, BaseScreenDelegate::NETWORK_CONNECTED);
 
-  CheckCurrentScreen(WizardController::kEulaScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_EULA);
   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
   OnExit(*mock_eula_screen_, BaseScreenDelegate::EULA_ACCEPTED);
 
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
-  CheckCurrentScreen(WizardController::kUpdateScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_UPDATE);
   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
   OnExit(*mock_update_screen_, BaseScreenDelegate::UPDATE_INSTALLED);
 
-  CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_AUTO_ENROLLMENT_CHECK);
   mock_auto_enrollment_check_screen_->RealShow();
   EXPECT_EQ(
       policy::AUTO_ENROLLMENT_STATE_NO_ENROLLMENT,
       LoginDisplayHost::default_host()->GetAutoEnrollmentController()->state());
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerDeviceStateTest,
                        ControlFlowDeviceDisabled) {
-  CheckCurrentScreen(WizardController::kNetworkScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_NETWORK);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
   OnExit(*mock_network_screen_, BaseScreenDelegate::NETWORK_CONNECTED);
 
-  CheckCurrentScreen(WizardController::kEulaScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_EULA);
   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
   OnExit(*mock_eula_screen_, BaseScreenDelegate::EULA_ACCEPTED);
 
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
-  CheckCurrentScreen(WizardController::kUpdateScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_UPDATE);
   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
   OnExit(*mock_update_screen_, BaseScreenDelegate::UPDATE_INSTALLED);
 
-  CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_AUTO_ENROLLMENT_CHECK);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(1);
   mock_auto_enrollment_check_screen_->RealShow();
 
   // Wait for auto-enrollment controller to encounter the connection error.
   WaitForAutoEnrollmentState(policy::AUTO_ENROLLMENT_STATE_CONNECTION_ERROR);
 
   // The error screen shows up if device state could not be retrieved.
   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
   EXPECT_EQ(GetErrorScreen(),
             WizardController::default_controller()->current_screen());
   base::DictionaryValue device_state;
   device_state.SetString(policy::kDeviceStateRestoreMode,
                          policy::kDeviceStateRestoreModeDisabled);
   device_state.SetString(policy::kDeviceStateDisabledMessage, kDisabledMessage);
   g_browser_process->local_state()->Set(prefs::kServerBackedDeviceState,
                                         device_state);
   EXPECT_CALL(*device_disabled_screen_actor_,
               UpdateMessage(kDisabledMessage)).Times(1);
   EXPECT_CALL(*device_disabled_screen_actor_, Show()).Times(1);
   OnExit(*mock_auto_enrollment_check_screen_,
          BaseScreenDelegate::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 
   ResetAutoEnrollmentCheckScreen();
 
   // Make sure the device disabled screen is shown.
-  CheckCurrentScreen(WizardController::kDeviceDisabledScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_DEVICE_DISABLED);
 
   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 }
 
 class WizardControllerBrokenLocalStateTest : public WizardControllerTest {
  protected:
   WizardControllerBrokenLocalStateTest()
       : fake_session_manager_client_(NULL) {
   }
 
@@ skipping 67 matching lines @@
 
   // Overridden from WizardControllerTest:
   void SetUp() override {
     ASSERT_TRUE(proxy_server_.Start());
     WizardControllerTest::SetUp();
   }
 
   void SetUpOnMainThread() override {
     WizardControllerTest::SetUpOnMainThread();
     WizardController::default_controller()->AdvanceToScreen(
-        WizardController::kNetworkScreenName);
+        OobeScreen::SCREEN_OOBE_NETWORK);
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitchASCII(::switches::kProxyServer,
                                     proxy_server_.host_port_pair().ToString());
   }
 
   net::SpawnedTestServer& proxy_server() { return proxy_server_; }
 
  private:
   net::SpawnedTestServer proxy_server_;
 
   DISALLOW_COPY_AND_ASSIGN(WizardControllerProxyAuthOnSigninTest);
 };
 
 // Disabled, see https://crbug.com/504928.
 IN_PROC_BROWSER_TEST_F(WizardControllerProxyAuthOnSigninTest,
                        DISABLED_ProxyAuthDialogOnSigninScreen) {
   content::WindowedNotificationObserver auth_needed_waiter(
       chrome::NOTIFICATION_AUTH_NEEDED,
       content::NotificationService::AllSources());
 
-  CheckCurrentScreen(WizardController::kNetworkScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_NETWORK);
 
   LoginDisplayHost::default_host()->StartSignInScreen(LoginScreenContext());
   auth_needed_waiter.Wait();
 }
 
 class WizardControllerKioskFlowTest : public WizardControllerFlowTest {
  protected:
   WizardControllerKioskFlowTest() {}
 
   // Overridden from InProcessBrowserTest:
@@ skipping 10 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(WizardControllerKioskFlowTest);
 };
 
 IN_PROC_BROWSER_TEST_F(WizardControllerKioskFlowTest,
                        ControlFlowKioskForcedEnrollment) {
   EXPECT_CALL(*mock_enrollment_screen_->actor(),
               SetParameters(mock_enrollment_screen_,
                             EnrollmentModeMatches(
                                 policy::EnrollmentConfig::MODE_LOCAL_FORCED)))
       .Times(1);
-  CheckCurrentScreen(WizardController::kNetworkScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_NETWORK);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
   OnExit(*mock_network_screen_, BaseScreenDelegate::NETWORK_CONNECTED);
 
-  CheckCurrentScreen(WizardController::kEulaScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_EULA);
   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
   OnExit(*mock_eula_screen_, BaseScreenDelegate::EULA_ACCEPTED);
 
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
-  CheckCurrentScreen(WizardController::kUpdateScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_UPDATE);
   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
   OnExit(*mock_update_screen_, BaseScreenDelegate::UPDATE_INSTALLED);
 
-  CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_AUTO_ENROLLMENT_CHECK);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
   OnExit(*mock_auto_enrollment_check_screen_,
          BaseScreenDelegate::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 
   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 
   // Make sure enterprise enrollment page shows up right after update screen.
-  CheckCurrentScreen(WizardController::kEnrollmentScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_ENROLLMENT);
   OnExit(*mock_enrollment_screen_,
          BaseScreenDelegate::ENTERPRISE_ENROLLMENT_COMPLETED);
 
   EXPECT_TRUE(StartupUtils::IsOobeCompleted());
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerKioskFlowTest,
                        ControlFlowEnrollmentBack) {
   EXPECT_CALL(*mock_enrollment_screen_->actor(),
               SetParameters(mock_enrollment_screen_,
                             EnrollmentModeMatches(
                                 policy::EnrollmentConfig::MODE_LOCAL_FORCED)))
       .Times(1);
 
-  CheckCurrentScreen(WizardController::kNetworkScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_NETWORK);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
   OnExit(*mock_network_screen_, BaseScreenDelegate::NETWORK_CONNECTED);
 
-  CheckCurrentScreen(WizardController::kEulaScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_EULA);
   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
   OnExit(*mock_eula_screen_, BaseScreenDelegate::EULA_ACCEPTED);
 
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
-  CheckCurrentScreen(WizardController::kUpdateScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_UPDATE);
   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
   OnExit(*mock_update_screen_, BaseScreenDelegate::UPDATE_INSTALLED);
 
-  CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_AUTO_ENROLLMENT_CHECK);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
   EXPECT_CALL(*mock_enrollment_screen_, Hide()).Times(1);
   OnExit(*mock_auto_enrollment_check_screen_,
          BaseScreenDelegate::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 
   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 
   // Make sure enterprise enrollment page shows up right after update screen.
-  CheckCurrentScreen(WizardController::kEnrollmentScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_ENROLLMENT);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
   OnExit(*mock_enrollment_screen_,
          BaseScreenDelegate::ENTERPRISE_ENROLLMENT_BACK);
 
-  CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_AUTO_ENROLLMENT_CHECK);
   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 }
 
 
 class WizardControllerEnableDebuggingTest : public WizardControllerFlowTest {
  protected:
   WizardControllerEnableDebuggingTest() {}
 
   // Overridden from InProcessBrowserTest:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     WizardControllerFlowTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(chromeos::switches::kSystemDevMode);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WizardControllerEnableDebuggingTest);
 };
 
 IN_PROC_BROWSER_TEST_F(WizardControllerEnableDebuggingTest,
                        ShowAndCancelEnableDebugging) {
-  CheckCurrentScreen(WizardController::kNetworkScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_NETWORK);
   WaitUntilJSIsReady();
 
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_enable_debugging_screen_, Show()).Times(1);
 
   ASSERT_TRUE(JSExecute("$('connect-debugging-features-link').click()"));
 
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
-  CheckCurrentScreen(WizardController::kEnableDebuggingScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_ENABLE_DEBUGGING);
   EXPECT_CALL(*mock_enable_debugging_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_network_screen_, Show()).Times(1);
 
   OnExit(*mock_enable_debugging_screen_,
          BaseScreenDelegate::ENABLE_DEBUGGING_CANCELED);
 
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
-  CheckCurrentScreen(WizardController::kNetworkScreenName);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_NETWORK);
 }
 
 class WizardControllerOobeResumeTest : public WizardControllerTest {
  protected:
   WizardControllerOobeResumeTest() {}
   // Overriden from InProcessBrowserTest:
   void SetUpOnMainThread() override {
     WizardControllerTest::SetUpOnMainThread();
 
     // Make sure that OOBE is run as an "official" build.
     WizardController::default_controller()->is_official_build_ = true;
 
     // Clear portal list (as it is by default in OOBE).
     NetworkHandler::Get()->network_state_handler()->SetCheckPortalList("");
 
     // Set up the mocks for all screens.
-    MOCK_WITH_DELEGATE(mock_network_screen_, kNetworkScreenName,
+    MOCK_WITH_DELEGATE(mock_network_screen_, OobeScreen::SCREEN_OOBE_NETWORK,
                        MockNetworkScreen, MockNetworkView);
-    MOCK(mock_enrollment_screen_,
-         kEnrollmentScreenName,
-         MockEnrollmentScreen,
-         MockEnrollmentScreenActor);
+    MOCK(mock_enrollment_screen_, OobeScreen::SCREEN_OOBE_ENROLLMENT,
+         MockEnrollmentScreen, MockEnrollmentScreenActor);
   }
 
   void OnExit(BaseScreen& screen, BaseScreenDelegate::ExitCodes exit_code) {
     WizardController::default_controller()->OnExit(screen, exit_code,
                                                    nullptr /* context */);
   }
 
-  std::string GetFirstScreenName() {
-    return WizardController::default_controller()->first_screen_name();
+  OobeScreen GetFirstScreen() {
+    return WizardController::default_controller()->first_screen();
   }
 
   MockOutShowHide<MockNetworkScreen, MockNetworkView>* mock_network_screen_;
   MockOutShowHide<MockEnrollmentScreen,
       MockEnrollmentScreenActor>* mock_enrollment_screen_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WizardControllerOobeResumeTest);
 };
 
 IN_PROC_BROWSER_TEST_F(WizardControllerOobeResumeTest,
                        PRE_ControlFlowResumeInterruptedOobe) {
   // Switch to the initial screen.
   EXPECT_CALL(*mock_network_screen_, Show()).Times(1);
   WizardController::default_controller()->AdvanceToScreen(
-      WizardController::kNetworkScreenName);
-  CheckCurrentScreen(WizardController::kNetworkScreenName);
+      OobeScreen::SCREEN_OOBE_NETWORK);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_NETWORK);
   EXPECT_CALL(*mock_enrollment_screen_->actor(),
               SetParameters(
                   mock_enrollment_screen_,
                   EnrollmentModeMatches(policy::EnrollmentConfig::MODE_MANUAL)))
       .Times(1);
   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 
   WizardController::default_controller()->AdvanceToScreen(
-      WizardController::kEnrollmentScreenName);
-  CheckCurrentScreen(WizardController::kEnrollmentScreenName);
+      OobeScreen::SCREEN_OOBE_ENROLLMENT);
+  CheckCurrentScreen(OobeScreen::SCREEN_OOBE_ENROLLMENT);
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerOobeResumeTest,
                        ControlFlowResumeInterruptedOobe) {
-  EXPECT_EQ(WizardController::kEnrollmentScreenName, GetFirstScreenName());
+  EXPECT_EQ(OobeScreen::SCREEN_OOBE_ENROLLMENT, GetFirstScreen());
 }
 
 // TODO(dzhioev): Add test emaulating device with wrong HWID.
 
 // TODO(nkostylev): Add test for WebUI accelerators http://crosbug.com/22571
 
 // TODO(merkulova): Add tests for bluetooth HID detection screen variations when
 // UI and logic is ready. http://crbug.com/127016
 
 // TODO(dzhioev): Add tests for controller/host pairing flow.
 // http://crbug.com/375191
 
 // TODO(khmel): Add tests for Arc OptIn flow.
 // http://crbug.com/651144
 static_assert(BaseScreenDelegate::EXIT_CODES_COUNT == 24,
               "tests for new control flow are missing");
 
 }  // namespace chromeos