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

chrome/browser/chromeos/platform_keys/key_permissions.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_PLATFORM_KEYS_KEY_PERMISSIONS_H_
 #define CHROME_BROWSER_CHROMEOS_PLATFORM_KEYS_KEY_PERMISSIONS_H_
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 
 class PrefService;
 
 namespace base {
 class DictionaryValue;
 class Value;
 }
 
 namespace extensions {
@@ skipping 51 matching lines @@
  public:
   // Allows querying and modifying permissions and registering keys for a
   // specific extension.
   class PermissionsForExtension {
    public:
     // |key_permissions| must not be null and outlive this object.
     // Methods of this object refer implicitly to the extension with the id
     // |extension_id|. Don't use this constructor directly. Call
     // |KeyPermissions::GetPermissionsForExtension| instead.
     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);
 
     ~PermissionsForExtension();
 
     // Returns true if the private key matching |public_key_spki_der| can be
     // used for signing by the extension with id |extension_id|.
     // |public_key_spki_der| must be the DER of a Subject Public Key Info.
     bool CanUseKeyForSigning(const std::string& public_key_spki_der);
@@ skipping 23 matching lines @@
     // Writes the current |state_store_entries_| to the state store of
     // |extension_id_|.
     void WriteToStateStore();
 
     // Reads a KeyEntry list from |state| and stores them in
     // |state_store_entries_|.
     void KeyEntriesFromState(const base::Value& state);
 
     // Converts |state_store_entries_| to a base::Value for storing in the state
     // store.
-    scoped_ptr<base::Value> KeyEntriesToState();
+    std::unique_ptr<base::Value> KeyEntriesToState();
 
     // Returns an existing entry for |public_key_spki_der_b64| from
     // |state_store_entries_|. If there is no existing entry, creates, adds and
     // returns a new entry.
     // |public_key_spki_der| must be the base64 encoding of the DER of a Subject
     // Public Key Info.
     KeyPermissions::PermissionsForExtension::KeyEntry* GetStateStoreEntry(
         const std::string& public_key_spki_der_b64);
 
     bool PolicyAllowsCorporateKeyUsage() const;
@@ skipping 14 matching lines @@
   // |profile_is_managed| determines the default usage and permissions for
   // keys without explicitly assigned usage.
   KeyPermissions(bool profile_is_managed,
                  PrefService* profile_prefs,
                  policy::PolicyService* profile_policies,
                  extensions::StateStore* extensions_state_store);
 
   ~KeyPermissions();
 
   using PermissionsCallback =
-      base::Callback<void(scoped_ptr<PermissionsForExtension>)>;
+      base::Callback<void(std::unique_ptr<PermissionsForExtension>)>;
 
   // Passes an object managing the key permissions of the extension with id
   // |extension_id| to |callback|. This can happen synchronously or
   // asynchronously.
   void GetPermissionsForExtension(const std::string& extension_id,
                                   const PermissionsCallback& callback);
 
   // Returns true if the user can grant any permission for |public_key_spki_der|
   // to extensions. |public_key_spki_der| must be the DER of a Subject Public
   // Key Info.
   bool CanUserGrantPermissionFor(const std::string& public_key_spki_der) const;
 
   static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
 
  private:
   bool IsCorporateKey(const std::string& public_key_spki_der_b64) const;
 
   // Creates a PermissionsForExtension object from |extension_id| and |value|
   // and passes the object to |callback|.
   void CreatePermissionObjectAndPassToCallback(
       const std::string& extension_id,
       const PermissionsCallback& callback,
-      scoped_ptr<base::Value> value);
+      std::unique_ptr<base::Value> value);
 
   // Writes |value| to the state store of the extension with id |extension_id|.
   void SetPlatformKeysOfExtension(const std::string& extension_id,
-                                  scoped_ptr<base::Value> value);
+                                  std::unique_ptr<base::Value> value);
 
   const base::DictionaryValue* GetPrefsEntry(
       const std::string& public_key_spki_der_b64) const;
 
   const bool profile_is_managed_;
   PrefService* const profile_prefs_;
   policy::PolicyService* const profile_policies_;
   extensions::StateStore* const extensions_state_store_;
   base::WeakPtrFactory<KeyPermissions> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(KeyPermissions);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_PLATFORM_KEYS_KEY_PERMISSIONS_H_