SetManagementSettings() is moved to OwnerSettingsServiceChromeOS.

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/ownership/owner_settings_service_chromeos.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/profiles/profile_helper.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 "chrome/browser/profiles/profile.h"
 #include "chromeos/chromeos_switches.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.
 const int kLockRetryIntervalMs = 500;
 // Maximum time to retry InstallAttrs initialization before we give up.
 const int kLockRetryTimeoutMs = 10 * 60 * 1000;  // 10 minutes.
 
 // Testing token used when the enrollment-skip-robot-auth is set to skip talking
 // to GAIA for an actual token. This is needed to be able to run against the
 // testing DMServer implementations.
 const char kTestingRobotToken[] = "test-token";
 
 }  // namespace
 
 EnrollmentHandlerChromeOS::EnrollmentHandlerChromeOS(
     DeviceCloudPolicyStoreChromeOS* store,
     EnterpriseInstallAttributes* install_attributes,
     ServerBackedStateKeysBroker* state_keys_broker,
     chromeos::DeviceSettingsService* device_settings_service,
+    chromeos::OwnerSettingsServiceChromeOS* owner_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,
     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),
+      owner_settings_service_(owner_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),
@@ skipping 130 matching lines @@
     // again after the store finishes loading.
     StartRegistration();
   } else if (enrollment_step_ == STEP_STORE_POLICY) {
     ReportResult(EnrollmentStatus::ForStatus(EnrollmentStatus::STATUS_SUCCESS));
   }
 }
 
 void EnrollmentHandlerChromeOS::OnStoreError(CloudPolicyStore* store) {
   DCHECK_EQ(store_, store);
   if (enrollment_step_ == STEP_STORE_TOKEN_AND_ID) {
-    // Calling DeviceSettingsService::SetManagementSettings() on a non-
-    // enterprise-managed device will trigger OnStoreError(), as
-    // DeviceCloudPolicyStore listens to all changes on DeviceSettingsService,
-    // and it calls OnStoreError() when the device is not enterprise-managed.
+    // Calling OwnerSettingsServiceChromeOS::SetManagementSettings()
+    // on a non- enterprise-managed device will fail as
+    // DeviceCloudPolicyStore listens to all changes on device
+    // settings, and it calls OnStoreError() when the device is not
+    // enterprise-managed.
     return;
   }
   ReportResult(EnrollmentStatus::ForStoreError(store_->status(),
                                                store_->validation_status()));
 }
 
 void EnrollmentHandlerChromeOS::HandleStateKeysResult(
     const std::vector<std::string>& state_keys) {
   CHECK_EQ(STEP_STATE_KEYS, enrollment_step_);
 
@@ skipping 115 matching lines @@
 }
 
 void EnrollmentHandlerChromeOS::StartLockDevice() {
   CHECK_EQ(STEP_LOCK_DEVICE, enrollment_step_);
   // Since this method is also called directly.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   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;

[davidyu, 2014/12/03 16:06:04]

CHECK(owner_settings_service_);

[ygorshenin1, 2014/12/04 10:27:23]

Done.

-    device_settings_service_->SetManagementSettings(
-        em::PolicyData::CONSUMER_MANAGED, request_token_, device_id_,
+    chromeos::OwnerSettingsServiceChromeOS::ManagementSettings settings;
+    settings.management_mode = management_mode_;
+    settings.request_token = request_token_;
+    settings.device_id = device_id_;
+    owner_settings_service_->SetManagementSettings(
+        settings,
         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()));
   }
 }
 
-void EnrollmentHandlerChromeOS::HandleSetManagementSettingsDone() {
+void EnrollmentHandlerChromeOS::HandleSetManagementSettingsDone(bool success) {
   CHECK_EQ(STEP_STORE_TOKEN_AND_ID, enrollment_step_);
-  if (device_settings_service_->status() !=
-      chromeos::DeviceSettingsService::STORE_SUCCESS) {
+  if (!success) {
     ReportResult(EnrollmentStatus::ForStatus(
         EnrollmentStatus::STATUS_STORE_TOKEN_AND_ID_FAILED));
     return;
   }
 
   StartStoreRobotAuth();
 }
 
 void EnrollmentHandlerChromeOS::HandleLockDeviceResult(
     EnterpriseInstallAttributes::LockResult lock_result) {
@@ skipping 78 matching lines @@
                  << ", validation: " << status.validation_status()
                  << ", store: " << status.store_status()
                  << ", lock: " << status.lock_status();
   }
 
   if (!callback.is_null())
     callback.Run(status);
 }
 
 }  // namespace policy