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 39 matching lines @@
   CHECK(!device_management_service_);
   CHECK(device_management_service);
   CHECK(local_state);
 
   local_state_ = local_state;
   device_management_service_ = device_management_service;
 
   StartIfManaged();
 }
 
+void DeviceCloudPolicyManagerChromeOS::StartEnrollment(
+    const std::string& auth_token,
+    const AllowedDeviceModes& allowed_device_modes,
+    const EnrollmentCallback& callback) {
+  CHECK(device_management_service_);
+  ShutdownService();
+
+  enrollment_handler_.reset(
+      new EnrollmentHandlerChromeOS(
+          device_store_, install_attributes_, CreateClient(), auth_token,
+          allowed_device_modes,
+          base::Bind(&DeviceCloudPolicyManagerChromeOS::EnrollmentCompleted,
+                     base::Unretained(this), callback)));
+  enrollment_handler_->StartEnrollment();
+}
+
+void DeviceCloudPolicyManagerChromeOS::CancelEnrollment() {
+  if (enrollment_handler_.get()) {
+    enrollment_handler_.reset();
+    StartIfManaged();
+  }
+}
+
 void DeviceCloudPolicyManagerChromeOS::OnStoreLoaded(CloudPolicyStore* store) {
   CloudPolicyManager::OnStoreLoaded(store);
 
-  StartIfManaged();
+  if (!enrollment_handler_.get())
+    StartIfManaged();
 }
 
 // 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) &&
@@ skipping 19 matching lines @@
   return machine_model;
 }
 
 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) {
+  if (status.status() == EnrollmentStatus::STATUS_SUCCESS) {

[pastarmovj, 2012/10/23 15:58:08]

Isn't it possible to call StartIfManaged() unconditionally here? 

[Mattias Nissler (ping if slow), 2012/10/23 16:33:03]

No, in this case we want to reuse the client. I guess I could pass the client in
a scoped_ptr parameter if you prefer that, but that would add noise to the other
call sites.

+    InitializeService(enrollment_handler_->ReleaseClient());
+    StartRefreshScheduler(local_state_, prefs::kDevicePolicyRefreshRate);
+  } else {
+    StartIfManaged();
+  }
+
+  enrollment_handler_.reset();
+  if (!callback.is_null())
+    callback.Run(status);
+}
+
 void DeviceCloudPolicyManagerChromeOS::StartIfManaged() {
   if (device_management_service_ &&
       local_state_ &&
       cloud_policy_store()->is_initialized() &&
       cloud_policy_store()->is_managed() &&
       !cloud_policy_service()) {
     InitializeService(CreateClient());
     StartRefreshScheduler(local_state_, prefs::kDevicePolicyRefreshRate);
   }
 }
 
 }  // namespace policy