Convert //extensions/browser from scoped_ptr to std::unique_ptr

extensions/browser/extension_prefs.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_EXTENSION_PREFS_H_
 #define EXTENSIONS_BROWSER_EXTENSION_PREFS_H_
 
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "extensions/browser/blacklist_state.h"
 #include "extensions/browser/extension_scoped_prefs.h"
 #include "extensions/browser/install_flag.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
@@ skipping 114 matching lines @@
 
   // A version of Create which allows injection of a custom base::Time provider.
   // Use this as needed for testing.
   static ExtensionPrefs* Create(
       content::BrowserContext* browser_context,
       PrefService* prefs,
       const base::FilePath& root_dir,
       ExtensionPrefValueMap* extension_pref_value_map,
       bool extensions_disabled,
       const std::vector<ExtensionPrefsObserver*>& early_observers,
-      scoped_ptr<TimeProvider> time_provider);
+      std::unique_ptr<TimeProvider> time_provider);
 
   ~ExtensionPrefs() override;
 
   // Convenience function to get the ExtensionPrefs for a BrowserContext.
   static ExtensionPrefs* Get(content::BrowserContext* context);
 
   // Returns all installed extensions from extension preferences provided by
   // |pref_service|. This is exposed for ProtectedPrefsWatcher because it needs
   // access to the extension ID list before the ExtensionService is initialized.
   static ExtensionIdList GetExtensionsFrom(const PrefService* pref_service);
@@ skipping 189 matching lines @@
 
   // A bit we use for determining if we should send the "days since active"
   // ping. A value of true means the item has been active (launched) since the
   // last update check.
   bool GetActiveBit(const std::string& extension_id) const;
   void SetActiveBit(const std::string& extension_id, bool active);
 
   // Returns the granted permission set for the extension with |extension_id|,
   // and NULL if no preferences were found for |extension_id|.
   // This passes ownership of the returned set to the caller.
