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

chrome/browser/chromeos/login/app_launch_controller.cc

 // Copyright 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/app_launch_controller.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/json/json_file_value_serializer.h"
@@ skipping 132 matching lines @@
 // AppLaunchController
 
 AppLaunchController::AppLaunchController(const std::string& app_id,
                                          bool diagnostic_mode,
                                          LoginDisplayHost* host,
                                          OobeUI* oobe_ui)
     : app_id_(app_id),
       diagnostic_mode_(diagnostic_mode),
       host_(host),
       oobe_ui_(oobe_ui),
-      app_launch_splash_screen_actor_(
-          oobe_ui_->GetAppLaunchSplashScreenActor()) {}
+      app_launch_splash_screen_view_(oobe_ui_->GetAppLaunchSplashScreenView()) {
+}
 
 AppLaunchController::~AppLaunchController() {
-  app_launch_splash_screen_actor_->SetDelegate(NULL);
+  app_launch_splash_screen_view_->SetDelegate(NULL);
 }
 
 void AppLaunchController::StartAppLaunch(bool is_auto_launch) {
   DVLOG(1) << "Starting kiosk mode...";
 
   RecordKioskLaunchUMA(is_auto_launch);
 
   // Ensure WebUILoginView is enabled so that bailout shortcut key works.
   host_->GetWebUILoginView()->SetUIEnabled(true);
 
   webui_visible_ = host_->GetWebUILoginView()->webui_visible();
   if (!webui_visible_) {
     registrar_.Add(this, chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
                    content::NotificationService::AllSources());
   }
   launch_splash_start_time_ = base::TimeTicks::Now().ToInternalValue();
 
   // TODO(tengs): Add a loading profile app launch state.
-  app_launch_splash_screen_actor_->SetDelegate(this);
-  app_launch_splash_screen_actor_->Show(app_id_);
+  app_launch_splash_screen_view_->SetDelegate(this);
+  app_launch_splash_screen_view_->Show(app_id_);
 
   KioskAppManager::App app;
   CHECK(KioskAppManager::Get());
   CHECK(KioskAppManager::Get()->GetApp(app_id_, &app));
 
   int auto_launch_delay = -1;
   if (is_auto_launch) {
     if (!CrosSettings::Get()->GetInteger(
             kAccountsPrefDeviceLocalAccountAutoLoginDelay,
             &auto_launch_delay)) {
@@ skipping 85 matching lines @@
     return;
 
   OnLaunchFailed(KioskAppLaunchError::USER_CANCEL);
 }
 
 void AppLaunchController::OnNetworkConfigRequested(bool requested) {
   network_config_requested_ = requested;
   if (requested) {
     MaybeShowNetworkConfigureUI();
   } else {
-    app_launch_splash_screen_actor_->UpdateAppLaunchState(
-        AppLaunchSplashScreenActor::APP_LAUNCH_STATE_PREPARING_NETWORK);
+    app_launch_splash_screen_view_->UpdateAppLaunchState(
+        AppLaunchSplashScreenView::APP_LAUNCH_STATE_PREPARING_NETWORK);
     startup_app_launcher_->RestartLauncher();
   }
 }
 
 void AppLaunchController::OnNetworkStateChanged(bool online) {
   if (!waiting_for_network_)
     return;
 
   if (online && !network_config_requested_)
     startup_app_launcher_->ContinueWithNetworkReady();
@@ skipping 79 matching lines @@
 
   return !IsEnterpriseManaged();
 }
 
 void AppLaunchController::MaybeShowNetworkConfigureUI() {
   if (CanConfigureNetwork()) {
     if (NeedOwnerAuthToConfigureNetwork()) {
       if (network_config_requested_)
         OnConfigureNetwork();
       else
-        app_launch_splash_screen_actor_->ToggleNetworkConfig(true);
+        app_launch_splash_screen_view_->ToggleNetworkConfig(true);
     } else {
       ShowNetworkConfigureUIWhenReady();
     }
   } else {
-    app_launch_splash_screen_actor_->UpdateAppLaunchState(
-        AppLaunchSplashScreenActor::APP_LAUNCH_STATE_NETWORK_WAIT_TIMEOUT);
+    app_launch_splash_screen_view_->UpdateAppLaunchState(
+        AppLaunchSplashScreenView::APP_LAUNCH_STATE_NETWORK_WAIT_TIMEOUT);
   }
 }
 
 void AppLaunchController::ShowNetworkConfigureUIWhenReady() {
   if (!profile_) {
     show_network_config_ui_after_profile_load_ = true;
-    app_launch_splash_screen_actor_->UpdateAppLaunchState(
-        AppLaunchSplashScreenActor::
+    app_launch_splash_screen_view_->UpdateAppLaunchState(
+        AppLaunchSplashScreenView::
             APP_LAUNCH_STATE_SHOWING_NETWORK_CONFIGURE_UI);
     return;
   }
 
   show_network_config_ui_after_profile_load_ = false;
   showing_network_dialog_ = true;
-  app_launch_splash_screen_actor_->ShowNetworkConfigureUI();
+  app_launch_splash_screen_view_->ShowNetworkConfigureUI();
 }
 
 void AppLaunchController::InitializeNetwork() {
   // Show the network configuration dialog if network is not initialized
   // after a brief wait time.
   waiting_for_network_ = true;
   network_wait_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromSeconds(network_wait_time_),
       this, &AppLaunchController::OnNetworkWaitTimedout);
 
-  app_launch_splash_screen_actor_->UpdateAppLaunchState(
-      AppLaunchSplashScreenActor::APP_LAUNCH_STATE_PREPARING_NETWORK);
+  app_launch_splash_screen_view_->UpdateAppLaunchState(
+      AppLaunchSplashScreenView::APP_LAUNCH_STATE_PREPARING_NETWORK);
 }
 
 bool AppLaunchController::IsNetworkReady() {
-  return app_launch_splash_screen_actor_->IsNetworkReady();
+  return app_launch_splash_screen_view_->IsNetworkReady();
 }
 
 bool AppLaunchController::ShouldSkipAppInstallation() {
   return false;
 }
 
 void AppLaunchController::OnLoadingOAuthFile() {
-  app_launch_splash_screen_actor_->UpdateAppLaunchState(
-      AppLaunchSplashScreenActor::APP_LAUNCH_STATE_LOADING_AUTH_FILE);
+  app_launch_splash_screen_view_->UpdateAppLaunchState(
+      AppLaunchSplashScreenView::APP_LAUNCH_STATE_LOADING_AUTH_FILE);
 }
 
 void AppLaunchController::OnInitializingTokenService() {
-  app_launch_splash_screen_actor_->UpdateAppLaunchState(
-      AppLaunchSplashScreenActor::APP_LAUNCH_STATE_LOADING_TOKEN_SERVICE);
+  app_launch_splash_screen_view_->UpdateAppLaunchState(
+      AppLaunchSplashScreenView::APP_LAUNCH_STATE_LOADING_TOKEN_SERVICE);
 }
 
 void AppLaunchController::OnInstallingApp() {
-  app_launch_splash_screen_actor_->UpdateAppLaunchState(
-      AppLaunchSplashScreenActor::APP_LAUNCH_STATE_INSTALLING_APPLICATION);
+  app_launch_splash_screen_view_->UpdateAppLaunchState(
+      AppLaunchSplashScreenView::APP_LAUNCH_STATE_INSTALLING_APPLICATION);
 
   ClearNetworkWaitTimer();
-  app_launch_splash_screen_actor_->ToggleNetworkConfig(false);
+  app_launch_splash_screen_view_->ToggleNetworkConfig(false);
 
   // We have connectivity at this point, so we can skip the network
   // configuration dialog if it is being shown.
   if (showing_network_dialog_) {
-    app_launch_splash_screen_actor_->Show(app_id_);
+    app_launch_splash_screen_view_->Show(app_id_);
     showing_network_dialog_ = false;
     launch_splash_start_time_ = base::TimeTicks::Now().ToInternalValue();
   }
 }
 
 void AppLaunchController::OnReadyToLaunch() {
   launcher_ready_ = true;
 
   if (network_config_requested_)
     return;
@@ skipping 21 matching lines @@
         this,
         &AppLaunchController::OnReadyToLaunch);
     return;
   }
 
   startup_app_launcher_->LaunchApp();
 }
 
 void AppLaunchController::OnLaunchSucceeded() {
   DVLOG(1) << "Kiosk launch succeeded, wait for app window.";
-  app_launch_splash_screen_actor_->UpdateAppLaunchState(
-      AppLaunchSplashScreenActor::APP_LAUNCH_STATE_WAITING_APP_WINDOW);
+  app_launch_splash_screen_view_->UpdateAppLaunchState(
+      AppLaunchSplashScreenView::APP_LAUNCH_STATE_WAITING_APP_WINDOW);
 
   DCHECK(!app_window_watcher_);
   app_window_watcher_.reset(new AppWindowWatcher(this, app_id_));
 }
 
 void AppLaunchController::OnLaunchFailed(KioskAppLaunchError::Error error) {
   DCHECK_NE(KioskAppLaunchError::NONE, error);
   LOG(ERROR) << "Kiosk launch failed, error=" << error;
 
   // Reboot on the recoverable cryptohome errors.
   if (error == KioskAppLaunchError::CRYPTOHOMED_NOT_RUNNING ||
       error == KioskAppLaunchError::ALREADY_MOUNTED) {
     // Do not save the error because saved errors would stop app from launching
     // on the next run.
     chrome::AttemptRelaunch();
     return;
   }
 
   // Saves the error and ends the session to go back to login screen.
   KioskAppLaunchError::Save(error);
   chrome::AttemptUserExit();
   CleanUp();
 }
 
 bool AppLaunchController::IsShowingNetworkConfigScreen() {
   return network_config_requested_;
 }
 
 }   // namespace chromeos