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

chrome/browser/ui/webui/chromeos/login/oobe_ui.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/ui/webui/chromeos/login/oobe_ui.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "ash/common/wm/screen_dimmer.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part.h"
-#include "chrome/browser/chromeos/login/enrollment/auto_enrollment_check_screen_actor.h"
-#include "chrome/browser/chromeos/login/enrollment/enrollment_screen_actor.h"
+#include "chrome/browser/chromeos/login/enrollment/auto_enrollment_check_screen_view.h"
+#include "chrome/browser/chromeos/login/enrollment/enrollment_screen_view.h"
 #include "chrome/browser/chromeos/login/screens/error_screen.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/settings/shutdown_policy_handler.h"
 #include "chrome/browser/chromeos/system/input_device_settings.h"
 #include "chrome/browser/extensions/signin/gaia_auth_extension_loader.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/ash/ash_util.h"
@@ skipping 196 matching lines @@
 
   if (display_type_ == kOobeDisplay) {
     auto network_screen_handler =
         base::MakeUnique<NetworkScreenHandler>(core_handler_);
     network_view_ = network_screen_handler.get();
     AddScreenHandler(std::move(network_screen_handler));
   }
 
   auto debugging_screen_handler =
       base::MakeUnique<EnableDebuggingScreenHandler>();
-  debugging_screen_actor_ = debugging_screen_handler.get();
+  debugging_screen_view_ = debugging_screen_handler.get();
   AddScreenHandler(std::move(debugging_screen_handler));
 
   auto eula_screen_handler = base::MakeUnique<EulaScreenHandler>(core_handler_);
   eula_view_ = eula_screen_handler.get();
   AddScreenHandler(std::move(eula_screen_handler));
 
   auto reset_screen_handler = base::MakeUnique<ResetScreenHandler>();
   reset_view_ = reset_screen_handler.get();
   AddScreenHandler(std::move(reset_screen_handler));
 
   auto autolaunch_screen_handler =
       base::MakeUnique<KioskAutolaunchScreenHandler>();
-  autolaunch_screen_actor_ = autolaunch_screen_handler.get();
+  autolaunch_screen_view_ = autolaunch_screen_handler.get();
   AddScreenHandler(std::move(autolaunch_screen_handler));
 
   auto kiosk_enable_screen_handler =
       base::MakeUnique<KioskEnableScreenHandler>();
-  kiosk_enable_screen_actor_ = kiosk_enable_screen_handler.get();
+  kiosk_enable_screen_view_ = kiosk_enable_screen_handler.get();
   AddScreenHandler(std::move(kiosk_enable_screen_handler));
 
   auto supervised_user_creation_screen_handler =
       base::MakeUnique<SupervisedUserCreationScreenHandler>();
-  supervised_user_creation_screen_actor_ =
+  supervised_user_creation_screen_view_ =
       supervised_user_creation_screen_handler.get();
   AddScreenHandler(std::move(supervised_user_creation_screen_handler));
 
   auto wrong_hwid_screen_handler = base::MakeUnique<WrongHWIDScreenHandler>();
-  wrong_hwid_screen_actor_ = wrong_hwid_screen_handler.get();
+  wrong_hwid_screen_view_ = wrong_hwid_screen_handler.get();
   AddScreenHandler(std::move(wrong_hwid_screen_handler));
 
   auto auto_enrollment_check_screen_handler =
       base::MakeUnique<AutoEnrollmentCheckScreenHandler>();
-  auto_enrollment_check_screen_actor_ =
+  auto_enrollment_check_screen_view_ =
       auto_enrollment_check_screen_handler.get();
   AddScreenHandler(std::move(auto_enrollment_check_screen_handler));
 
   auto hid_detection_screen_handler =
       base::MakeUnique<HIDDetectionScreenHandler>(core_handler_);
   hid_detection_view_ = hid_detection_screen_handler.get();
   AddScreenHandler(std::move(hid_detection_screen_handler));
 
   auto error_screen_handler = base::MakeUnique<ErrorScreenHandler>();
   error_screen_handler_ = error_screen_handler.get();
   AddScreenHandler(std::move(error_screen_handler));
   network_dropdown_handler_->AddObserver(error_screen_handler_);
 
   error_screen_.reset(new ErrorScreen(nullptr, error_screen_handler_));
   ErrorScreen* error_screen = error_screen_.get();
 
   auto enrollment_screen_handler = base::MakeUnique<EnrollmentScreenHandler>(
       network_state_informer_, error_screen);
