Implemented consumer management unenrollment.

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"
@@ skipping 39 matching lines @@
 
 DeviceCloudPolicyInitializer::DeviceCloudPolicyInitializer(
     PrefService* local_state,
     DeviceManagementService* enterprise_service,
     DeviceManagementService* consumer_service,
     const scoped_refptr<base::SequencedTaskRunner>& background_task_runner,
     EnterpriseInstallAttributes* install_attributes,
     ServerBackedStateKeysBroker* state_keys_broker,
     DeviceCloudPolicyStoreChromeOS* device_store,
     DeviceCloudPolicyManagerChromeOS* manager,
-    chromeos::DeviceSettingsService* device_settings_service)
+    chromeos::DeviceSettingsService* device_settings_service,
+    ConsumerManagementService* consumer_management_service)
     : local_state_(local_state),
       enterprise_service_(enterprise_service),
       consumer_service_(consumer_service),
       background_task_runner_(background_task_runner),
       install_attributes_(install_attributes),
       state_keys_broker_(state_keys_broker),
       device_store_(device_store),
       manager_(manager),
       device_settings_service_(device_settings_service),
+      consumer_management_service_(consumer_management_service),
       is_initialized_(false) {
 }
 
 DeviceCloudPolicyInitializer::~DeviceCloudPolicyInitializer() {
   DCHECK(!is_initialized_);
 }
 
 void DeviceCloudPolicyInitializer::Init() {
   DCHECK(!is_initialized_);
 
   is_initialized_ = true;
   device_store_->AddObserver(this);
+  if (consumer_management_service_)
+    consumer_management_service_->AddObserver(this);
   state_keys_update_subscription_ = state_keys_broker_->RegisterUpdateCallback(
       base::Bind(&DeviceCloudPolicyInitializer::TryToCreateClient,
                  base::Unretained(this)));
 
   device_status_provider_.reset(
       new DeviceStatusCollector(
           local_state_,
           chromeos::system::StatisticsProvider::GetInstance(),
           NULL));
 
   TryToCreateClient();
 }
 
 void DeviceCloudPolicyInitializer::Shutdown() {
   DCHECK(is_initialized_);
 
+  if (consumer_management_service_)
+    consumer_management_service_->RemoveObserver(this);
   device_store_->RemoveObserver(this);
   device_status_provider_.reset();
   enrollment_handler_.reset();
   state_keys_update_subscription_.reset();
   is_initialized_ = false;
 }
 
 void DeviceCloudPolicyInitializer::StartEnrollment(
     em::PolicyData::ManagementMode management_mode,
     DeviceManagementService* device_management_service,
@@ skipping 74 matching lines @@
 }
 
 void DeviceCloudPolicyInitializer::OnStoreLoaded(CloudPolicyStore* store) {
   TryToCreateClient();
 }
 
 void DeviceCloudPolicyInitializer::OnStoreError(CloudPolicyStore* store) {
   // Do nothing.
 }
 
+void DeviceCloudPolicyInitializer::OnConsumerManagementStatusChanged() {
+  TryToCreateClient();
+}
+
 void DeviceCloudPolicyInitializer::EnrollmentCompleted(
     const EnrollmentCallback& enrollment_callback,
     EnrollmentStatus status) {
   scoped_ptr<CloudPolicyClient> client = enrollment_handler_->ReleaseClient();
   enrollment_handler_.reset();
 
   if (status.status() == EnrollmentStatus::STATUS_SUCCESS) {
     StartConnection(client.Pass());
   } else {
     // Some attempts to create a client may be blocked because the enrollment
@@ skipping 15 matching lines @@
       new CloudPolicyClient(DeviceCloudPolicyManagerChromeOS::GetMachineID(),
                             DeviceCloudPolicyManagerChromeOS::GetMachineModel(),
                             kPolicyVerificationKeyHash,
                             USER_AFFILIATION_NONE,
                             device_status_provider_.get(),
                             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 (enrollment_handler_ || state_keys_broker_->pending())
+    return;
+
+  DeviceManagementService* service = NULL;

[bartfab (slow), 2014/11/28 13:25:18]

Nit: s/NULL/nullptr/

[davidyu, 2014/12/01 17:05:22]

Done.

+  if (consumer_management_service_ &&
+      consumer_management_service_->IsManaged()) {
+    service = consumer_service_;
+  } else if (device_store_->is_initialized() &&
+             device_store_->has_policy() &&
+             !device_store_->policy()->request_token().empty()) {
+    DCHECK_NE(em::PolicyData::CONSUMER_MANAGED,
+              device_store_->policy()->management_mode());
+    service = enterprise_service_;
   }
+
+  if (service)
+    StartConnection(CreateClient(service));
 }
 
 void DeviceCloudPolicyInitializer::StartConnection(
     scoped_ptr<CloudPolicyClient> client) {
   if (!manager_->core()->service())
     manager_->StartConnection(client.Pass(), device_status_provider_.Pass());
 }
 
 }  // namespace policy