Delete dead consumer enrollment code.

chrome/browser/chromeos/ownership/owner_settings_service_chromeos.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/ownership/owner_settings_service_chromeos.h"
 
 #include <keyhi.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 141 matching lines @@
   scoped_refptr<base::TaskRunner> task_runner =
       BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
           base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
   base::PostTaskAndReplyWithResult(
       task_runner.get(),
       FROM_HERE,
       base::Bind(&DoesPrivateKeyExistAsyncHelper, owner_key_util),
       callback);
 }
 
-// Returns true if it is okay to transfer from the current mode to the new
-// mode. This function should be called in SetManagementMode().
-bool CheckManagementModeTransition(policy::ManagementMode current_mode,
-                                   policy::ManagementMode new_mode) {
-  // Mode is not changed.
-  if (current_mode == new_mode)
-    return true;
-
-  switch (current_mode) {
-    case policy::MANAGEMENT_MODE_LOCAL_OWNER:
-      // For consumer management enrollment.
-      return new_mode == policy::MANAGEMENT_MODE_CONSUMER_MANAGED;
-
-    case policy::MANAGEMENT_MODE_ENTERPRISE_MANAGED:
-      // Management mode cannot be set when it is currently ENTERPRISE_MANAGED.
-      return false;
-
-    case policy::MANAGEMENT_MODE_CONSUMER_MANAGED:
-      // For consumer management unenrollment.
-      return new_mode == policy::MANAGEMENT_MODE_LOCAL_OWNER;
-  }
-
-  NOTREACHED();
-  return false;
-}
-
 }  // namespace
 
 OwnerSettingsServiceChromeOS::ManagementSettings::ManagementSettings() {
 }
 
 OwnerSettingsServiceChromeOS::ManagementSettings::~ManagementSettings() {
 }
 
 OwnerSettingsServiceChromeOS::OwnerSettingsServiceChromeOS(
     DeviceSettingsService* device_settings_service,
     Profile* profile,
     const scoped_refptr<OwnerKeyUtil>& owner_key_util)
     : ownership::OwnerSettingsService(owner_key_util),
       device_settings_service_(device_settings_service),
       profile_(profile),
       waiting_for_profile_creation_(true),
       waiting_for_tpm_token_(true),
       has_pending_fixups_(false),
-      has_pending_management_settings_(false),
       weak_factory_(this),
       store_settings_factory_(this) {
   if (TPMTokenLoader::IsInitialized()) {
     TPMTokenLoader::TPMTokenStatus tpm_token_status =
         TPMTokenLoader::Get()->IsTPMTokenEnabled(
             base::Bind(&OwnerSettingsServiceChromeOS::OnTPMTokenReady,
                        weak_factory_.GetWeakPtr()));
     waiting_for_tpm_token_ =
         tpm_token_status == TPMTokenLoader::TPM_TOKEN_STATUS_UNDETERMINED;
   }
@@ skipping 38 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   waiting_for_tpm_token_ = false;
 
   // TPMTokenLoader initializes the TPM and NSS database which is necessary to
   // determine ownership. Force a reload once we know these are initialized.
   ReloadKeypair();
 }
 
 bool OwnerSettingsServiceChromeOS::HasPendingChanges() const {
   return !pending_changes_.empty() || tentative_settings_.get() ||
-         has_pending_management_settings_ || has_pending_fixups_;
+         has_pending_fixups_;
 }
 
 bool OwnerSettingsServiceChromeOS::HandlesSetting(const std::string& setting) {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kStubCrosSettings)) {
     return false;
   }
   return DeviceSettingsProvider::IsDeviceSetting(setting);
 }
 
@@ skipping 94 matching lines @@
 
 void OwnerSettingsServiceChromeOS::DeviceSettingsUpdated() {
   DCHECK(thread_checker_.CalledOnValidThread());
   StorePendingChanges();
 }
 
 void OwnerSettingsServiceChromeOS::OnDeviceSettingsServiceShutdown() {
   device_settings_service_ = nullptr;
 }
 
