Add ManagementMode enum and GetManagementMode().

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"
 #include "base/sequenced_task_runner.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/login/startup_utils.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_store_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_status_collector.h"
 #include "chrome/browser/chromeos/policy/enrollment_handler_chromeos.h"
 #include "chrome/browser/chromeos/policy/enterprise_install_attributes.h"
 #include "chrome/browser/chromeos/policy/server_backed_device_state.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #include "chrome/common/chrome_content_client.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/system/statistics_provider.h"
-#include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/policy/core/common/cloud/cloud_policy_core.h"
 #include "components/policy/core/common/cloud/device_management_service.h"
 #include "components/policy/core/common/cloud/system_policy_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
-namespace em = enterprise_management;
-
 namespace policy {
 
 namespace {
 
 // Gets a machine flag from StatisticsProvider, returning the given
 // |default_value| if not present.
 bool GetMachineFlag(const std::string& key, bool default_value) {
   bool value = default_value;
   chromeos::system::StatisticsProvider* provider =
       chromeos::system::StatisticsProvider::GetInstance();
@@ skipping 48 matching lines @@
 void DeviceCloudPolicyInitializer::Shutdown() {
   DCHECK(is_initialized_);
 
   device_store_->RemoveObserver(this);
   enrollment_handler_.reset();
   state_keys_update_subscription_.reset();
   is_initialized_ = false;
 }
 
 void DeviceCloudPolicyInitializer::StartEnrollment(
-    em::PolicyData::ManagementMode management_mode,
+    ManagementMode management_mode,
     DeviceManagementService* device_management_service,
     const std::string& auth_token,
     bool is_auto_enrollment,
     const AllowedDeviceModes& allowed_device_modes,
     const EnrollmentCallback& enrollment_callback) {
   DCHECK(is_initialized_);
   DCHECK(!enrollment_handler_);
 
   manager_->core()->Disconnect();
   enrollment_handler_.reset(new EnrollmentHandlerChromeOS(
@@ skipping 99 matching lines @@
   return make_scoped_ptr(
       new CloudPolicyClient(DeviceCloudPolicyManagerChromeOS::GetMachineID(),
                             DeviceCloudPolicyManagerChromeOS::GetMachineModel(),
                             kPolicyVerificationKeyHash,
                             USER_AFFILIATION_NONE,
                             device_management_service,
                             request_context));
 }
 
 void DeviceCloudPolicyInitializer::TryToCreateClient() {
-  if (device_store_->is_initialized() &&
-      device_store_->has_policy() &&
-      !device_store_->policy()->request_token().empty() &&
-      !state_keys_broker_->pending() &&
-      !enrollment_handler_) {
-    DeviceManagementService* service = NULL;
-    if (device_store_->policy()->management_mode() ==
-        em::PolicyData::CONSUMER_MANAGED) {
-      service = consumer_service_;
-    } else {
-      service = enterprise_service_;
-    }
-    if (service)
-      StartConnection(CreateClient(service));
+  if (!device_store_->is_initialized() ||
+      !device_store_->has_policy() ||
+      state_keys_broker_->pending() ||
+      enrollment_handler_) {
+    return;
   }
+
+  DeviceManagementService* service = nullptr;
+  if (GetManagementMode(*device_store_->policy()) ==
+      MANAGEMENT_MODE_CONSUMER_MANAGED) {
+    service = consumer_service_;
+  } else if (GetManagementMode(*device_store_->policy()) ==
+             MANAGEMENT_MODE_ENTERPRISE_MANAGED) {
+    service = enterprise_service_;
+  }
+
+  if (service)
+    StartConnection(CreateClient(service));
 }
 
 void DeviceCloudPolicyInitializer::StartConnection(
     scoped_ptr<CloudPolicyClient> client) {
   if (!manager_->core()->service())
     manager_->StartConnection(client.Pass(), install_attributes_);
 
   if (!on_connected_callback_.is_null()) {
     on_connected_callback_.Run();
     on_connected_callback_.Reset();
   }
 }
 
 }  // namespace policy