Update locally managed user creation flow according to mocks

chrome/browser/chromeos/login/managed/locally_managed_user_creation_screen.cc

 // Copyright (c) 2013 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/managed/locally_managed_user_creation_screen.h"
 
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/chromeos/login/existing_user_controller.h"
 #include "chrome/browser/chromeos/login/managed/locally_managed_user_controller.h"
 #include "chrome/browser/chromeos/login/screens/error_screen.h"
@@ skipping 55 matching lines @@
 void LocallyManagedUserCreationScreen::PrepareToShow() {
   if (actor_)
     actor_->PrepareToShow();
 }
 
 void LocallyManagedUserCreationScreen::Show() {
   if (actor_) {
     actor_->Show();
     // TODO(antrim) : temorary hack (until upcoming hackaton). Should be
     // removed once we have screens reworked.
-    if (on_image_screen_) {
-      actor_->ShowPostImageSelectionScreen();
-    } else {
-      actor_->ShowInitialScreen();
-    }
+    if (on_image_screen_)
+      actor_->ShowTutorialPage();
+    else
+      actor_->ShowIntroPage();
   }
 
   NetworkPortalDetector* detector = NetworkPortalDetector::GetInstance();
   if (detector && !on_error_screen_)
     detector->AddAndFireObserver(this);
   on_error_screen_ = false;
 }
 
 void LocallyManagedUserCreationScreen::OnPortalDetectionCompleted(
     const Network* network,
     const NetworkPortalDetector::CaptivePortalState& state)  {
   if (state.status == NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE) {
     get_screen_observer()->HideErrorScreen(this);
   } else {
     on_error_screen_ = true;
     ErrorScreen* screen = get_screen_observer()->GetErrorScreen();
     ConfigureErrorScreen(screen, network, state.status);
     screen->SetUIState(ErrorScreen::UI_STATE_LOCALLY_MANAGED);
     get_screen_observer()->ShowErrorScreen();
   }
 }
 
 void LocallyManagedUserCreationScreen::
     ShowManagerInconsistentStateErrorScreen() {
   if (!actor_)
     return;
-  actor_->ShowErrorMessage(
+  actor_->ShowErrorPage(
       l10n_util::GetStringUTF16(
           IDS_CREATE_LOCALLY_MANAGED_USER_MANAGER_INCONSISTENT_STATE),
       false);
 }
 
 void LocallyManagedUserCreationScreen::ShowInitialScreen() {
   if (actor_)
-    actor_->ShowInitialScreen();
+    actor_->ShowIntroPage();
 }
 
 void LocallyManagedUserCreationScreen::Hide() {
   if (actor_)
     actor_->Hide();
   NetworkPortalDetector* detector = NetworkPortalDetector::GetInstance();
   if (detector && !on_error_screen_)
     detector->RemoveObserver(this);
 }
 
 std::string LocallyManagedUserCreationScreen::GetName() const {
   return WizardController::kLocallyManagedUserCreationScreenName;
 }
 
 void LocallyManagedUserCreationScreen::AbortFlow() {
   controller_->FinishCreation();
 }
 
 void LocallyManagedUserCreationScreen::FinishFlow() {
   controller_->FinishCreation();
 }
 
-void LocallyManagedUserCreationScreen::RetryLastStep() {
-  controller_->RetryLastStep();
-}
-
-void LocallyManagedUserCreationScreen::RunFlow(
-    string16& display_name,
-    std::string& managed_user_password,
+void LocallyManagedUserCreationScreen::AuthenticateManager(
     std::string& manager_id,
     std::string& manager_password) {
-
   // Make sure no two controllers exist at the same time.
   controller_.reset();
   controller_.reset(new LocallyManagedUserController(this));
-  controller_->SetUpCreation(display_name, managed_user_password);
 
   ExistingUserController::current_controller()->
       Login(UserContext(manager_id,
                         manager_password,
                         std::string()  /* auth_code */));
 }
 
+void LocallyManagedUserCreationScreen::CreateManagedUser(
+    string16& display_name,
+    std::string& managed_user_password) {
+  DCHECK(controller_.get());
+  controller_->SetUpCreation(display_name, managed_user_password);
+  controller_->StartCreation();
+}
+
 void LocallyManagedUserCreationScreen::OnManagerLoginFailure() {
   if (actor_)
     actor_->ShowManagerPasswordError();
 }
 
-void LocallyManagedUserCreationScreen::OnManagerSignIn() {
+void LocallyManagedUserCreationScreen::OnManagerFullyAuthenticated() {
   if (actor_)
-    actor_->ShowProgressScreen();
-  controller_->StartCreation();
+    actor_->ShowUsernamePage();
+}
+
+void LocallyManagedUserCreationScreen::OnManagerCryptohomeAuthenticated() {
+  if (actor_)
+    actor_->ShowProgressPage();
 }
 
 void LocallyManagedUserCreationScreen::OnExit() {}
 
 void LocallyManagedUserCreationScreen::OnActorDestroyed(
     LocallyManagedUserCreationScreenHandler* actor) {
   if (actor_ == actor)
     actor_ = NULL;
 }
 
@@ skipping 19 matching lines @@
           IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_ERROR_TIMED_OUT);
       break;
     case LocallyManagedUserController::CLOUD_SERVER_ERROR:
       message = l10n_util::GetStringUTF16(
           IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_ERROR_SERVER_ERROR);
       break;
     default:
       NOTREACHED();
   }
   if (actor_)
-    actor_->ShowErrorMessage(message, recoverable);
+    actor_->ShowErrorPage(message, recoverable);
 }
 
 void LocallyManagedUserCreationScreen::SelectPicture() {
   on_image_screen_ = true;
   WizardController::default_controller()->
       EnableUserImageScreenReturnToPreviousHack();
   DictionaryValue* params = new DictionaryValue();
   params->SetBoolean("profile_picture_enabled", false);
   params->SetString("user_id", controller_->GetManagedUserId());
 
   WizardController::default_controller()->
       AdvanceToScreenWithParams(WizardController::kUserImageScreenName, params);
 }
 
 void LocallyManagedUserCreationScreen::OnCreationSuccess() {
   SelectPicture();
 }
 
 }  // namespace chromeos