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

chrome/browser/chromeos/login/enrollment/enrollment_screen.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/chromeos/login/enrollment/enrollment_screen.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
@@ skipping 56 matching lines @@
 
 namespace chromeos {
 
 // static
 EnrollmentScreen* EnrollmentScreen::Get(ScreenManager* manager) {
   return static_cast<EnrollmentScreen*>(
       manager->GetScreen(OobeScreen::SCREEN_OOBE_ENROLLMENT));
 }
 
 EnrollmentScreen::EnrollmentScreen(BaseScreenDelegate* base_screen_delegate,
-                                   EnrollmentScreenActor* actor)
+                                   EnrollmentScreenView* view)
     : BaseScreen(base_screen_delegate, OobeScreen::SCREEN_OOBE_ENROLLMENT),
-      actor_(actor),
+      view_(view),
       weak_ptr_factory_(this) {
   retry_policy_.num_errors_to_ignore = 0;
   retry_policy_.initial_delay_ms = kInitialDelayMS;
   retry_policy_.multiply_factor = kMultiplyFactor;
   retry_policy_.jitter_factor = kJitterFactor;
   retry_policy_.maximum_backoff_ms = kMaxDelayMS;
   retry_policy_.entry_lifetime_ms = -1;
   retry_policy_.always_use_initial_delay = true;
   retry_backoff_.reset(new net::BackoffEntry(&retry_policy_));
 }