-void OwnerSettingsServiceChromeOS::SetManagementSettings(
-    const ManagementSettings& settings,
-    const OnManagementSettingsSetCallback& callback) {
-  if ((!IsOwner() && !IsOwnerInTests(user_id_))) {
-    if (!callback.is_null())
-      callback.Run(false /* success */);
-    return;
-  }
-
-  policy::ManagementMode current_mode = policy::MANAGEMENT_MODE_LOCAL_OWNER;
-  if (has_pending_management_settings_) {
-    current_mode = pending_management_settings_.management_mode;
-  } else if (device_settings_service_ &&
-             device_settings_service_->policy_data()) {
-    current_mode =
-        policy::GetManagementMode(*device_settings_service_->policy_data());
-  }
-
-  if (!CheckManagementModeTransition(current_mode, settings.management_mode)) {
-    LOG(ERROR) << "Invalid management mode transition: current mode = "
-               << current_mode << ", new mode = " << settings.management_mode;
-    if (!callback.is_null())
-      callback.Run(false /* success */);
-    return;
-  }
-
-  pending_management_settings_ = settings;
-  has_pending_management_settings_ = true;
-  pending_management_settings_callbacks_.push_back(callback);
-  StorePendingChanges();
-}
-
 // static
 void OwnerSettingsServiceChromeOS::IsOwnerForSafeModeAsync(
     const std::string& user_hash,
     const scoped_refptr<OwnerKeyUtil>& owner_key_util,
     const IsOwnerCallback& callback) {
   CHECK(chromeos::LoginState::Get()->IsInSafeMode());
 
   // Make sure NSS is initialized and NSS DB is loaded for the user before
   // searching for the owner key.
   BrowserThread::PostTaskAndReply(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(base::IgnoreResult(&crypto::InitializeNSSForChromeOSUser),
                  user_hash,
                  ProfileHelper::GetProfilePathByUserIdHash(user_hash)),
       base::Bind(&DoesPrivateKeyExistAsync, owner_key_util, callback));
 }
 
 // static
 std::unique_ptr<em::PolicyData> OwnerSettingsServiceChromeOS::AssemblePolicy(
     const std::string& user_id,
     const em::PolicyData* policy_data,
-    bool apply_pending_management_settings,
-    const ManagementSettings& pending_management_settings,
     em::ChromeDeviceSettingsProto* settings) {
   std::unique_ptr<em::PolicyData> policy(new em::PolicyData());
   if (policy_data) {
     // Preserve management settings.
     if (policy_data->has_management_mode())
       policy->set_management_mode(policy_data->management_mode());
     if (policy_data->has_request_token())
       policy->set_request_token(policy_data->request_token());
     if (policy_data->has_device_id())
       policy->set_device_id(policy_data->device_id());
   } else {
     // If there's no previous policy data, this is the first time the device
     // setting is set. We set the management mode to LOCAL_OWNER initially.
     policy->set_management_mode(em::PolicyData::LOCAL_OWNER);
   }
-  if (apply_pending_management_settings) {
-    policy::SetManagementMode(*policy,
-                              pending_management_settings.management_mode);
-
-    if (pending_management_settings.request_token.empty())
-      policy->clear_request_token();
-    else
-      policy->set_request_token(pending_management_settings.request_token);
-
-    if (pending_management_settings.device_id.empty())
-      policy->clear_device_id();
-    else
-      policy->set_device_id(pending_management_settings.device_id);
-  }
   policy->set_policy_type(policy::dm_protocol::kChromeDevicePolicyType);
   policy->set_timestamp(
       (base::Time::Now() - base::Time::UnixEpoch()).InMilliseconds());
   policy->set_username(user_id);
   if (policy_data->management_mode() == em::PolicyData::LOCAL_OWNER ||
       policy_data->management_mode() == em::PolicyData::CONSUMER_MANAGED) {
     FixupLocalOwnerPolicy(user_id, settings);
   }
   if (!settings->SerializeToString(policy->mutable_policy_value()))
     return std::unique_ptr<em::PolicyData>();
@@ skipping 290 matching lines @@
   } else {
     return;
   }
 
   for (const auto& change : pending_changes_)
     UpdateDeviceSettings(change.first, *change.second, settings);
   pending_changes_.clear();
 
   std::unique_ptr<em::PolicyData> policy =
       AssemblePolicy(user_id_, device_settings_service_->policy_data(),
-                     has_pending_management_settings_,
-                     pending_management_settings_, &settings);
+                     &settings);
   has_pending_fixups_ = false;
-  has_pending_management_settings_ = false;
 
   bool rv = AssembleAndSignPolicyAsync(
       content::BrowserThread::GetBlockingPool(), std::move(policy),
       base::Bind(&OwnerSettingsServiceChromeOS::OnPolicyAssembledAndSigned,
                  store_settings_factory_.GetWeakPtr()));
   if (!rv)
     ReportStatusAndContinueStoring(false /* success */);
 }
 
 void OwnerSettingsServiceChromeOS::OnPolicyAssembledAndSigned(
@@ skipping 13 matching lines @@
   ReportStatusAndContinueStoring(success &&
                                  device_settings_service_->status() ==
                                      DeviceSettingsService::STORE_SUCCESS);
 }
 
 void OwnerSettingsServiceChromeOS::ReportStatusAndContinueStoring(
     bool success) {
   store_settings_factory_.InvalidateWeakPtrs();
   FOR_EACH_OBSERVER(OwnerSettingsService::Observer, observers_,
                     OnSignedPolicyStored(success));
-
-  std::vector<OnManagementSettingsSetCallback> callbacks;
-  pending_management_settings_callbacks_.swap(callbacks);
-  for (const auto& callback : callbacks) {
-    if (!callback.is_null())
-      callback.Run(success);
-  }
   StorePendingChanges();
 }
 
 }  // namespace chromeos