Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

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>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
+#include "base/memory/ptr_util.h"
 #include "base/threading/thread_checker.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos_factory.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_provider.h"
 #include "chrome/browser/chromeos/settings/session_manager_operation.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
@@ skipping 243 matching lines @@
   }
   return DeviceSettingsProvider::IsDeviceSetting(setting);
 }
 
 bool OwnerSettingsServiceChromeOS::Set(const std::string& setting,
                                        const base::Value& value) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!IsOwner() && !IsOwnerInTests(user_id_))
     return false;
 
-  pending_changes_.add(setting, make_scoped_ptr(value.DeepCopy()));
+  pending_changes_.add(setting, base::WrapUnique(value.DeepCopy()));
 
   em::ChromeDeviceSettingsProto settings;
   if (tentative_settings_.get()) {
     settings = *tentative_settings_;
   } else if (device_settings_service_->status() ==
                  DeviceSettingsService::STORE_SUCCESS &&
              device_settings_service_->device_settings()) {
     settings = *device_settings_service_->device_settings();
   }
   UpdateDeviceSettings(setting, value, settings);
   em::PolicyData policy_data;
   policy_data.set_username(user_id_);
   CHECK(settings.SerializeToString(policy_data.mutable_policy_value()));
   FOR_EACH_OBSERVER(OwnerSettingsService::Observer, observers_,
                     OnTentativeChangesInPolicy(policy_data));
   StorePendingChanges();
   return true;
 }
 
 bool OwnerSettingsServiceChromeOS::AppendToList(const std::string& setting,
                                                 const base::Value& value) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const base::Value* old_value = CrosSettings::Get()->GetPref(setting);
   if (old_value && !old_value->IsType(base::Value::TYPE_LIST))
     return false;
-  scoped_ptr<base::ListValue> new_value(
+  std::unique_ptr<base::ListValue> new_value(
       old_value ? static_cast<const base::ListValue*>(old_value)->DeepCopy()
                 : new base::ListValue());
   new_value->Append(value.DeepCopy());
   return Set(setting, *new_value);
 }
 
 bool OwnerSettingsServiceChromeOS::RemoveFromList(const std::string& setting,
                                                   const base::Value& value) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const base::Value* old_value = CrosSettings::Get()->GetPref(setting);
   if (old_value && !old_value->IsType(base::Value::TYPE_LIST))
     return false;
-  scoped_ptr<base::ListValue> new_value(
+  std::unique_ptr<base::ListValue> new_value(
       old_value ? static_cast<const base::ListValue*>(old_value)->DeepCopy()
                 : new base::ListValue());
   new_value->Remove(value, nullptr);
   return Set(setting, *new_value);
 }
 
 bool OwnerSettingsServiceChromeOS::CommitTentativeDeviceSettings(
-    scoped_ptr<enterprise_management::PolicyData> policy) {
+    std::unique_ptr<enterprise_management::PolicyData> policy) {
   if (!IsOwner() && !IsOwnerInTests(user_id_))
     return false;
   if (policy->username() != user_id_) {
     LOG(ERROR) << "Username mismatch: " << policy->username() << " vs. "
                << user_id_;
     return false;
   }
   tentative_settings_.reset(new em::ChromeDeviceSettingsProto);
   CHECK(tentative_settings_->ParseFromString(policy->policy_value()));
   StorePendingChanges();
@@ skipping 84 matching lines @@
   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
-scoped_ptr<em::PolicyData> OwnerSettingsServiceChromeOS::AssemblePolicy(
+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) {
-  scoped_ptr<em::PolicyData> policy(new em::PolicyData());
+  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
@@ skipping 16 matching lines @@
   }
   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 scoped_ptr<em::PolicyData>();
+    return std::unique_ptr<em::PolicyData>();
 
   return policy;
 }
 
 // static
 void OwnerSettingsServiceChromeOS::FixupLocalOwnerPolicy(
     const std::string& user_id,
     enterprise_management::ChromeDeviceSettingsProto* settings) {
   if (!settings->has_allow_new_users())
     settings->mutable_allow_new_users()->set_allow_new_users(true);
@@ skipping 278 matching lines @@
              device_settings_service_->device_settings()) {
     settings = *device_settings_service_->device_settings();
   } else {
     return;
   }
 
   for (const auto& change : pending_changes_)
     UpdateDeviceSettings(change.first, *change.second, settings);
   pending_changes_.clear();
 
-  scoped_ptr<em::PolicyData> policy =
+  std::unique_ptr<em::PolicyData> policy =
       AssemblePolicy(user_id_, device_settings_service_->policy_data(),
                      has_pending_management_settings_,
                      pending_management_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(
-    scoped_ptr<em::PolicyFetchResponse> policy_response) {
+    std::unique_ptr<em::PolicyFetchResponse> policy_response) {
   if (!policy_response.get() || !device_settings_service_) {
     ReportStatusAndContinueStoring(false /* success */);
     return;
   }
   device_settings_service_->Store(
       std::move(policy_response),
       base::Bind(&OwnerSettingsServiceChromeOS::OnSignedPolicyStored,
                  store_settings_factory_.GetWeakPtr(), true /* success */));
 }
 
@@ skipping 13 matching lines @@
   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