Add DeviceADPolicyManager to provide AD policy.

chrome/browser/chromeos/policy/device_cloud_policy_store_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/device_cloud_policy_store_chromeos.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 18 matching lines @@
 
 DeviceCloudPolicyStoreChromeOS::DeviceCloudPolicyStoreChromeOS(
     chromeos::DeviceSettingsService* device_settings_service,
     chromeos::InstallAttributes* install_attributes,
     scoped_refptr<base::SequencedTaskRunner> background_task_runner)
     : device_settings_service_(device_settings_service),
       install_attributes_(install_attributes),
       background_task_runner_(background_task_runner),
       weak_factory_(this) {
   device_settings_service_->AddObserver(this);
+  device_settings_service_->SetDeviceMode(install_attributes_->GetMode());
 }
 
 DeviceCloudPolicyStoreChromeOS::~DeviceCloudPolicyStoreChromeOS() {
   device_settings_service_->RemoveObserver(this);
 }
 
 void DeviceCloudPolicyStoreChromeOS::Store(
     const em::PolicyFetchResponse& policy) {
   // Cancel all pending requests.
   weak_factory_.InvalidateWeakPtrs();
 
   scoped_refptr<ownership::PublicKey> public_key(
       device_settings_service_->GetPublicKey());
-  if (!install_attributes_->IsEnterpriseDevice() ||
+  if (!install_attributes_->IsCloudManaged() ||
       !device_settings_service_->policy_data() || !public_key.get() ||
       !public_key->is_loaded()) {
     status_ = STATUS_BAD_STATE;
     NotifyStoreError();
     return;
   }
 
   std::unique_ptr<DeviceCloudPolicyValidator> validator(
       CreateValidator(policy));
   validator->ValidateSignatureAllowingRotation(
@@ skipping 11 matching lines @@
 
 void DeviceCloudPolicyStoreChromeOS::Load() {
   device_settings_service_->Load();
 }
 
 void DeviceCloudPolicyStoreChromeOS::InstallInitialPolicy(
     const em::PolicyFetchResponse& policy) {
   // Cancel all pending requests.
   weak_factory_.InvalidateWeakPtrs();
 
-  if (!install_attributes_->IsEnterpriseDevice()) {
+  if (!install_attributes_->IsCloudManaged()) {
     status_ = STATUS_BAD_STATE;
     NotifyStoreError();
     return;
   }
 
   std::unique_ptr<DeviceCloudPolicyValidator> validator(
       CreateValidator(policy));
   validator->ValidateInitialKey(GetPolicyVerificationKey(),
                                 install_attributes_->GetDomain());
   validator.release()->StartValidation(
@@ skipping 37 matching lines @@
       std::move(validator->policy()),
       base::Bind(&DeviceCloudPolicyStoreChromeOS::OnPolicyStored,
                  weak_factory_.GetWeakPtr()));
 }
 
 void DeviceCloudPolicyStoreChromeOS::OnPolicyStored() {
   UpdateFromService();
 }
 
 void DeviceCloudPolicyStoreChromeOS::UpdateFromService() {
-  if (!install_attributes_->IsEnterpriseDevice()) {
+  if (!install_attributes_->IsEnterpriseManaged()) {
     status_ = STATUS_BAD_STATE;
     NotifyStoreError();
     return;
   }
 
   CheckDMToken();
   UpdateStatusFromService();
 
   const chromeos::DeviceSettingsService::Status service_status =
       device_settings_service_->status();
@@ skipping 54 matching lines @@
     case chromeos::DeviceSettingsService::STORE_TEMP_VALIDATION_ERROR:
       // Don't check for write errors or transient read errors.
       return;
   }
 
   if (dm_token_checked_) {
     return;
   }
   dm_token_checked_ = true;
 
+  // PolicyData from Active Directory doesn't contain a DM token.
+  if (install_attributes_->IsActiveDirectoryManaged()) {
+    return;
+  }
+
   // At the time LoginDisplayHostImpl decides whether enrollment flow is to be
   // started, policy hasn't been read yet.  To work around this, once the need
   // for recovery is detected upon policy load, a flag is stored in prefs which
   // is accessed by LoginDisplayHostImpl early during (next) boot.
   const em::PolicyData* policy_data = device_settings_service_->policy_data();
   if (service_status == chromeos::DeviceSettingsService::STORE_SUCCESS &&
       policy_data && policy_data->has_request_token()) {
     UMA_HISTOGRAM_BOOLEAN(kDMTokenCheckHistogram, true);
   } else {
     LOG(ERROR) << "Device policy read on enrolled device yields "
                << "no DM token! Status: " << service_status << ".";
     chromeos::StartupUtils::MarkEnrollmentRecoveryRequired();
     UMA_HISTOGRAM_BOOLEAN(kDMTokenCheckHistogram, false);
   }
 }
 
 }  // namespace policy