Rename policy::EnterpriseInstallAttributes to chromeos::InstallAttributes.

chrome/browser/chromeos/policy/enrollment_handler_chromeos.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/policy/enrollment_handler_chromeos.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 52 matching lines @@
   }
 
   NOTREACHED() << "Bad enrollment mode: " << mode;
   return em::DeviceRegisterRequest::FLAVOR_ENROLLMENT_MANUAL;
 }
 
 }  // namespace
 
 EnrollmentHandlerChromeOS::EnrollmentHandlerChromeOS(
     DeviceCloudPolicyStoreChromeOS* store,
-    EnterpriseInstallAttributes* install_attributes,
+    chromeos::InstallAttributes* install_attributes,
     ServerBackedStateKeysBroker* state_keys_broker,
     chromeos::attestation::AttestationFlow* attestation_flow,
     std::unique_ptr<CloudPolicyClient> client,
     scoped_refptr<base::SequencedTaskRunner> background_task_runner,
     const EnrollmentConfig& enrollment_config,
     const std::string& auth_token,
     const std::string& client_id,
     const std::string& requisition,
     const EnrollmentCallback& completion_callback)
     : store_(store),
@@ skipping 317 matching lines @@
   if (!success) {
     ReportResult(EnrollmentStatus::ForStatus(
         EnrollmentStatus::STATUS_STORE_TOKEN_AND_ID_FAILED));
     return;
   }
 
   StartStoreRobotAuth();
 }
 
 void EnrollmentHandlerChromeOS::HandleLockDeviceResult(
-    EnterpriseInstallAttributes::LockResult lock_result) {
+    chromeos::InstallAttributes::LockResult lock_result) {
   CHECK_EQ(STEP_LOCK_DEVICE, enrollment_step_);
   switch (lock_result) {
-    case EnterpriseInstallAttributes::LOCK_SUCCESS:
+    case chromeos::InstallAttributes::LOCK_SUCCESS:
       StartStoreRobotAuth();
       break;
-    case EnterpriseInstallAttributes::LOCK_NOT_READY:
+    case chromeos::InstallAttributes::LOCK_NOT_READY:
       // We wait up to |kLockRetryTimeoutMs| milliseconds and if it hasn't
       // succeeded by then show an error to the user and stop the enrollment.
       if (lockbox_init_duration_ < kLockRetryTimeoutMs) {
         // InstallAttributes not ready yet, retry later.
         LOG(WARNING) << "Install Attributes not ready yet will retry in "
                      << kLockRetryIntervalMs << "ms.";
         base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
             FROM_HERE, base::Bind(&EnrollmentHandlerChromeOS::StartLockDevice,
                                   weak_ptr_factory_.GetWeakPtr()),
             base::TimeDelta::FromMilliseconds(kLockRetryIntervalMs));
         lockbox_init_duration_ += kLockRetryIntervalMs;
       } else {
-        HandleLockDeviceResult(EnterpriseInstallAttributes::LOCK_TIMEOUT);
+        HandleLockDeviceResult(chromeos::InstallAttributes::LOCK_TIMEOUT);
       }
       break;
-    case EnterpriseInstallAttributes::LOCK_TIMEOUT:
-    case EnterpriseInstallAttributes::LOCK_BACKEND_INVALID:
-    case EnterpriseInstallAttributes::LOCK_ALREADY_LOCKED:
-    case EnterpriseInstallAttributes::LOCK_SET_ERROR:
-    case EnterpriseInstallAttributes::LOCK_FINALIZE_ERROR:
-    case EnterpriseInstallAttributes::LOCK_READBACK_ERROR:
-    case EnterpriseInstallAttributes::LOCK_WRONG_DOMAIN:
-    case EnterpriseInstallAttributes::LOCK_WRONG_MODE:
+    case chromeos::InstallAttributes::LOCK_TIMEOUT:
+    case chromeos::InstallAttributes::LOCK_BACKEND_INVALID:
+    case chromeos::InstallAttributes::LOCK_ALREADY_LOCKED:
+    case chromeos::InstallAttributes::LOCK_SET_ERROR:
+    case chromeos::InstallAttributes::LOCK_FINALIZE_ERROR:
+    case chromeos::InstallAttributes::LOCK_READBACK_ERROR:
+    case chromeos::InstallAttributes::LOCK_WRONG_DOMAIN:
+    case chromeos::InstallAttributes::LOCK_WRONG_MODE:
       ReportResult(EnrollmentStatus::ForLockError(lock_result));
       break;
   }
 }
 
 void EnrollmentHandlerChromeOS::StartStoreRobotAuth() {
   enrollment_step_ = STEP_STORE_ROBOT_AUTH;
 
   // Don't store the token if robot auth was skipped.
   if (skip_robot_auth_) {
@@ skipping 39 matching lines @@
                  << ", validation: " << status.validation_status()
                  << ", store: " << status.store_status()
                  << ", lock: " << status.lock_status();
   }
 
   if (!callback.is_null())
     callback.Run(status);
 }
 
 }  // namespace policy