@@ skipping 29 matching lines @@
   SetConfig();
 }
 
 void EnrollmentScreen::SetConfig() {
   config_ = enrollment_config_;
   if (current_auth_ == AUTH_ATTESTATION) {
     config_.mode = enrollment_config_.is_attestation_forced()
                        ? policy::EnrollmentConfig::MODE_ATTESTATION_FORCED
                        : policy::EnrollmentConfig::MODE_ATTESTATION;
   }
-  actor_->SetParameters(this, config_);
+  view_->SetParameters(this, config_);
   enrollment_helper_ = nullptr;
 }
 
 bool EnrollmentScreen::AdvanceToNextAuth() {
   if (current_auth_ != last_auth_ && current_auth_ == AUTH_ATTESTATION) {
     current_auth_ = AUTH_OAUTH;
     SetConfig();
     return true;
   }
   return false;
@@ skipping 35 matching lines @@
       break;
   }
 }
 
 void EnrollmentScreen::ShowInteractiveScreen() {
   ClearAuth(base::Bind(&EnrollmentScreen::ShowSigninScreen,
                        weak_ptr_factory_.GetWeakPtr()));
 }
 
 void EnrollmentScreen::Hide() {
-  actor_->Hide();
+  view_->Hide();
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 void EnrollmentScreen::AuthenticateUsingAttestation() {
   VLOG(1) << "Authenticating using attestation.";
   elapsed_timer_.reset(new base::ElapsedTimer());
-  actor_->Show();
+  view_->Show();
   CreateEnrollmentHelper();
   enrollment_helper_->EnrollUsingAttestation();
 }
 
 void EnrollmentScreen::OnLoginDone(const std::string& user,
                                    const std::string& auth_code) {
   LOG_IF(ERROR, auth_code.empty()) << "Auth code is empty.";
   elapsed_timer_.reset(new base::ElapsedTimer());
   enrolling_user_domain_ = gaia::ExtractDomainName(user);
   UMA(enrollment_failed_once_ ? policy::kMetricEnrollmentRestarted
                               : policy::kMetricEnrollmentStarted);
 
-  actor_->ShowEnrollmentSpinnerScreen();
+  view_->ShowEnrollmentSpinnerScreen();
   CreateEnrollmentHelper();
   enrollment_helper_->EnrollUsingAuthCode(
       auth_code, shark_controller_ != nullptr /* fetch_additional_token */);
 }
 
 void EnrollmentScreen::OnRetry() {
   retry_task_.Cancel();
   ProcessRetry();
 }
 
@@ skipping 33 matching lines @@
   ClearAuth(base::Bind(&EnrollmentScreen::Finish, base::Unretained(this),
                        BaseScreenDelegate::ENTERPRISE_ENROLLMENT_COMPLETED));
 }
 
 void EnrollmentScreen::OnAdJoined(const std::string& realm) {
   std::move(on_joined_callback_).Run(realm);
 }
 
 void EnrollmentScreen::OnAuthError(const GoogleServiceAuthError& error) {
   RecordEnrollmentErrorMetrics();
-  actor_->ShowAuthError(error);
+  view_->ShowAuthError(error);
 }
 
 void EnrollmentScreen::OnEnrollmentError(policy::EnrollmentStatus status) {
   // TODO(pbond): remove this LOG once http://crbug.com/586961 is fixed.
   LOG(WARNING) << "Enrollment error occured: status=" << status.status()
                << " http status=" << status.http_status()
                << " DM status=" << status.client_status();
   RecordEnrollmentErrorMetrics();
   // If the DM server does not have a device pre-provisioned for attestation-
   // based enrollment and we have a fallback authentication, show it.
   if (status.status() == policy::EnrollmentStatus::REGISTRATION_FAILED &&
       status.client_status() == policy::DM_STATUS_SERVICE_DEVICE_NOT_FOUND &&
       current_auth_ == AUTH_ATTESTATION && AdvanceToNextAuth()) {
     Show();
   } else {
-    actor_->ShowEnrollmentStatus(status);
+    view_->ShowEnrollmentStatus(status);
     if (UsingHandsOffEnrollment())
       AutomaticRetry();
   }
 }
 
 void EnrollmentScreen::OnOtherError(
     EnterpriseEnrollmentHelper::OtherError error) {
   RecordEnrollmentErrorMetrics();
-  actor_->ShowOtherError(error);
+  view_->ShowOtherError(error);
   if (UsingHandsOffEnrollment())
     AutomaticRetry();
 }
 
 void EnrollmentScreen::OnDeviceEnrolled(const std::string& additional_token) {
   // TODO(pbond): remove this LOG once http://crbug.com/586961 is fixed.
   LOG(WARNING) << "Device is successfully enrolled.";
   if (!additional_token.empty())
     SendEnrollmentAuthToken(additional_token);
 
@@ skipping 23 matching lines @@
   }
 
 }
 
 void EnrollmentScreen::OnDeviceAttributeUploadCompleted(bool success) {
   if (success) {
     // If the device attributes have been successfully uploaded, fetch policy.
     policy::BrowserPolicyConnectorChromeOS* connector =
         g_browser_process->platform_part()->browser_policy_connector_chromeos();
     connector->GetDeviceCloudPolicyManager()->core()->RefreshSoon();
-    actor_->ShowEnrollmentStatus(
+    view_->ShowEnrollmentStatus(
         policy::EnrollmentStatus::ForStatus(policy::EnrollmentStatus::SUCCESS));
   } else {
-    actor_->ShowEnrollmentStatus(policy::EnrollmentStatus::ForStatus(
+    view_->ShowEnrollmentStatus(policy::EnrollmentStatus::ForStatus(
         policy::EnrollmentStatus::ATTRIBUTE_UPDATE_FAILED));
   }
 }
 
 void EnrollmentScreen::ShowAttributePromptScreen() {
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()->browser_policy_connector_chromeos();
   policy::DeviceCloudPolicyManagerChromeOS* policy_manager =
       connector->GetDeviceCloudPolicyManager();
 
   policy::CloudPolicyStore* store = policy_manager->core()->store();
 
   const enterprise_management::PolicyData* policy = store->policy();
 
   std::string asset_id = policy ? policy->annotated_asset_id() : std::string();
   std::string location = policy ? policy->annotated_location() : std::string();
-  actor_->ShowAttributePromptScreen(asset_id, location);
+  view_->ShowAttributePromptScreen(asset_id, location);
 }
 
 void EnrollmentScreen::SendEnrollmentAuthToken(const std::string& token) {
   DCHECK(shark_controller_);
   shark_controller_->OnAuthenticationDone(enrolling_user_domain_, token);
 }
 
 void EnrollmentScreen::ShowEnrollmentStatusOnSuccess() {
   retry_backoff_->InformOfRequest(true);
   if (elapsed_timer_)
     UMA_ENROLLMENT_TIME(kMetricEnrollmentTimeSuccess, elapsed_timer_);
   if (UsingHandsOffEnrollment()) {
     OnConfirmationClosed();
   } else {
-    actor_->ShowEnrollmentStatus(
+    view_->ShowEnrollmentStatus(
         policy::EnrollmentStatus::ForStatus(policy::EnrollmentStatus::SUCCESS));
   }
 }
 
 void EnrollmentScreen::UMA(policy::MetricEnrollment sample) {
   EnrollmentUMA(sample, config_.mode);
 }
 
 void EnrollmentScreen::ShowSigninScreen() {
-  actor_->Show();
-  actor_->ShowSigninScreen();
+  view_->Show();
+  view_->ShowSigninScreen();
 }
 
 void EnrollmentScreen::RecordEnrollmentErrorMetrics() {
   enrollment_failed_once_ = true;
   //  TODO(drcrash): Maybe create multiple metrics (http://crbug.com/640313)?
   if (elapsed_timer_)
     UMA_ENROLLMENT_TIME(kMetricEnrollmentTimeFailure, elapsed_timer_);
 }
 
 void EnrollmentScreen::JoinDomain(OnDomainJoinedCallback on_joined_callback) {
   on_joined_callback_ = std::move(on_joined_callback);
-  actor_->ShowAdJoin();
+  view_->ShowAdJoin();
 }
 
 }  // namespace chromeos