cros: Unify oobe View/Actor naming to just View.

chrome/browser/chromeos/login/supervised/supervised_user_creation_screen.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/supervised/supervised_user_creation_screen.h"
 
 #include <utility>
 
 #include "ash/common/wallpaper/wallpaper_controller.h"
 #include "ash/common/wm_shell.h"
@@ skipping 84 matching lines @@
 
 // static
 SupervisedUserCreationScreen* SupervisedUserCreationScreen::Get(
     ScreenManager* manager) {
   return static_cast<SupervisedUserCreationScreen*>(
       manager->GetScreen(OobeScreen::SCREEN_CREATE_SUPERVISED_USER_FLOW));
 }
 
 SupervisedUserCreationScreen::SupervisedUserCreationScreen(
     BaseScreenDelegate* base_screen_delegate,
-    SupervisedUserCreationScreenHandler* actor)
+    SupervisedUserCreationScreenHandler* view)
     : BaseScreen(base_screen_delegate,
                  OobeScreen::SCREEN_CREATE_SUPERVISED_USER_FLOW),
-      actor_(actor),
+      view_(view),
       on_error_screen_(false),
       manager_signin_in_progress_(false),
       last_page_(kNameOfIntroScreen),
       sync_service_(NULL),
       apply_photo_after_decoding_(false),
       selected_image_(0),
       histogram_helper_(new ErrorScreensHistogramHelper("Supervised")),
       weak_factory_(this) {
-  DCHECK(actor_);
-  if (actor_)
-    actor_->SetDelegate(this);
+  DCHECK(view_);
+  if (view_)
+    view_->SetDelegate(this);
 }
 
 SupervisedUserCreationScreen::~SupervisedUserCreationScreen() {
   CameraPresenceNotifier::GetInstance()->RemoveObserver(this);
   if (sync_service_)
     sync_service_->RemoveObserver(this);
-  if (actor_)
-    actor_->SetDelegate(NULL);
+  if (view_)
+    view_->SetDelegate(NULL);
   network_portal_detector::GetInstance()->RemoveObserver(this);
 }
 
 void SupervisedUserCreationScreen::Show() {
   CameraPresenceNotifier::GetInstance()->AddObserver(this);
-  if (actor_) {
-    actor_->Show();
+  if (view_) {
+    view_->Show();
     // TODO(antrim) : temorary hack (until upcoming hackaton). Should be
     // removed once we have screens reworked.
     if (on_error_screen_)
-      actor_->ShowPage(last_page_);
+      view_->ShowPage(last_page_);
     else
-      actor_->ShowIntroPage();
+      view_->ShowIntroPage();
   }
 
   if (!on_error_screen_)
     network_portal_detector::GetInstance()->AddAndFireObserver(this);
   on_error_screen_ = false;
   histogram_helper_->OnScreenShow();
 }
 
 void SupervisedUserCreationScreen::OnPageSelected(const std::string& page) {
   last_page_ = page;
@@ skipping 11 matching lines @@
     ErrorScreen* screen = get_base_screen_delegate()->GetErrorScreen();
     ConfigureErrorScreen(screen, network, state.status);
     screen->SetUIState(NetworkError::UI_STATE_SUPERVISED);
     get_base_screen_delegate()->ShowErrorScreen();
     histogram_helper_->OnErrorShow(screen->GetErrorState());
   }
 }
 
 void SupervisedUserCreationScreen::ShowManagerInconsistentStateErrorScreen() {
   manager_signin_in_progress_ = false;
-  if (!actor_)
+  if (!view_)
     return;
-  actor_->ShowErrorPage(
+  view_->ShowErrorPage(
       l10n_util::GetStringUTF16(
           IDS_CREATE_SUPERVISED_USER_MANAGER_INCONSISTENT_STATE_TITLE),
       l10n_util::GetStringUTF16(
           IDS_CREATE_SUPERVISED_USER_MANAGER_INCONSISTENT_STATE),
       l10n_util::GetStringUTF16(
           IDS_CREATE_SUPERVISED_USER_MANAGER_INCONSISTENT_STATE_BUTTON));
 }
 
 void SupervisedUserCreationScreen::ShowInitialScreen() {
-  if (actor_)
-    actor_->ShowIntroPage();
+  if (view_)
+    view_->ShowIntroPage();
 }
 
 void SupervisedUserCreationScreen::Hide() {
   CameraPresenceNotifier::GetInstance()->RemoveObserver(this);
-  if (actor_)
-    actor_->Hide();
+  if (view_)
+    view_->Hide();
   if (!on_error_screen_)
     network_portal_detector::GetInstance()->RemoveObserver(this);
 }
 
 void SupervisedUserCreationScreen::AbortFlow() {
   DBusThreadManager::Get()
       ->GetSessionManagerClient()
       ->NotifySupervisedUserCreationFinished();
   controller_->CancelCreation();
 }
@@ skipping 64 matching lines @@
   user_info->GetString(SupervisedUserSyncService::kMasterKey, &master_key);
   user_info->GetString(SupervisedUserSyncService::kPasswordSignatureKey,
                        &signature_key);
   user_info->GetString(SupervisedUserSyncService::kPasswordEncryptionKey,
                        &encryption_key);
   user_info->GetString(SupervisedUserSyncService::kChromeOsAvatar, &avatar);
   user_info->GetBoolean(kUserExists, &exists);
 
   // We should not get here with existing user selected, so just display error.
   if (exists) {
-    actor_->ShowErrorPage(
+    view_->ShowErrorPage(
         l10n_util::GetStringUTF16(
             IDS_CREATE_SUPERVISED_USER_GENERIC_ERROR_TITLE),
-        l10n_util::GetStringUTF16(
-            IDS_CREATE_SUPERVISED_USER_GENERIC_ERROR),
+        l10n_util::GetStringUTF16(IDS_CREATE_SUPERVISED_USER_GENERIC_ERROR),
         l10n_util::GetStringUTF16(
             IDS_CREATE_SUPERVISED_USER_GENERIC_ERROR_BUTTON));
     return;
   }
 
   SupervisedUserSyncService::GetAvatarIndex(avatar, &avatar_index);
 
   const base::DictionaryValue* password_data = NULL;
   SupervisedUserSharedSettingsService* shared_settings_service =
       SupervisedUserSharedSettingsServiceFactory::GetForBrowserContext(
@@ skipping 35 matching lines @@
   std::string avatar;
   bool exists;
   int avatar_index = SupervisedUserCreationController::kDummyAvatarIndex;
   user_info->GetString(SupervisedUserSyncService::kName, &display_name);
   user_info->GetString(SupervisedUserSyncService::kMasterKey, &master_key);
   user_info->GetString(SupervisedUserSyncService::kChromeOsAvatar, &avatar);
   user_info->GetBoolean(kUserExists, &exists);
 
   // We should not get here with existing user selected, so just display error.
   if (exists) {
-    actor_->ShowErrorPage(
+    view_->ShowErrorPage(
         l10n_util::GetStringUTF16(
             IDS_CREATE_SUPERVISED_USER_GENERIC_ERROR_TITLE),
-        l10n_util::GetStringUTF16(
-            IDS_CREATE_SUPERVISED_USER_GENERIC_ERROR),
+        l10n_util::GetStringUTF16(IDS_CREATE_SUPERVISED_USER_GENERIC_ERROR),
         l10n_util::GetStringUTF16(
             IDS_CREATE_SUPERVISED_USER_GENERIC_ERROR_BUTTON));
     return;
   }
 
   SupervisedUserSyncService::GetAvatarIndex(avatar, &avatar_index);
 
   controller_->StartImport(display_name,
                            password,
                            avatar_index,
                            user_id,
                            master_key);
 }
 
 void SupervisedUserCreationScreen::OnManagerLoginFailure() {
   manager_signin_in_progress_ = false;
-  if (actor_)
-    actor_->ShowManagerPasswordError();
+  if (view_)
+    view_->ShowManagerPasswordError();
 }
 
 void SupervisedUserCreationScreen::OnManagerFullyAuthenticated(
     Profile* manager_profile) {
   DBusThreadManager::Get()
       ->GetSessionManagerClient()
       ->NotifySupervisedUserCreationStarted();
   manager_signin_in_progress_ = false;
   DCHECK(controller_.get());
   // For manager user, move wallpaper to locked container so that windows
   // created during the user image picker step are below it.
   ash::WmShell::Get()->wallpaper_controller()->MoveToLockedContainer();
 
   controller_->SetManagerProfile(manager_profile);
-  if (actor_)
-    actor_->ShowUsernamePage();
+  if (view_)
+    view_->ShowUsernamePage();
 
   last_page_ = kNameOfNewUserParametersScreen;
   CHECK(!sync_service_);
   sync_service_ = SupervisedUserSyncServiceFactory::GetForProfile(
       manager_profile);
   sync_service_->AddObserver(this);
   OnSupervisedUsersChanged();
 }
 
 void SupervisedUserCreationScreen::OnSupervisedUsersChanged() {
   CHECK(sync_service_);
   sync_service_->GetSupervisedUsersAsync(
       base::Bind(&SupervisedUserCreationScreen::OnGetSupervisedUsers,
                  weak_factory_.GetWeakPtr()));
 }
 
 void SupervisedUserCreationScreen::OnManagerCryptohomeAuthenticated() {
-  if (actor_) {
-    actor_->ShowStatusMessage(true /* progress */, l10n_util::GetStringUTF16(
-        IDS_CREATE_SUPERVISED_USER_CREATION_AUTH_PROGRESS_MESSAGE));
+  if (view_) {
+    view_->ShowStatusMessage(
+        true /* progress */,
+        l10n_util::GetStringUTF16(
+            IDS_CREATE_SUPERVISED_USER_CREATION_AUTH_PROGRESS_MESSAGE));
   }
 }
 
-void SupervisedUserCreationScreen::OnActorDestroyed(
-    SupervisedUserCreationScreenHandler* actor) {
-  if (actor_ == actor)
-    actor_ = NULL;
+void SupervisedUserCreationScreen::OnViewDestroyed(
+    SupervisedUserCreationScreenHandler* view) {
+  if (view_ == view)
+    view_ = NULL;
 }
 
 void SupervisedUserCreationScreen::OnCreationError(
     SupervisedUserCreationController::ErrorCode code) {
   LOG(ERROR) << "Supervised user creation failure, code: " << code;
 
   base::string16 title;
   base::string16 message;
   base::string16 button;
   // TODO(antrim) : find out which errors do we really have.
@@ skipping 14 matching lines @@
       title = l10n_util::GetStringUTF16(
           IDS_CREATE_SUPERVISED_USER_GENERIC_ERROR_TITLE);
       message = l10n_util::GetStringUTF16(
           IDS_CREATE_SUPERVISED_USER_GENERIC_ERROR);
       button = l10n_util::GetStringUTF16(
           IDS_CREATE_SUPERVISED_USER_GENERIC_ERROR_BUTTON);
       break;
     case SupervisedUserCreationController::NO_ERROR:
       NOTREACHED();
   }
-  if (actor_)
-    actor_->ShowErrorPage(title, message, button);
+  if (view_)
+    view_->ShowErrorPage(title, message, button);
 }
 
 void SupervisedUserCreationScreen::OnCreationTimeout() {
-  if (actor_) {
-    actor_->ShowStatusMessage(false /* error */, l10n_util::GetStringUTF16(
-        IDS_CREATE_SUPERVISED_USER_CREATION_CREATION_TIMEOUT_MESSAGE));
+  if (view_) {
+    view_->ShowStatusMessage(
+        false /* error */,
+        l10n_util::GetStringUTF16(
+            IDS_CREATE_SUPERVISED_USER_CREATION_CREATION_TIMEOUT_MESSAGE));
   }
 }
 
 void SupervisedUserCreationScreen::OnLongCreationWarning() {
-  if (actor_) {
-    actor_->ShowStatusMessage(true /* progress */, l10n_util::GetStringUTF16(
-        IDS_PROFILES_CREATE_SUPERVISED_JUST_SIGNED_IN));
+  if (view_) {
+    view_->ShowStatusMessage(
+        true /* progress */,
+        l10n_util::GetStringUTF16(
+            IDS_PROFILES_CREATE_SUPERVISED_JUST_SIGNED_IN));
   }
 }
 
 bool SupervisedUserCreationScreen::FindUserByDisplayName(
     const base::string16& display_name,
     std::string *out_id) const {
   if (!existing_users_.get())
     return false;
   for (base::DictionaryValue::Iterator it(*existing_users_.get());
        !it.IsAtEnd(); it.Advance()) {
@@ skipping 33 matching lines @@
     case user_manager::User::USER_IMAGE_PROFILE:
       NOTREACHED() << "Supervised users have no profile pictures";
       break;
     default:
       DCHECK(selected_image_ >= 0 &&
              selected_image_ < default_user_image::kDefaultImagesCount);
       image_manager->SaveUserDefaultImageIndex(selected_image_);
       break;
   }
   // Proceed to tutorial.
-  actor_->ShowTutorialPage();
+  view_->ShowTutorialPage();
 }
 
 void SupervisedUserCreationScreen::OnCreationSuccess() {
   ApplyPicture();
 }
 
 void SupervisedUserCreationScreen::OnCameraPresenceCheckDone(
     bool is_camera_present) {
-  if (actor_)
-    actor_->SetCameraPresent(is_camera_present);
+  if (view_)
+    view_->SetCameraPresent(is_camera_present);
 }
 
 void SupervisedUserCreationScreen::OnGetSupervisedUsers(
     const base::DictionaryValue* users) {
   // Copy for passing to WebUI, contains only id, name and avatar URL.
   std::unique_ptr<base::ListValue> ui_users(new base::ListValue());
   SupervisedUserManager* supervised_user_manager =
       ChromeUserManager::Get()->GetSupervisedUserManager();
 
   // Stored copy, contains all necessary information.
@@ skipping 51 matching lines @@
         local_copy->GetString(SupervisedUserSyncService::kPasswordSignatureKey,
                               &signature_key) &&
         !signature_key.empty();
 
     ui_copy->SetBoolean(kUserNeedPassword, !has_password);
     ui_copy->SetString("id", it.key());
 
     existing_users_->Set(it.key(), local_copy);
     ui_users->Append(std::move(ui_copy));
   }
-  actor_->ShowExistingSupervisedUsers(ui_users.get());
+  view_->ShowExistingSupervisedUsers(ui_users.get());
 }
 
 void SupervisedUserCreationScreen::OnPhotoTaken(
     const std::string& raw_data) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   user_photo_ = gfx::ImageSkia();
   ImageDecoder::Cancel(this);
   ImageDecoder::Start(this, raw_data);
 }
 
@@ skipping 21 matching lines @@
     selected_image_ = user_manager::User::USER_IMAGE_EXTERNAL;
   } else {
     NOTREACHED() << "Unexpected image type: " << image_type;
   }
 }
 
 void SupervisedUserCreationScreen::OnImageAccepted() {
 }
 
 }  // namespace chromeos