Delete dead consumer enrollment code.

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 34 matching lines @@
     return default_value;
 
   return value;
 }
 
 }  // namespace
 
 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)
     : 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),
       is_initialized_(false) {
 }
 
 DeviceCloudPolicyInitializer::~DeviceCloudPolicyInitializer() {
   DCHECK(!is_initialized_);
@@ skipping 14 matching lines @@
 void DeviceCloudPolicyInitializer::Shutdown() {
   DCHECK(is_initialized_);
 
   device_store_->RemoveObserver(this);
   enrollment_handler_.reset();
   state_keys_update_subscription_.reset();
   is_initialized_ = false;
 }
 
 void DeviceCloudPolicyInitializer::StartEnrollment(
-    ManagementMode management_mode,
     DeviceManagementService* device_management_service,
-    chromeos::OwnerSettingsServiceChromeOS* owner_settings_service,
     const EnrollmentConfig& enrollment_config,
     const std::string& auth_token,
     const AllowedDeviceModes& allowed_device_modes,
     const EnrollmentCallback& enrollment_callback) {
   DCHECK(is_initialized_);
   DCHECK(!enrollment_handler_);
 
   manager_->core()->Disconnect();
   enrollment_handler_.reset(new EnrollmentHandlerChromeOS(
       device_store_, install_attributes_, state_keys_broker_,
-      owner_settings_service, CreateClient(device_management_service),
-      background_task_runner_, enrollment_config, auth_token,
-      install_attributes_->GetDeviceId(), manager_->GetDeviceRequisition(),
-      allowed_device_modes, management_mode,
+      CreateClient(device_management_service), background_task_runner_,
+      enrollment_config, auth_token, install_attributes_->GetDeviceId(),
+      manager_->GetDeviceRequisition(), allowed_device_modes,
       base::Bind(&DeviceCloudPolicyInitializer::EnrollmentCompleted,
                  base::Unretained(this), enrollment_callback)));
   enrollment_handler_->StartEnrollment();
 }
 
 EnrollmentConfig DeviceCloudPolicyInitializer::GetPrescribedEnrollmentConfig()
     const {
   EnrollmentConfig config;
 
   // Authentication through the attestation mechanism is controlled by a
@@ skipping 131 matching lines @@
       g_browser_process->system_request_context()));
 }
 
 void DeviceCloudPolicyInitializer::TryToCreateClient() {
   if (!device_store_->is_initialized() ||
       !device_store_->has_policy() ||
       state_keys_broker_->pending() ||
       enrollment_handler_) {
     return;
   }
-
-  DeviceManagementService* service = nullptr;
-  if (GetManagementMode(*device_store_->policy()) ==
-      MANAGEMENT_MODE_CONSUMER_MANAGED) {
-    service = consumer_service_;
-  } else if (GetManagementMode(*device_store_->policy()) ==
-             MANAGEMENT_MODE_ENTERPRISE_MANAGED) {
-    service = enterprise_service_;
-  }
-
-  if (service)
-    StartConnection(CreateClient(service));
+  StartConnection(CreateClient(enterprise_service_));
 }
 
 void DeviceCloudPolicyInitializer::StartConnection(
     std::unique_ptr<CloudPolicyClient> client) {
   if (!manager_->core()->service())
     manager_->StartConnection(std::move(client), install_attributes_);
 }
 
 }  // namespace policy