-  scoped_ptr<const PermissionSet> GetGrantedPermissions(
+  std::unique_ptr<const PermissionSet> GetGrantedPermissions(
       const std::string& extension_id) const;
 
   // Adds |permissions| to the granted permissions set for the extension with
   // |extension_id|. The new granted permissions set will be the union of
   // |permissions| and the already granted permissions.
   void AddGrantedPermissions(const std::string& extension_id,
                              const PermissionSet& permissions);
 
   // As above, but subtracts the given |permissions| from the granted set.
   void RemoveGrantedPermissions(const std::string& extension_id,
                                 const PermissionSet& permissions);
 
   // Gets the active permission set for the specified extension. This may
   // differ from the permissions in the manifest due to the optional
   // permissions API. This passes ownership of the set to the caller.
-  scoped_ptr<const PermissionSet> GetActivePermissions(
+  std::unique_ptr<const PermissionSet> GetActivePermissions(
       const std::string& extension_id) const;
 
   // Sets the active |permissions| for the extension with |extension_id|.
   void SetActivePermissions(const std::string& extension_id,
                             const PermissionSet& permissions);
 
   // Records whether or not this extension is currently running.
   void SetExtensionRunning(const std::string& extension_id, bool is_running);
 
   // Returns whether or not this extension is marked as running. This is used to
@@ skipping 20 matching lines @@
   // IMPORTANT: you probably want to use extensions::util::AllowFileAccess
   // instead of this method.
   bool AllowFileAccess(const std::string& extension_id) const;
   void SetAllowFileAccess(const std::string& extension_id, bool allow);
   bool HasAllowFileAccessSetting(const std::string& extension_id) const;
 
   // Saves ExtensionInfo for each installed extension with the path to the
   // version directory and the location. Blacklisted extensions won't be saved
   // and neither will external extensions the user has explicitly uninstalled.
   // Caller takes ownership of returned structure.
-  scoped_ptr<ExtensionsInfo> GetInstalledExtensionsInfo() const;
+  std::unique_ptr<ExtensionsInfo> GetInstalledExtensionsInfo() const;
 
   // Same as above, but only includes external extensions the user has
   // explicitly uninstalled.
-  scoped_ptr<ExtensionsInfo> GetUninstalledExtensionsInfo() const;
+  std::unique_ptr<ExtensionsInfo> GetUninstalledExtensionsInfo() const;
 
   // Returns the ExtensionInfo from the prefs for the given extension. If the
   // extension is not present, NULL is returned.
-  scoped_ptr<ExtensionInfo> GetInstalledExtensionInfo(
+  std::unique_ptr<ExtensionInfo> GetInstalledExtensionInfo(
       const std::string& extension_id) const;
 
   // We've downloaded an updated .crx file for the extension, but are waiting
   // to install it.
   //
   // |install_flags| are a bitmask of extension::InstallFlags.
   void SetDelayedInstallInfo(const Extension* extension,
                              Extension::State initial_state,
                              int install_flags,
                              DelayReason delay_reason,
                              const syncer::StringOrdinal& page_ordinal,
                              const std::string& install_parameter);
 
   // Removes any delayed install information we have for the given
   // |extension_id|. Returns true if there was info to remove; false otherwise.
   bool RemoveDelayedInstallInfo(const std::string& extension_id);
 
   // Update the prefs to finish the update for an extension.
   bool FinishDelayedInstallInfo(const std::string& extension_id);
 
   // Returns the ExtensionInfo from the prefs for delayed install information
   // for |extension_id|, if we have any. Otherwise returns NULL.
-  scoped_ptr<ExtensionInfo> GetDelayedInstallInfo(
+  std::unique_ptr<ExtensionInfo> GetDelayedInstallInfo(
       const std::string& extension_id) const;
 
   DelayReason GetDelayedInstallReason(const std::string& extension_id) const;
 
   // Returns information about all the extensions that have delayed install
   // information.
-  scoped_ptr<ExtensionsInfo> GetAllDelayedInstallInfo() const;
+  std::unique_ptr<ExtensionsInfo> GetAllDelayedInstallInfo() const;
 
   // Returns true if the user repositioned the app on the app launcher via drag
   // and drop.
   bool WasAppDraggedByUser(const std::string& extension_id) const;
 
   // Sets a flag indicating that the user repositioned the app on the app
   // launcher by drag and dropping it.
   void SetAppDraggedByUser(const std::string& extension_id);
 
   // Returns true if there is an extension which controls the preference value
@@ skipping 50 matching lines @@
   // start of this ExtensionService. Applies only to extensions with isolated
   // storage.
   void SetNeedsStorageGarbageCollection(bool value);
   bool NeedsStorageGarbageCollection() const;
 
   // Used by AppWindowGeometryCache to persist its cache. These methods
   // should not be called directly.
   const base::DictionaryValue* GetGeometryCache(
         const std::string& extension_id) const;
   void SetGeometryCache(const std::string& extension_id,
-                        scoped_ptr<base::DictionaryValue> cache);
+                        std::unique_ptr<base::DictionaryValue> cache);
 
   // Used for verification of installed extension ids. For the Set method, pass
   // null to remove the preference.
   const base::DictionaryValue* GetInstallSignature() const;
   void SetInstallSignature(const base::DictionaryValue* signature);
 
   // The installation parameter associated with the extension.
   std::string GetInstallParam(const std::string& extension_id) const;
   void SetInstallParam(const std::string& extension_id,
                        const std::string& install_parameter);
@@ skipping 19 matching lines @@
     DISABLE_REASON_REMOVE,
     DISABLE_REASON_REPLACE,
     DISABLE_REASON_CLEAR
   };
 
   // See the Create methods.
   ExtensionPrefs(content::BrowserContext* browser_context,
                  PrefService* prefs,
                  const base::FilePath& root_dir,
                  ExtensionPrefValueMap* extension_pref_value_map,
-                 scoped_ptr<TimeProvider> time_provider,
+                 std::unique_ptr<TimeProvider> time_provider,
                  bool extensions_disabled,
                  const std::vector<ExtensionPrefsObserver*>& early_observers);
 
   // Converts absolute paths in the pref to paths relative to the
   // install_directory_.
   void MakePathsRelative();
 
   // Converts internal relative paths to be absolute. Used for export to
   // consumers who expect full paths.
   void MakePathsAbsolute(base::DictionaryValue* dict);
 
   // Helper function used by GetInstalledExtensionInfo() and
   // GetDelayedInstallInfo() to construct an ExtensionInfo from the provided
   // |extension| dictionary.
-  scoped_ptr<ExtensionInfo> GetInstalledInfoHelper(
+  std::unique_ptr<ExtensionInfo> GetInstalledInfoHelper(
       const std::string& extension_id,
       const base::DictionaryValue* extension) const;
 
   // Interprets the list pref, |pref_key| in |extension_id|'s preferences, as a
   // URLPatternSet. The |valid_schemes| specify how to parse the URLPatterns.
   bool ReadPrefAsURLPatternSet(const std::string& extension_id,
                                const std::string& pref_key,
                                URLPatternSet* result,
                                int valid_schemes) const;
 
   // Converts |new_value| to a list of strings and sets the |pref_key| pref
   // belonging to |extension_id|.
   void SetExtensionPrefURLPatternSet(const std::string& extension_id,
                                      const std::string& pref_key,
                                      const URLPatternSet& new_value);
 
   // Read the boolean preference entry and return true if the preference exists
   // and the preference's value is true; false otherwise.
   bool ReadPrefAsBooleanAndReturn(const std::string& extension_id,
                                   const std::string& key) const;
 
   // Interprets |pref_key| in |extension_id|'s preferences as an
   // PermissionSet, and passes ownership of the set to the caller.
-  scoped_ptr<const PermissionSet> ReadPrefAsPermissionSet(
+  std::unique_ptr<const PermissionSet> ReadPrefAsPermissionSet(
       const std::string& extension_id,
       const std::string& pref_key) const;
 
   // Converts the |new_value| to its value and sets the |pref_key| pref
   // belonging to |extension_id|.
   void SetExtensionPrefPermissionSet(const std::string& extension_id,
                                      const std::string& pref_key,
                                      const PermissionSet& new_value);
 
   // Returns an immutable dictionary for extension |id|'s prefs, or NULL if it
@@ skipping 60 matching lines @@
   // The pref service specific to this set of extension prefs. Owned by the
   // BrowserContext.
   PrefService* prefs_;
 
   // Base extensions install directory.
   base::FilePath install_directory_;
 
   // Weak pointer, owned by BrowserContext.
   ExtensionPrefValueMap* extension_pref_value_map_;
 
-  scoped_ptr<TimeProvider> time_provider_;
+  std::unique_ptr<TimeProvider> time_provider_;
 
   bool extensions_disabled_;
 
   base::ObserverList<ExtensionPrefsObserver> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPrefs);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_EXTENSION_PREFS_H_