Implement Chrome OS device enrollment on the new cloud policy stack.

chrome/browser/policy/device_cloud_policy_manager_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/policy/device_cloud_policy_manager_chromeos.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "chrome/browser/chromeos/system/statistics_provider.h"
 #include "chrome/browser/policy/cloud_policy_client.h"
 #include "chrome/browser/policy/device_cloud_policy_store_chromeos.h"
 #include "chrome/browser/policy/device_management_service.h"
+#include "chrome/browser/policy/enrollment_handler_chromeos.h"
 #include "chrome/browser/policy/enterprise_install_attributes.h"
 #include "chrome/common/pref_names.h"
 
 namespace policy {
 
 namespace {
 
 // MachineInfo key names.
 const char kMachineInfoSystemHwqual[] = "hardware_class";
 
@@ skipping 40 matching lines @@
   CHECK(device_management_service);
   CHECK(local_state);
 
   local_state_ = local_state;
   device_management_service_ = device_management_service;
 
   StartIfInitialized();
 }
 
 void DeviceCloudPolicyManagerChromeOS::Shutdown() {
+  enrollment_handler_.reset();
   ShutdownService();
 }
 
+void DeviceCloudPolicyManagerChromeOS::StartEnrollment(
+    const std::string& auth_token,
+    const EnrollmentCallback& callback) {
+  CHECK(device_management_service_);
+  ShutdownService();
+
+  enrollment_handler_.reset(
+      new EnrollmentHandlerChromeOS(
+          device_store_, install_attributes_, CreateClient(), auth_token,
+          base::Bind(&DeviceCloudPolicyManagerChromeOS::EnrollmentCompleted,
+                     base::Unretained(this), callback)));
+  enrollment_handler_->StartEnrollment();
+}
+
+void DeviceCloudPolicyManagerChromeOS::CancelEnrollment() {
+  if (enrollment_handler_.get()) {
+    enrollment_handler_.reset();
+    StartIfInitialized();

[Joao da Silva, 2012/09/07 14:01:42]

Why? Is this for the re-enrollment case?

[Mattias Nissler (ping if slow), 2012/10/23 15:30:41]

Yes. Also, for robustness. While enrollment is on, we don't have a
CloudPolicyService. At all other times, we should have CloudPolicyService
running if there is valid policy present.

+  }
+}
+
 // static
 std::string DeviceCloudPolicyManagerChromeOS::GetMachineID() {
   std::string machine_id;
   chromeos::system::StatisticsProvider* provider =
       chromeos::system::StatisticsProvider::GetInstance();
   for (size_t i = 0; i < arraysize(kMachineInfoSerialNumberKeys); i++) {
     if (provider->GetMachineStatistic(kMachineInfoSerialNumberKeys[i],
                                       &machine_id) &&
         !machine_id.empty()) {
       break;
@@ skipping 13 matching lines @@
       chromeos::system::StatisticsProvider::GetInstance();
   if (!provider->GetMachineStatistic(kMachineInfoSystemHwqual, &machine_model))
     LOG(WARNING) << "Failed to get machine model.";
 
   return machine_model;
 }
 
 void DeviceCloudPolicyManagerChromeOS::OnStoreLoaded(CloudPolicyStore* store) {
   CloudPolicyManager::OnStoreLoaded(store);
 
-  if (device_management_service_ && local_state_)
+  if (!enrollment_handler_.get() && device_management_service_ && local_state_)
     StartIfInitialized();
 }
 
 scoped_ptr<CloudPolicyClient> DeviceCloudPolicyManagerChromeOS::CreateClient() {
   return make_scoped_ptr(
       new CloudPolicyClient(GetMachineID(), GetMachineModel(),
                             USER_AFFILIATION_NONE, POLICY_SCOPE_MACHINE, NULL,
                             device_management_service_));
 }
 
+void DeviceCloudPolicyManagerChromeOS::EnrollmentCompleted(
+    const EnrollmentCallback& callback,
+    EnrollmentStatus status,
+    DeviceManagementStatus dm_status,
+    CloudPolicyValidatorBase::Status validator_status,
+    CloudPolicyStore::Status store_status) {
+  if (status == ENROLLMENT_STATUS_SUCCESS) {
+    InitializeService(enrollment_handler_->ReleaseClient());
+    StartRefreshScheduler(local_state_, prefs::kDevicePolicyRefreshRate);
+  } else {
+    StartIfInitialized();
+  }
+
+  enrollment_handler_.reset();
+  if (!callback.is_null())
+    callback.Run(status, dm_status, validator_status, store_status);
+}
+
 void DeviceCloudPolicyManagerChromeOS::StartIfInitialized() {
   if (cloud_policy_store()->is_initialized() &&
       cloud_policy_store()->has_policy()) {
     InitializeService(CreateClient());
     StartRefreshScheduler(local_state_, prefs::kDevicePolicyRefreshRate);
   }
 }
 
 }  // namespace policy