-  enrollment_screen_actor_ = enrollment_screen_handler.get();
+  enrollment_screen_view_ = enrollment_screen_handler.get();
   AddScreenHandler(std::move(enrollment_screen_handler));
 
   auto terms_of_service_screen_handler =
       base::MakeUnique<TermsOfServiceScreenHandler>(core_handler_);
-  terms_of_service_screen_actor_ = terms_of_service_screen_handler.get();
+  terms_of_service_screen_view_ = terms_of_service_screen_handler.get();
   AddScreenHandler(std::move(terms_of_service_screen_handler));
 
   auto arc_terms_of_service_screen_handler =
       base::MakeUnique<ArcTermsOfServiceScreenHandler>();
-  arc_terms_of_service_screen_actor_ =
-      arc_terms_of_service_screen_handler.get();
+  arc_terms_of_service_screen_view_ = arc_terms_of_service_screen_handler.get();
   AddScreenHandler(std::move(arc_terms_of_service_screen_handler));
 
   auto user_image_screen_handler = base::MakeUnique<UserImageScreenHandler>();
   user_image_view_ = user_image_screen_handler.get();
   AddScreenHandler(std::move(user_image_screen_handler));
 
   auto user_board_screen_handler = base::MakeUnique<UserBoardScreenHandler>();
   user_board_screen_handler_ = user_board_screen_handler.get();
   AddScreenHandler(std::move(user_board_screen_handler));
 
   auto gaia_screen_handler = base::MakeUnique<GaiaScreenHandler>(
       core_handler_, network_state_informer_);
   gaia_screen_handler_ = gaia_screen_handler.get();
   AddScreenHandler(std::move(gaia_screen_handler));
 
   auto signin_screen_handler = base::MakeUnique<SigninScreenHandler>(
       network_state_informer_, error_screen, core_handler_,
       gaia_screen_handler_);
   signin_screen_handler_ = signin_screen_handler.get();
   AddScreenHandler(std::move(signin_screen_handler));
 
   auto app_launch_splash_screen_handler =
       base::MakeUnique<AppLaunchSplashScreenHandler>(network_state_informer_,
                                                      error_screen);
-  app_launch_splash_screen_actor_ = app_launch_splash_screen_handler.get();
+  app_launch_splash_screen_view_ = app_launch_splash_screen_handler.get();
   AddScreenHandler(std::move(app_launch_splash_screen_handler));
 
   auto arc_kiosk_splash_screen_handler =
       base::MakeUnique<ArcKioskSplashScreenHandler>();
-  arc_kiosk_splash_screen_actor_ = arc_kiosk_splash_screen_handler.get();
+  arc_kiosk_splash_screen_view_ = arc_kiosk_splash_screen_handler.get();
   AddScreenHandler(std::move(arc_kiosk_splash_screen_handler));
 
   if (display_type_ == kOobeDisplay) {
     auto controller_pairing_handler =
         base::MakeUnique<ControllerPairingScreenHandler>();
-    controller_pairing_screen_actor_ = controller_pairing_handler.get();
+    controller_pairing_screen_view_ = controller_pairing_handler.get();
     AddScreenHandler(std::move(controller_pairing_handler));
 
     auto host_pairing_handler = base::MakeUnique<HostPairingScreenHandler>();
-    host_pairing_screen_actor_ = host_pairing_handler.get();
+    host_pairing_screen_view_ = host_pairing_handler.get();
     AddScreenHandler(std::move(host_pairing_handler));
   }
 
   auto device_disabled_screen_handler =
       base::MakeUnique<DeviceDisabledScreenHandler>();
