Add ManagementMode enum and GetManagementMode().

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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/login/enrollment/auto_enrollment_controller.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_store_chromeos.h"
 #include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
 #include "chrome/browser/chromeos/policy/server_backed_state_keys_broker.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service_factory.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #include "chromeos/chromeos_switches.h"
-#include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/http/http_status_code.h"
 
 namespace em = enterprise_management;
 
 namespace policy {
 
 namespace {
 
 // Retry for InstallAttrs initialization every 500ms.
@@ skipping 13 matching lines @@
     EnterpriseInstallAttributes* install_attributes,
     ServerBackedStateKeysBroker* state_keys_broker,
     chromeos::DeviceSettingsService* device_settings_service,
     scoped_ptr<CloudPolicyClient> client,
     scoped_refptr<base::SequencedTaskRunner> background_task_runner,
     const std::string& auth_token,
     const std::string& client_id,
     bool is_auto_enrollment,
     const std::string& requisition,
     const AllowedDeviceModes& allowed_device_modes,
-    em::PolicyData::ManagementMode management_mode,
+    ManagementMode management_mode,
     const EnrollmentCallback& completion_callback)
     : store_(store),
       install_attributes_(install_attributes),
       state_keys_broker_(state_keys_broker),
       device_settings_service_(device_settings_service),
       client_(client.Pass()),
       background_task_runner_(background_task_runner),
       auth_token_(auth_token),
       client_id_(client_id),
       is_auto_enrollment_(is_auto_enrollment),
       requisition_(requisition),
       allowed_device_modes_(allowed_device_modes),
       management_mode_(management_mode),
       completion_callback_(completion_callback),
       device_mode_(DEVICE_MODE_NOT_SET),
       enrollment_step_(STEP_PENDING),
       lockbox_init_duration_(0),
       weak_ptr_factory_(this) {
   CHECK(!client_->is_registered());
   CHECK_EQ(DM_STATUS_SUCCESS, client_->status());
-  CHECK(management_mode_ == em::PolicyData::ENTERPRISE_MANAGED ||
-        management_mode_ == em::PolicyData::CONSUMER_MANAGED);
+  CHECK(management_mode_ == MANAGEMENT_MODE_ENTERPRISE_MANAGED ||
+        management_mode_ == MANAGEMENT_MODE_CONSUMER_MANAGED);
   store_->AddObserver(this);
   client_->AddObserver(this);
   client_->AddPolicyTypeToFetch(dm_protocol::kChromeDevicePolicyType,
                                 std::string());
 }
 
 EnrollmentHandlerChromeOS::~EnrollmentHandlerChromeOS() {
   Stop();
   store_->RemoveObserver(this);
 }
@@ skipping 39 matching lines @@
   // previously-enrolled domain.
   std::string domain;
   if (install_attributes_->IsEnterpriseDevice()) {
     domain = install_attributes_->GetDomain();
     validator->ValidateDomain(domain);
   }
   validator->ValidateDMToken(client->dm_token(),
                              CloudPolicyValidatorBase::DM_TOKEN_REQUIRED);
   validator->ValidatePolicyType(dm_protocol::kChromeDevicePolicyType);
   validator->ValidatePayload();
-  if (management_mode_ == em::PolicyData::CONSUMER_MANAGED) {
+  if (management_mode_ == MANAGEMENT_MODE_CONSUMER_MANAGED) {
     // For consumer-managed devices, although we don't store the policy, we
     // still need to verify its integrity since we use the request token in it.
     // The consumer device management server does not have the verification
     // key, and we need to skip checking on that by passing an empty key to
     // ValidateInitialKey(). ValidateInitialKey() still checks that the policy
     // data is correctly signed by the new public key when the verification key
     // is empty.
     validator->ValidateInitialKey(std::string(), std::string());
   } else {
     // If |domain| is empty here, the policy validation code will just use the
@@ skipping 189 matching lines @@
              << response_code;
   ReportResult(
       EnrollmentStatus::ForRobotRefreshFetchError(response_code));
 }
 
 void EnrollmentHandlerChromeOS::StartLockDevice() {
   CHECK_EQ(STEP_LOCK_DEVICE, enrollment_step_);
   // Since this method is also called directly.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
-  if (management_mode_ == em::PolicyData::CONSUMER_MANAGED) {
+  if (management_mode_ == MANAGEMENT_MODE_CONSUMER_MANAGED) {
     // Consumer device enrollment doesn't use install attributes. Instead,
     // we put the information in the owners settings.
     enrollment_step_ = STEP_STORE_TOKEN_AND_ID;
     device_settings_service_->SetManagementSettings(
-        management_mode_, request_token_, device_id_,
+        em::PolicyData::CONSUMER_MANAGED, request_token_, device_id_,
         base::Bind(&EnrollmentHandlerChromeOS::HandleSetManagementSettingsDone,
                    weak_ptr_factory_.GetWeakPtr()));
   } else {
     install_attributes_->LockDevice(
         username_, device_mode_, device_id_,
         base::Bind(&EnrollmentHandlerChromeOS::HandleLockDeviceResult,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
@@ skipping 57 matching lines @@
 void EnrollmentHandlerChromeOS::HandleStoreRobotAuthTokenResult(bool result) {
   CHECK_EQ(STEP_STORE_ROBOT_AUTH, enrollment_step_);
 
   if (!result) {
     LOG(ERROR) << "Failed to store API refresh token.";
     ReportResult(EnrollmentStatus::ForStatus(
         EnrollmentStatus::STATUS_ROBOT_REFRESH_STORE_FAILED));
     return;
   }
 
-  if (management_mode_ == em::PolicyData::CONSUMER_MANAGED) {
+  if (management_mode_ == MANAGEMENT_MODE_CONSUMER_MANAGED) {
     // For consumer management enrollment, we don't store the policy.
     ReportResult(EnrollmentStatus::ForStatus(EnrollmentStatus::STATUS_SUCCESS));
     return;
   }
 
   enrollment_step_ = STEP_STORE_POLICY;
   store_->InstallInitialPolicy(*policy_);
 }
 
 void EnrollmentHandlerChromeOS::Stop() {
@@ skipping 14 matching lines @@
                  << ", validation: " << status.validation_status()
                  << ", store: " << status.store_status()
                  << ", lock: " << status.lock_status();
   }
 
   if (!callback.is_null())
     callback.Run(status);
 }
 
 }  // namespace policy