Add RESTORE_MODE_DISABLED to RestoreMode

chrome/browser/chromeos/policy/device_cloud_policy_initializer.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/policy/device_cloud_policy_initializer.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
@@ skipping 117 matching lines @@
       manager_->GetDeviceRequisition(),
       allowed_device_modes,
       management_mode,
       base::Bind(&DeviceCloudPolicyInitializer::EnrollmentCompleted,
                  base::Unretained(this),
                  enrollment_callback)));
   enrollment_handler_->StartEnrollment();
 }
 
 bool DeviceCloudPolicyInitializer::ShouldAutoStartEnrollment() const {
-  std::string restore_mode = GetRestoreMode();
-  if (restore_mode == kDeviceStateRestoreModeReEnrollmentRequested ||
-      restore_mode == kDeviceStateRestoreModeReEnrollmentEnforced) {
+  const RestoreMode restore_mode = GetRestoreMode();
+  if (restore_mode == RESTORE_MODE_REENROLLMENT_REQUESTED ||
+      restore_mode == RESTORE_MODE_REENROLLMENT_ENFORCED) {
     return true;
   }
 
   if (local_state_->HasPrefPath(prefs::kDeviceEnrollmentAutoStart))
     return local_state_->GetBoolean(prefs::kDeviceEnrollmentAutoStart);
 
   return GetMachineFlag(chromeos::system::kOemIsEnterpriseManagedKey, false);
 }
 
 bool DeviceCloudPolicyInitializer::ShouldRecoverEnrollment() const {
   if (install_attributes_->IsEnterpriseDevice() &&
       chromeos::StartupUtils::IsEnrollmentRecoveryRequired()) {
     LOG(WARNING) << "Enrollment recovery required according to pref.";
     if (!DeviceCloudPolicyManagerChromeOS::GetMachineID().empty())
       return true;
     LOG(WARNING) << "Postponing recovery because machine id is missing.";
   }
   return false;
 }
 
 std::string DeviceCloudPolicyInitializer::GetEnrollmentRecoveryDomain() const {
   return install_attributes_->GetDomain();
 }
 
 bool DeviceCloudPolicyInitializer::CanExitEnrollment() const {
-  if (GetRestoreMode() == kDeviceStateRestoreModeReEnrollmentEnforced)
+  if (GetRestoreMode() == RESTORE_MODE_REENROLLMENT_ENFORCED)
     return false;
 
   if (local_state_->HasPrefPath(prefs::kDeviceEnrollmentCanExit))
     return local_state_->GetBoolean(prefs::kDeviceEnrollmentCanExit);
 
   return GetMachineFlag(chromeos::system::kOemCanExitEnterpriseEnrollmentKey,
                         true);
 }
 
 std::string
@@ skipping 70 matching lines @@
     scoped_ptr<CloudPolicyClient> client) {
   if (!manager_->core()->service())
     manager_->StartConnection(client.Pass(), device_status_provider_.Pass());
 
   if (!on_connected_callback_.is_null()) {
     on_connected_callback_.Run();
     on_connected_callback_.Reset();
   }
 }
 
-std::string DeviceCloudPolicyInitializer::GetRestoreMode() const {
-  const base::DictionaryValue* device_state_dict =
-      local_state_->GetDictionary(prefs::kServerBackedDeviceState);
-  std::string restore_mode;
-  device_state_dict->GetString(kDeviceStateRestoreMode, &restore_mode);
-  return restore_mode;
-}
-
 }  // namespace policy