-  device_disabled_screen_actor_ = device_disabled_screen_handler.get();
+  device_disabled_screen_view_ = device_disabled_screen_handler.get();
   AddScreenHandler(std::move(device_disabled_screen_handler));
 
   // Initialize KioskAppMenuHandler. Note that it is NOT a screen handler.
   auto kiosk_app_menu_handler =
       base::MakeUnique<KioskAppMenuHandler>(network_state_informer_);
   kiosk_app_menu_handler_ = kiosk_app_menu_handler.get();
   web_ui->AddMessageHandler(std::move(kiosk_app_menu_handler));
 
   base::DictionaryValue localized_strings;
   GetLocalizedStrings(&localized_strings);
@@ skipping 27 matching lines @@
 OobeUI::~OobeUI() {
   core_handler_->SetDelegate(nullptr);
   network_dropdown_handler_->RemoveObserver(error_screen_handler_);
   if (chrome::IsRunningInMash()) {
     // TODO: Ash needs to expose screen dimming api. See
     // http://crbug.com/646034.
     NOTIMPLEMENTED();
   }
 }
 
-CoreOobeActor* OobeUI::GetCoreOobeActor() {
+CoreOobeView* OobeUI::GetCoreOobeView() {
   return core_handler_;
 }
 
 NetworkView* OobeUI::GetNetworkView() {
   return network_view_;
 }
 
 EulaView* OobeUI::GetEulaView() {
   return eula_view_;
 }
 
 UpdateView* OobeUI::GetUpdateView() {
   return update_view_;
 }
 
-EnableDebuggingScreenActor* OobeUI::GetEnableDebuggingScreenActor() {
-  return debugging_screen_actor_;
+EnableDebuggingScreenView* OobeUI::GetEnableDebuggingScreenView() {
+  return debugging_screen_view_;
 }
 
-EnrollmentScreenActor* OobeUI::GetEnrollmentScreenActor() {
-  return enrollment_screen_actor_;
+EnrollmentScreenView* OobeUI::GetEnrollmentScreenView() {
+  return enrollment_screen_view_;
 }
 
 ResetView* OobeUI::GetResetView() {
   return reset_view_;
 }
 
-KioskAutolaunchScreenActor* OobeUI::GetKioskAutolaunchScreenActor() {
-  return autolaunch_screen_actor_;
+KioskAutolaunchScreenView* OobeUI::GetKioskAutolaunchScreenView() {
+  return autolaunch_screen_view_;
 }
 
-KioskEnableScreenActor* OobeUI::GetKioskEnableScreenActor() {
-  return kiosk_enable_screen_actor_;
+KioskEnableScreenView* OobeUI::GetKioskEnableScreenView() {
+  return kiosk_enable_screen_view_;
 }
 
-TermsOfServiceScreenActor* OobeUI::GetTermsOfServiceScreenActor() {
-  return terms_of_service_screen_actor_;
+TermsOfServiceScreenView* OobeUI::GetTermsOfServiceScreenView() {
+  return terms_of_service_screen_view_;
 }
 
-ArcTermsOfServiceScreenActor* OobeUI::GetArcTermsOfServiceScreenActor() {
-  return arc_terms_of_service_screen_actor_;
+ArcTermsOfServiceScreenView* OobeUI::GetArcTermsOfServiceScreenView() {
+  return arc_terms_of_service_screen_view_;
 }
 
-WrongHWIDScreenActor* OobeUI::GetWrongHWIDScreenActor() {
-  return wrong_hwid_screen_actor_;
+WrongHWIDScreenView* OobeUI::GetWrongHWIDScreenView() {
+  return wrong_hwid_screen_view_;
 }
 
-AutoEnrollmentCheckScreenActor* OobeUI::GetAutoEnrollmentCheckScreenActor() {
-  return auto_enrollment_check_screen_actor_;
+AutoEnrollmentCheckScreenView* OobeUI::GetAutoEnrollmentCheckScreenView() {
+  return auto_enrollment_check_screen_view_;
 }
 
 HIDDetectionView* OobeUI::GetHIDDetectionView() {
   return hid_detection_view_;
 }
 
-ControllerPairingScreenActor* OobeUI::GetControllerPairingScreenActor() {
-  return controller_pairing_screen_actor_;
+ControllerPairingScreenView* OobeUI::GetControllerPairingScreenView() {
+  return controller_pairing_screen_view_;
 }
 
-HostPairingScreenActor* OobeUI::GetHostPairingScreenActor() {
-  return host_pairing_screen_actor_;
+HostPairingScreenView* OobeUI::GetHostPairingScreenView() {
+  return host_pairing_screen_view_;
 }
 
-DeviceDisabledScreenActor* OobeUI::GetDeviceDisabledScreenActor() {
-  return device_disabled_screen_actor_;
+DeviceDisabledScreenView* OobeUI::GetDeviceDisabledScreenView() {
+  return device_disabled_screen_view_;
 }
 
 UserImageView* OobeUI::GetUserImageView() {
   return user_image_view_;
 }
 
 ErrorScreen* OobeUI::GetErrorScreen() {
   return error_screen_.get();
 }
 
 SupervisedUserCreationScreenHandler*
-    OobeUI::GetSupervisedUserCreationScreenActor() {
-  return supervised_user_creation_screen_actor_;
+OobeUI::GetSupervisedUserCreationScreenView() {
+  return supervised_user_creation_screen_view_;
 }
 
-GaiaScreenHandler* OobeUI::GetGaiaScreenActor() {
+GaiaScreenHandler* OobeUI::GetGaiaScreenView() {
   return gaia_screen_handler_;
 }
 
-UserBoardView* OobeUI::GetUserBoardScreenActor() {
+UserBoardView* OobeUI::GetUserBoardView() {
   return user_board_screen_handler_;
 }
 
 void OobeUI::OnShutdownPolicyChanged(bool reboot_on_shutdown) {
   core_handler_->UpdateShutdownAndRebootVisibility(reboot_on_shutdown);
 }
 
-AppLaunchSplashScreenActor*
-      OobeUI::GetAppLaunchSplashScreenActor() {
-  return app_launch_splash_screen_actor_;
+AppLaunchSplashScreenView* OobeUI::GetAppLaunchSplashScreenView() {
+  return app_launch_splash_screen_view_;
 }
 
-ArcKioskSplashScreenActor* OobeUI::GetArcKioskSplashScreenActor() {
-  return arc_kiosk_splash_screen_actor_;
+ArcKioskSplashScreenView* OobeUI::GetArcKioskSplashScreenView() {
+  return arc_kiosk_splash_screen_view_;
 }
 
 void OobeUI::GetLocalizedStrings(base::DictionaryValue* localized_strings) {
   // Note, handlers_[0] is a GenericHandler used by the WebUI.
   for (size_t i = 0; i < handlers_.size(); ++i) {
     handlers_[i]->GetLocalizedStrings(localized_strings);
   }
   const std::string& app_locale = g_browser_process->GetApplicationLocale();
   webui::SetLoadTimeDataDefaults(app_locale, localized_strings);
   kiosk_app_menu_handler_->GetLocalizedStrings(localized_strings);
@@ skipping 130 matching lines @@
 }
 
 void OobeUI::UpdateLocalizedStringsIfNeeded() {
   if (oobe_ui_md_mode_ ==
       g_browser_process->local_state()->GetBoolean(prefs::kOobeMdMode)) {
     return;
   }
 
   base::DictionaryValue localized_strings;
   GetLocalizedStrings(&localized_strings);
-  static_cast<CoreOobeActor*>(core_handler_)->ReloadContent(localized_strings);
+  static_cast<CoreOobeView*>(core_handler_)->ReloadContent(localized_strings);
 }
 
 }  // namespace chromeos