Don't start device cloud policy connection after Chromad enrollment

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 <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 226 matching lines @@
   // Do nothing.
 }
 
 void DeviceCloudPolicyInitializer::EnrollmentCompleted(
     const EnrollmentCallback& enrollment_callback,
     EnrollmentStatus status) {
   std::unique_ptr<CloudPolicyClient> client =
       enrollment_handler_->ReleaseClient();
   enrollment_handler_.reset();
 
-  if (status.status() == EnrollmentStatus::SUCCESS) {
+  if (status.status() == EnrollmentStatus::SUCCESS &&
+      !install_attributes_->IsActiveDirectoryManaged()) {
     StartConnection(std::move(client));
   } else {
     // Some attempts to create a client may be blocked because the enrollment
     // was in progress. We give it a try again.
     TryToCreateClient();
   }
 
   if (!enrollment_callback.is_null())
     enrollment_callback.Run(status);
 }
 
 std::unique_ptr<CloudPolicyClient> DeviceCloudPolicyInitializer::CreateClient(
     DeviceManagementService* device_management_service) {
   std::string machine_model;
   statistics_provider_->GetMachineStatistic(chromeos::system::kHardwareClassKey,
                                             &machine_model);
   return base::MakeUnique<CloudPolicyClient>(
       statistics_provider_->GetEnterpriseMachineID(), machine_model,
       device_management_service, g_browser_process->system_request_context(),
       signing_service_.get());
 }
 
 void DeviceCloudPolicyInitializer::TryToCreateClient() {
   if (!device_store_->is_initialized() ||
       !device_store_->has_policy() ||
       state_keys_broker_->pending() ||
-      enrollment_handler_) {
+      enrollment_handler_ ||
+      install_attributes_->IsActiveDirectoryManaged()) {
     return;
   }
   StartConnection(CreateClient(enterprise_service_));
 }
 
 void DeviceCloudPolicyInitializer::StartConnection(
     std::unique_ptr<CloudPolicyClient> client) {
   if (!manager_->core()->service())
     manager_->StartConnection(std::move(client), install_attributes_);
 }
@@ skipping 42 matching lines @@
   if (success && (success = att_signed_data.ParseFromString(signed_data))) {
     em_signed_data.set_data(att_signed_data.data());
     em_signed_data.set_signature(att_signed_data.signature());
     em_signed_data.set_extra_data_bytes(att_signed_data.data().size() -
                                         data.size());
   }
   callback.Run(success, em_signed_data);
 }
 
 }  // namespace policy