cros: Replace WizardController string constants with OobeScreen values.

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

 // Copyright 2014 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/ui/login_display_host_impl.h"
 
 #include <utility>
 #include <vector>
 
 #include "ash/common/wallpaper/wallpaper_controller.h"
@@ skipping 154 matching lines @@
 
   base::Closure callback_;
 
   DISALLOW_COPY_AND_ASSIGN(AnimationObserver);
 };
 
 // ShowLoginWizard is split into two parts. This function is sometimes called
 // from ShowLoginWizard(), and sometimes from OnLanguageSwitchedCallback()
 // (if locale was updated).
 void ShowLoginWizardFinish(
-    const std::string& first_screen_name,
+    chromeos::OobeScreen first_screen,
     const chromeos::StartupCustomizationDocument* startup_manifest,
     chromeos::LoginDisplayHost* display_host) {
   TRACE_EVENT0("chromeos", "ShowLoginWizard::ShowLoginWizardFinish");
 
-  display_host->StartWizard(first_screen_name);
+  display_host->StartWizard(first_screen);
 
   // Set initial timezone if specified by customization.
   const std::string timezone_name = startup_manifest->initial_timezone();
   VLOG(1) << "Initial time zone: " << timezone_name;
   // Apply locale customizations only once to preserve whatever locale
   // user has changed to during OOBE.
   if (!timezone_name.empty()) {
     chromeos::system::TimezoneSettings::GetInstance()->SetTimezoneFromID(
         base::UTF8ToUTF16(timezone_name));
   }
 }
 
 struct ShowLoginWizardSwitchLanguageCallbackData {
   explicit ShowLoginWizardSwitchLanguageCallbackData(
-      const std::string& first_screen_name,
+      chromeos::OobeScreen first_screen,
       const chromeos::StartupCustomizationDocument* startup_manifest,
       chromeos::LoginDisplayHost* display_host)
-      : first_screen_name(first_screen_name),
+      : first_screen(first_screen),
         startup_manifest(startup_manifest),
         display_host(display_host) {}
 
-  const std::string first_screen_name;
+  const chromeos::OobeScreen first_screen;
   const chromeos::StartupCustomizationDocument* const startup_manifest;
   chromeos::LoginDisplayHost* const display_host;
 
   // lock UI while resource bundle is being reloaded.
   chromeos::InputEventsBlocker events_blocker;
 };
 
 void OnLanguageSwitchedCallback(
     std::unique_ptr<ShowLoginWizardSwitchLanguageCallbackData> self,
     const chromeos::locale_util::LanguageSwitchResult& result) {
   if (!result.success)
     LOG(WARNING) << "Locale could not be found for '" << result.requested_locale
                  << "'";
 
-  ShowLoginWizardFinish(
-      self->first_screen_name, self->startup_manifest, self->display_host);
+  ShowLoginWizardFinish(self->first_screen, self->startup_manifest,
+                        self->display_host);
 }
 
 void EnableSystemSoundsForAccessibility() {
   chromeos::AccessibilityManager::Get()->EnableSystemSounds(true);
 }
 
 // A login implementation of WidgetDelegate.
 class LoginWidgetDelegate : public views::WidgetDelegate {
  public:
   explicit LoginWidgetDelegate(views::Widget* widget) : widget_(widget) {
@@ skipping 294 matching lines @@
   else if (login_view_)
     login_view_->SetStatusAreaVisible(visible);
 }
 
 AutoEnrollmentController* LoginDisplayHostImpl::GetAutoEnrollmentController() {
   if (!auto_enrollment_controller_)
     auto_enrollment_controller_.reset(new AutoEnrollmentController());
   return auto_enrollment_controller_.get();
 }
 
-void LoginDisplayHostImpl::StartWizard(const std::string& first_screen_name) {
+void LoginDisplayHostImpl::StartWizard(OobeScreen first_screen) {
   DisableKeyboardOverscroll();
 
   startup_sound_honors_spoken_feedback_ = false;
   TryToPlayStartupSound();
 
   // Keep parameters to restore if renderer crashes.
   restore_path_ = RESTORE_WIZARD;
-  first_screen_name_ = first_screen_name;
+  first_screen_ = first_screen;
   is_showing_login_ = false;
 
   if (waiting_for_wallpaper_load_ && !initialize_webui_hidden_) {
     VLOG(1) << "Login WebUI >> wizard postponed";
     return;
   }
   VLOG(1) << "Login WebUI >> wizard";
 
   if (!login_window_)
     LoadURL(GURL(kOobeURL));
 
-  DVLOG(1) << "Starting wizard, first_screen_name: " << first_screen_name;
+  DVLOG(1) << "Starting wizard, first_screen: "
+           << GetOobeScreenName(first_screen);
   // Create and show the wizard.
   // Note, dtor of the old WizardController should be called before ctor of the
   // new one, because "default_controller()" is updated there. So pure "reset()"
   // is done before new controller creation.
   wizard_controller_.reset();
   wizard_controller_.reset(CreateWizardController());
 
   oobe_progress_bar_visible_ = !StartupUtils::IsDeviceRegistered();
   SetOobeProgressBarVisible(oobe_progress_bar_visible_);
-  wizard_controller_->Init(first_screen_name);
+  wizard_controller_->Init(first_screen);
 }
 
 WizardController* LoginDisplayHostImpl::GetWizardController() {
   return wizard_controller_.get();
 }
 
 AppLaunchController* LoginDisplayHostImpl::GetAppLaunchController() {
   return app_launch_controller_.get();
 }
 
@@ skipping 513 matching lines @@
   // Wallpaper has finished loading before StartWizard/StartSignInScreen has
   // been called. In general this should not happen.
   // Let go through normal code path when one of those will be called.
   if (restore_path_ == RESTORE_UNKNOWN) {
     NOTREACHED();
     return;
   }
 
   switch (restore_path_) {
     case RESTORE_WIZARD:
-      StartWizard(first_screen_name_);
+      StartWizard(first_screen_);
       break;
     case RESTORE_SIGN_IN:
       StartSignInScreen(LoginScreenContext());
       break;
     case RESTORE_ADD_USER_INTO_SESSION:
       StartUserAdding(completion_callback_);
       break;
     default:
       NOTREACHED();
       break;
@@ skipping 131 matching lines @@
       ->GetOobeUI()
       ->GetGaiaScreenActor()
       ->DisableRestrictiveProxyCheckForTest();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // external
 
 // Declared in login_wizard.h so that others don't need to depend on our .h.
 // TODO(nkostylev): Split this into a smaller functions.
-void ShowLoginWizard(const std::string& first_screen_name) {
+void ShowLoginWizard(OobeScreen first_screen) {
   if (browser_shutdown::IsTryingToQuit())
     return;
 
-  VLOG(1) << "Showing OOBE screen: " << first_screen_name;
+  VLOG(1) << "Showing OOBE screen: " << GetOobeScreenName(first_screen);
 
   chromeos::input_method::InputMethodManager* manager =
       chromeos::input_method::InputMethodManager::Get();
 
   // Set up keyboards. For example, when |locale| is "en-US", enable US qwerty
   // and US dvorak keyboard layouts.
   if (g_browser_process && g_browser_process->local_state()) {
     manager->GetActiveIMEState()->SetInputMethodLoginDefault();
 
     PrefService* prefs = g_browser_process->local_state();
@@ skipping 11 matching lines @@
   gfx::Rect screen_bounds(chromeos::CalculateScreenBounds(gfx::Size()));
 
   session_manager::SessionManager::Get()->SetSessionState(
       StartupUtils::IsOobeCompleted()
           ? session_manager::SessionState::LOGIN_PRIMARY
           : session_manager::SessionState::OOBE);
 
   LoginDisplayHostImpl* display_host = new LoginDisplayHostImpl(screen_bounds);
 
   bool show_app_launch_splash_screen =
-      (first_screen_name == WizardController::kAppLaunchSplashScreenName);
+      (first_screen == OobeScreen::SCREEN_APP_LAUNCH_SPLASH);
   if (show_app_launch_splash_screen) {
     const std::string& auto_launch_app_id =
         KioskAppManager::Get()->GetAutoLaunchApp();
     const bool diagnostic_mode = false;
     const bool auto_launch = true;
     display_host->StartAppLaunch(auto_launch_app_id,
                                  diagnostic_mode,
                                  auto_launch);
     return;
   }
 
   // Check whether we need to execute OOBE flow.
   const policy::EnrollmentConfig enrollment_config =
       g_browser_process->platform_part()
           ->browser_policy_connector_chromeos()
           ->GetPrescribedEnrollmentConfig();
-  if (enrollment_config.should_enroll() && first_screen_name.empty()) {
+  if (enrollment_config.should_enroll() &&
+      first_screen == OobeScreen::SCREEN_UNKNOWN) {
     // Shows networks screen instead of enrollment screen to resume the
     // interrupted auto start enrollment flow because enrollment screen does
     // not handle flaky network. See http://crbug.com/332572
-    display_host->StartWizard(WizardController::kNetworkScreenName);
+    display_host->StartWizard(OobeScreen::SCREEN_OOBE_NETWORK);
     return;
   }
 
   if (StartupUtils::IsEulaAccepted()) {
     DelayNetworkCall(
         base::TimeDelta::FromMilliseconds(kDefaultNetworkRetryDelayMS),
         ServicesCustomizationDocument::GetInstance()
             ->EnsureCustomizationAppliedClosure());
 
     g_browser_process->platform_part()
         ->GetTimezoneResolverManager()
         ->UpdateTimezoneResolver();
   }
 
-  bool show_login_screen =
-      (first_screen_name.empty() && StartupUtils::IsOobeCompleted()) ||
-      first_screen_name == WizardController::kLoginScreenName;
+  bool show_login_screen = (first_screen == OobeScreen::SCREEN_UNKNOWN &&
+                            StartupUtils::IsOobeCompleted()) ||
+                           first_screen == OobeScreen::SCREEN_SPECIAL_LOGIN;
 
   if (show_login_screen) {
     display_host->StartSignInScreen(LoginScreenContext());
     return;
   }
 
   // Load startup manifest.
   const StartupCustomizationDocument* startup_manifest =
       StartupCustomizationDocument::GetInstance();
 
   // Switch to initial locale if specified by customization
   // and has not been set yet. We cannot call
   // LanguageSwitchMenu::SwitchLanguage here before
   // EmitLoginPromptReady.
   PrefService* prefs = g_browser_process->local_state();
   const std::string& current_locale =
       prefs->GetString(prefs::kApplicationLocale);
   VLOG(1) << "Current locale: " << current_locale;
   const std::string& locale = startup_manifest->initial_locale_default();
 
   const std::string& layout = startup_manifest->keyboard_layout();
   VLOG(1) << "Initial locale: " << locale << "keyboard layout " << layout;
 
   // Determine keyboard layout from OEM customization (if provided) or
   // initial locale and save it in preferences.
   manager->GetActiveIMEState()->SetInputMethodLoginDefaultFromVPD(locale,
                                                                   layout);
 
   if (!current_locale.empty() || locale.empty()) {
-    ShowLoginWizardFinish(first_screen_name, startup_manifest, display_host);
+    ShowLoginWizardFinish(first_screen, startup_manifest, display_host);
     return;
   }
 
   // Save initial locale from VPD/customization manifest as current
   // Chrome locale. Otherwise it will be lost if Chrome restarts.
   // Don't need to schedule pref save because setting initial local
   // will enforce preference saving.
   prefs->SetString(prefs::kApplicationLocale, locale);
   StartupUtils::SetInitialLocale(locale);
 
   std::unique_ptr<ShowLoginWizardSwitchLanguageCallbackData> data(
       new ShowLoginWizardSwitchLanguageCallbackData(
-          first_screen_name, startup_manifest, display_host));
+          first_screen, startup_manifest, display_host));
 
   locale_util::SwitchLanguageCallback callback(
       base::Bind(&OnLanguageSwitchedCallback, base::Passed(std::move(data))));
 
   // Load locale keyboards here. Hardware layout would be automatically enabled.
   locale_util::SwitchLanguage(locale, true, true /* login_layouts_only */,
                               callback, ProfileManager::GetActiveUserProfile());
 }
 
 }  // namespace chromeos