Add RESTORE_MODE_DISABLED to RestoreMode

chrome/browser/chromeos/policy/auto_enrollment_client.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/auto_enrollment_client.h"
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 56 matching lines @@
 // corresponding prefs string constant.
 std::string ConvertRestoreMode(
     em::DeviceStateRetrievalResponse::RestoreMode restore_mode) {
   switch (restore_mode) {
     case em::DeviceStateRetrievalResponse::RESTORE_MODE_NONE:
       return std::string();
     case em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_REQUESTED:
       return kDeviceStateRestoreModeReEnrollmentRequested;
     case em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED:
       return kDeviceStateRestoreModeReEnrollmentEnforced;
+    case em::DeviceStateRetrievalResponse::RESTORE_MODE_DISABLED:
+      return kDeviceStateRestoreModeDisabled;
   }
 
   // Return is required to avoid compiler warning.
   NOTREACHED() << "Bad restore mode " << restore_mode;
   return std::string();
 }
 
 }  // namespace
 
 AutoEnrollmentClient::AutoEnrollmentClient(
@@ skipping 139 matching lines @@
   } else {
     progress_callback_.Run(state_);
   }
 }
 
 void AutoEnrollmentClient::NextStep() {
   if (!RetryStep()) {
     // Protocol finished successfully, report result.
     bool trigger_enrollment = false;
     if (retrieve_device_state_) {
-      const base::DictionaryValue* device_state_dict =
-          local_state_->GetDictionary(prefs::kServerBackedDeviceState);
-      std::string restore_mode;
-      device_state_dict->GetString(kDeviceStateRestoreMode, &restore_mode);
+      const RestoreMode restore_mode = GetRestoreMode();
       trigger_enrollment =
-          (restore_mode == kDeviceStateRestoreModeReEnrollmentRequested ||
-           restore_mode == kDeviceStateRestoreModeReEnrollmentEnforced);
+          (restore_mode == RESTORE_MODE_REENROLLMENT_REQUESTED ||
+           restore_mode == RESTORE_MODE_REENROLLMENT_ENFORCED);
     } else {
       trigger_enrollment = has_server_state_;
     }
 
     ReportProgress(trigger_enrollment ? AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT
                                       : AUTO_ENROLLMENT_STATE_NO_ENROLLMENT);
   }
 }
 
 bool AutoEnrollmentClient::SendBucketDownloadRequest() {
@@ skipping 152 matching lines @@
                  new base::StringValue(state_response.management_domain()));
 
       std::string restore_mode =
           ConvertRestoreMode(state_response.restore_mode());
       UpdateDict(dict.Get(),
                  kDeviceStateRestoreMode,
                  !restore_mode.empty(),
                  new base::StringValue(restore_mode));
 
       UpdateDict(dict.Get(),
-                 kDeviceStateDisabled,
-                 true /* set_or_clear */,
-                 new base::FundamentalValue(
-                     state_response.has_disabled_state()));
-      UpdateDict(dict.Get(),
                  kDeviceStateDisabledMessage,
                  state_response.has_disabled_state(),
                  new base::StringValue(
                      state_response.disabled_state().message()));
     }
     local_state_->CommitPendingWrite();
     device_state_available_ = true;
     progress = true;
   }
 
@@ skipping 25 matching lines @@
   base::TimeDelta delta = kZero;
   if (!time_extra_start_.is_null())
     delta = now - time_extra_start_;
   // This samples |kZero| when there was no need for extra time, so that we can
   // measure the ratio of users that succeeded without needing a delay to the
   // total users going through OOBE.
   UMA_HISTOGRAM_CUSTOM_TIMES(kUMAExtraTime, delta, kMin, kMax, kBuckets);
 }
 
 }  // namespace policy