Delete dead consumer enrollment code.

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 <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 49 matching lines @@
   NOTREACHED() << "Bad enrollment mode: " << mode;
   return em::DeviceRegisterRequest::FLAVOR_ENROLLMENT_MANUAL;
 }
 
 }  // namespace
 
 EnrollmentHandlerChromeOS::EnrollmentHandlerChromeOS(
     DeviceCloudPolicyStoreChromeOS* store,
     EnterpriseInstallAttributes* install_attributes,
     ServerBackedStateKeysBroker* state_keys_broker,
-    chromeos::OwnerSettingsServiceChromeOS* owner_settings_service,
     std::unique_ptr<CloudPolicyClient> client,
     scoped_refptr<base::SequencedTaskRunner> background_task_runner,
     const EnrollmentConfig& enrollment_config,
     const std::string& auth_token,
     const std::string& client_id,
     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),
-      owner_settings_service_(owner_settings_service),
       client_(std::move(client)),
       background_task_runner_(background_task_runner),
       enrollment_config_(enrollment_config),
       auth_token_(auth_token),
       client_id_(client_id),
       requisition_(requisition),
       allowed_device_modes_(allowed_device_modes),
-      management_mode_(management_mode),
       completion_callback_(completion_callback),
       device_mode_(DEVICE_MODE_NOT_SET),
       skip_robot_auth_(false),
       enrollment_step_(STEP_PENDING),
       lockbox_init_duration_(0),
       weak_ptr_factory_(this) {
   CHECK(!client_->is_registered());
   CHECK_EQ(DM_STATUS_SUCCESS, client_->status());
-  CHECK(management_mode_ == MANAGEMENT_MODE_ENTERPRISE_MANAGED ||
-        management_mode_ == MANAGEMENT_MODE_CONSUMER_MANAGED);
   store_->AddObserver(this);
   client_->AddObserver(this);
   client_->AddPolicyTypeToFetch(dm_protocol::kChromeDevicePolicyType,
                                 std::string());
 }
 
 EnrollmentHandlerChromeOS::~EnrollmentHandlerChromeOS() {
   Stop();
   store_->RemoveObserver(this);
 }
@@ skipping 39 matching lines @@
   // previously-enrolled domain.
   std::string domain;
   if (install_attributes_->IsEnterpriseDevice()) {
     domain = install_attributes_->GetDomain();
     validator->ValidateDomain(domain);
   }
   validator->ValidateDMToken(client->dm_token(),
                              CloudPolicyValidatorBase::DM_TOKEN_REQUIRED);
   validator->ValidatePolicyType(dm_protocol::kChromeDevicePolicyType);
   validator->ValidatePayload();
-  if (management_mode_ == MANAGEMENT_MODE_CONSUMER_MANAGED) {
-    // For consumer-managed devices, although we don't store the policy, we
-    // still need to verify its integrity since we use the request token in it.
-    // The consumer device management server does not have the verification
-    // key, and we need to skip checking on that by passing an empty key to
-    // ValidateInitialKey(). ValidateInitialKey() still checks that the policy
-    // data is correctly signed by the new public key when the verification key
-    // is empty.
-    validator->ValidateInitialKey(std::string(), std::string());
-  } else {
-    // If |domain| is empty here, the policy validation code will just use the
-    // domain from the username field in the policy itself to do key validation.
-    // TODO(mnissler): Plumb the enrolling user's username into this object so
-    // we can validate the username on the resulting policy, and use the domain
-    // from that username to validate the key below (http://crbug.com/343074).
-    validator->ValidateInitialKey(GetPolicyVerificationKey(), domain);
-  }
+  // If |domain| is empty here, the policy validation code will just use the
+  // domain from the username field in the policy itself to do key validation.
+  // TODO(mnissler): Plumb the enrolling user's username into this object so we
+  // can validate the username on the resulting policy, and use the domain from
+  // that username to validate the key below (http://crbug.com/343074).
+  validator->ValidateInitialKey(GetPolicyVerificationKey(), domain);
   validator.release()->StartValidation(
       base::Bind(&EnrollmentHandlerChromeOS::HandlePolicyValidationResult,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void EnrollmentHandlerChromeOS::OnRegistrationStateChanged(
     CloudPolicyClient* client) {
   DCHECK_EQ(client_.get(), client);
 
   if (enrollment_step_ == STEP_REGISTRATION && client_->is_registered()) {
@@ skipping 174 matching lines @@
              << response_code;
   ReportResult(
       EnrollmentStatus::ForRobotRefreshFetchError(response_code));
 }
 
 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) {
-    CHECK(owner_settings_service_);
-
-    // Consumer device enrollment doesn't use install attributes. Instead,
-    // we put the information in the owners settings.
-    enrollment_step_ = STEP_STORE_TOKEN_AND_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()));
-  }
+  install_attributes_->LockDevice(
+      username_, device_mode_, device_id_,
+      base::Bind(&EnrollmentHandlerChromeOS::HandleLockDeviceResult,
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void EnrollmentHandlerChromeOS::HandleSetManagementSettingsDone(bool success) {
   CHECK_EQ(STEP_STORE_TOKEN_AND_ID, enrollment_step_);
   if (!success) {
     ReportResult(EnrollmentStatus::ForStatus(
         EnrollmentStatus::STATUS_STORE_TOKEN_AND_ID_FAILED));
     return;
   }
 
@@ skipping 54 matching lines @@
 void EnrollmentHandlerChromeOS::HandleStoreRobotAuthTokenResult(bool result) {
   CHECK_EQ(STEP_STORE_ROBOT_AUTH, enrollment_step_);
 
   if (!result) {
     LOG(ERROR) << "Failed to store API refresh token.";
     ReportResult(EnrollmentStatus::ForStatus(
         EnrollmentStatus::STATUS_ROBOT_REFRESH_STORE_FAILED));
     return;
   }
 
-  if (management_mode_ == MANAGEMENT_MODE_CONSUMER_MANAGED) {
-    // For consumer management enrollment, we don't store the policy.
-    ReportResult(EnrollmentStatus::ForStatus(EnrollmentStatus::STATUS_SUCCESS));
-    return;
-  }
-
   enrollment_step_ = STEP_STORE_POLICY;
   store_->InstallInitialPolicy(*policy_);
 }
 
 void EnrollmentHandlerChromeOS::Stop() {
   if (client_.get())
     client_->RemoveObserver(this);
   enrollment_step_ = STEP_FINISHED;
   weak_ptr_factory_.InvalidateWeakPtrs();
   completion_callback_.Reset();
 }
 
 void EnrollmentHandlerChromeOS::ReportResult(EnrollmentStatus status) {
   EnrollmentCallback callback = completion_callback_;
   Stop();
 
   if (status.status() != EnrollmentStatus::STATUS_SUCCESS) {
     LOG(WARNING) << "Enrollment failed: " << status.status()
                  << ", client: " << status.client_status()
                  << ", validation: " << status.validation_status()
                  << ", store: " << status.store_status()
                  << ", lock: " << status.lock_status();
   }
 
   if (!callback.is_null())
     callback.Run(status);
 }
 
 }  // namespace policy