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

chrome/browser/chromeos/platform_keys/key_permissions.cc

 // Copyright 2015 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/platform_keys/key_permissions.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/common/pref_names.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/core/common/policy_namespace.h"
 #include "components/policy/core/common/policy_service.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "extensions/browser/state_store.h"
 #include "policy/policy_constants.h"
@@ skipping 58 matching lines @@
 
   // True if the key can be used for signing an unlimited number of times.
   // This permission is granted by the user to allow the extension to use the
   // key for signing through the enterprise.platformKeys or platformKeys API.
   // This permission is granted until revoked by the user or the policy.
   bool sign_unlimited = false;
 };
 
 KeyPermissions::PermissionsForExtension::PermissionsForExtension(
     const std::string& extension_id,
-    scoped_ptr<base::Value> state_store_value,
+    std::unique_ptr<base::Value> state_store_value,
     PrefService* profile_prefs,
     policy::PolicyService* profile_policies,
     KeyPermissions* key_permissions)
     : extension_id_(extension_id),
       profile_prefs_(profile_prefs),
       profile_policies_(profile_policies),
       key_permissions_(key_permissions) {
   DCHECK(profile_prefs_);
   DCHECK(profile_policies_);
   DCHECK(key_permissions_);
@@ skipping 60 matching lines @@
   if (matching_entry->sign_once) {
     VLOG(1) << "Key is already allowed for signing, skipping.";
     return;
   }
 
   matching_entry->sign_once = true;
   WriteToStateStore();
 
   DictionaryPrefUpdate update(profile_prefs_, prefs::kPlatformKeys);
 
-  scoped_ptr<base::DictionaryValue> new_pref_entry(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> new_pref_entry(
+      new base::DictionaryValue);
   new_pref_entry->SetStringWithoutPathExpansion(kPrefKeyUsage,
                                                 kPrefKeyUsageCorporate);
 
   update->SetWithoutPathExpansion(public_key_spki_der_b64,
                                   new_pref_entry.release());
 }
 
 void KeyPermissions::PermissionsForExtension::SetUserGrantedPermission(
     const std::string& public_key_spki_der) {
   if (!key_permissions_->CanUserGrantPermissionFor(public_key_spki_der)) {
@@ skipping 84 matching lines @@
                                                  &new_entry.sign_unlimited);
       state_store_entries_.push_back(new_entry);
     } else {
       LOG(ERROR) << "Found invalid entry of type " << entry->GetType()
                  << " in PlatformKeys state store.";
       continue;
     }
   }
 }
 
-scoped_ptr<base::Value>
+std::unique_ptr<base::Value>
 KeyPermissions::PermissionsForExtension::KeyEntriesToState() {
-  scoped_ptr<base::ListValue> new_state(new base::ListValue);
+  std::unique_ptr<base::ListValue> new_state(new base::ListValue);
   for (const KeyEntry& entry : state_store_entries_) {
     // Drop entries that the extension doesn't have any permissions for anymore.
     if (!entry.sign_once && !entry.sign_unlimited)
       continue;
 
-    scoped_ptr<base::DictionaryValue> new_entry(new base::DictionaryValue);
+    std::unique_ptr<base::DictionaryValue> new_entry(new base::DictionaryValue);
     new_entry->SetStringWithoutPathExpansion(kStateStoreSPKI, entry.spki_b64);
     // Omit writing default values, namely |false|.
     if (entry.sign_once) {
       new_entry->SetBooleanWithoutPathExpansion(kStateStoreSignOnce,
                                                 entry.sign_once);
     }
     if (entry.sign_unlimited) {
       new_entry->SetBooleanWithoutPathExpansion(kStateStoreSignUnlimited,
                                                 entry.sign_unlimited);
     }
@@ skipping 71 matching lines @@
 
 void KeyPermissions::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   // For the format of the dictionary see the documentation at kPrefKeyUsage.
   registry->RegisterDictionaryPref(prefs::kPlatformKeys);
 }
 
 void KeyPermissions::CreatePermissionObjectAndPassToCallback(
     const std::string& extension_id,
     const PermissionsCallback& callback,
-    scoped_ptr<base::Value> value) {
-  callback.Run(make_scoped_ptr(
+    std::unique_ptr<base::Value> value) {
+  callback.Run(base::WrapUnique(
       new PermissionsForExtension(extension_id, std::move(value),
                                   profile_prefs_, profile_policies_, this)));
 }
 
-void KeyPermissions::SetPlatformKeysOfExtension(const std::string& extension_id,
-                                                scoped_ptr<base::Value> value) {
+void KeyPermissions::SetPlatformKeysOfExtension(
+    const std::string& extension_id,
+    std::unique_ptr<base::Value> value) {
   extensions_state_store_->SetExtensionValue(
       extension_id, kStateStorePlatformKeys, std::move(value));
 }
 
 const base::DictionaryValue* KeyPermissions::GetPrefsEntry(
     const std::string& public_key_spki_der_b64) const {
   const base::DictionaryValue* platform_keys =
       profile_prefs_->GetDictionary(prefs::kPlatformKeys);
 
   const base::DictionaryValue* key_entry = nullptr;
   platform_keys->GetDictionaryWithoutPathExpansion(public_key_spki_der_b64,
                                                    &key_entry);
   return key_entry;
 }
 
 }  // namespace chromeos