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

extensions/browser/extension_prefs.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 "extensions/browser/extension_prefs.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <iterator>
 #include <utility>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "components/crx_file/id_util.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "extensions/browser/app_sorting.h"
 #include "extensions/browser/event_router.h"
@@ skipping 302 matching lines @@
 ExtensionPrefs* 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) {
   return ExtensionPrefs::Create(browser_context, prefs, root_dir,
                                 extension_pref_value_map, extensions_disabled,
                                 early_observers,
-                                make_scoped_ptr(new TimeProvider()));
+                                base::WrapUnique(new TimeProvider()));
 }
 
 // static
 ExtensionPrefs* ExtensionPrefs::Create(
     content::BrowserContext* browser_context,
     PrefService* pref_service,
     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) {
   return new ExtensionPrefs(browser_context, pref_service, root_dir,
                             extension_pref_value_map, std::move(time_provider),
                             extensions_disabled, early_observers);
 }
 
 ExtensionPrefs::~ExtensionPrefs() {
 }
 
 // static
 ExtensionPrefs* ExtensionPrefs::Get(content::BrowserContext* context) {
@@ skipping 185 matching lines @@
   UpdateExtensionPref(extension_id, pref_key, new_value.ToValue().release());
 }
 
 bool ExtensionPrefs::ReadPrefAsBooleanAndReturn(
     const std::string& extension_id,
     const std::string& pref_key) const {
   bool out_value = false;
   return ReadPrefAsBoolean(extension_id, pref_key, &out_value) && out_value;
 }
 
-scoped_ptr<const PermissionSet> ExtensionPrefs::ReadPrefAsPermissionSet(
+std::unique_ptr<const PermissionSet> ExtensionPrefs::ReadPrefAsPermissionSet(
     const std::string& extension_id,
     const std::string& pref_key) const {
   if (!GetExtensionPref(extension_id))
     return nullptr;
 
   // Retrieve the API permissions. Please refer SetExtensionPrefPermissionSet()
   // for api_values format.
   APIPermissionSet apis;
   const base::ListValue* api_values = NULL;
   std::string api_pref = JoinPrefs(pref_key, kPrefAPIs);
@@ skipping 20 matching lines @@
   ReadPrefAsURLPatternSet(
       extension_id, JoinPrefs(pref_key, kPrefExplicitHosts),
       &explicit_hosts, Extension::kValidHostPermissionSchemes);
 
   // Retrieve the scriptable host permissions.
   URLPatternSet scriptable_hosts;
   ReadPrefAsURLPatternSet(
       extension_id, JoinPrefs(pref_key, kPrefScriptableHosts),
       &scriptable_hosts, UserScript::ValidUserScriptSchemes());
 
-  return make_scoped_ptr(new PermissionSet(apis, manifest_permissions,
-                                           explicit_hosts, scriptable_hosts));
+  return base::WrapUnique(new PermissionSet(apis, manifest_permissions,
+                                            explicit_hosts, scriptable_hosts));
 }
 
 // Set the API or Manifest permissions.
 // The format of api_values is:
 // [ "permission_name1",   // permissions do not support detail.
 //   "permission_name2",
 //   {"permission_name3": value },
 //   // permission supports detail, permission detail will be stored in value.
 //   ...
 // ]
 template<typename T>
 static base::ListValue* CreatePermissionList(const T& permissions) {
   base::ListValue* values = new base::ListValue();
   for (typename T::const_iterator i = permissions.begin();
       i != permissions.end(); ++i) {
-    scoped_ptr<base::Value> detail(i->ToValue());
+    std::unique_ptr<base::Value> detail(i->ToValue());
     if (detail) {
       base::DictionaryValue* tmp = new base::DictionaryValue();
       tmp->Set(i->name(), detail.release());
       values->Append(tmp);
     } else {
       values->Append(new base::StringValue(i->name()));
     }
   }
   return values;
 }
@@ skipping 309 matching lines @@
     return result;
   return false;
 }
 
 void ExtensionPrefs::SetActiveBit(const std::string& extension_id,
                                   bool active) {
   UpdateExtensionPref(extension_id, kActiveBit,
                       new base::FundamentalValue(active));
 }
 
-scoped_ptr<const PermissionSet> ExtensionPrefs::GetGrantedPermissions(
+std::unique_ptr<const PermissionSet> ExtensionPrefs::GetGrantedPermissions(
     const std::string& extension_id) const {
   CHECK(crx_file::id_util::IdIsValid(extension_id));
   return ReadPrefAsPermissionSet(extension_id, kPrefGrantedPermissions);
 }
 
 void ExtensionPrefs::AddGrantedPermissions(const std::string& extension_id,
                                            const PermissionSet& permissions) {
   CHECK(crx_file::id_util::IdIsValid(extension_id));
-  scoped_ptr<const PermissionSet> granted = GetGrantedPermissions(extension_id);
-  scoped_ptr<const PermissionSet> union_set;
+  std::unique_ptr<const PermissionSet> granted =
+      GetGrantedPermissions(extension_id);
+  std::unique_ptr<const PermissionSet> union_set;
   if (granted)
     union_set = PermissionSet::CreateUnion(permissions, *granted);
   // The new granted permissions are the union of the already granted
   // permissions and the newly granted permissions.
   SetExtensionPrefPermissionSet(extension_id, kPrefGrantedPermissions,
                                 union_set ? *union_set : permissions);
 }
 
 void ExtensionPrefs::RemoveGrantedPermissions(
     const std::string& extension_id,
     const PermissionSet& permissions) {
   CHECK(crx_file::id_util::IdIsValid(extension_id));
 
   // The new granted permissions are the difference of the already granted
   // permissions and the newly ungranted permissions.
   SetExtensionPrefPermissionSet(
       extension_id, kPrefGrantedPermissions,
       *PermissionSet::CreateDifference(*GetGrantedPermissions(extension_id),
                                        permissions));
 }
 
-scoped_ptr<const PermissionSet> ExtensionPrefs::GetActivePermissions(
+std::unique_ptr<const PermissionSet> ExtensionPrefs::GetActivePermissions(
     const std::string& extension_id) const {
   CHECK(crx_file::id_util::IdIsValid(extension_id));
   return ReadPrefAsPermissionSet(extension_id, kPrefActivePermissions);
 }
 
 void ExtensionPrefs::SetActivePermissions(const std::string& extension_id,
                                           const PermissionSet& permissions) {
   SetExtensionPrefPermissionSet(
       extension_id, kPrefActivePermissions, permissions);
 }
@@ skipping 195 matching lines @@
     bool update_required =
         !extension_dict->GetDictionary(kPrefManifest, &old_manifest) ||
         !extension->manifest()->value()->Equals(old_manifest);
     if (update_required) {
       UpdateExtensionPref(extension->id(), kPrefManifest,
                           extension->manifest()->value()->DeepCopy());
     }
   }
 }
 
-scoped_ptr<ExtensionInfo> ExtensionPrefs::GetInstalledInfoHelper(
+std::unique_ptr<ExtensionInfo> ExtensionPrefs::GetInstalledInfoHelper(
     const std::string& extension_id,
     const base::DictionaryValue* extension) const {
   int location_value;
   if (!extension->GetInteger(kPrefLocation, &location_value))
-    return scoped_ptr<ExtensionInfo>();
+    return std::unique_ptr<ExtensionInfo>();
 
   Manifest::Location location = static_cast<Manifest::Location>(location_value);
   if (location == Manifest::COMPONENT) {
     // Component extensions are ignored. Component extensions may have data
     // saved in preferences, but they are already loaded at this point (by
     // ComponentLoader) and shouldn't be populated into the result of
     // GetInstalledExtensionsInfo, otherwise InstalledLoader would also want to
     // load them.
-    return scoped_ptr<ExtensionInfo>();
+    return std::unique_ptr<ExtensionInfo>();
   }
 
   // Only the following extension types have data saved in the preferences.
   if (location != Manifest::INTERNAL &&
       !Manifest::IsUnpackedLocation(location) &&
       !Manifest::IsExternalLocation(location)) {
     NOTREACHED();
-    return scoped_ptr<ExtensionInfo>();
+    return std::unique_ptr<ExtensionInfo>();
   }
 
   const base::DictionaryValue* manifest = NULL;
   if (!Manifest::IsUnpackedLocation(location) &&
       !extension->GetDictionary(kPrefManifest, &manifest)) {
     LOG(WARNING) << "Missing manifest for extension " << extension_id;
     // Just a warning for now.
   }
 
   base::FilePath::StringType path;
   if (!extension->GetString(kPrefPath, &path))
-    return scoped_ptr<ExtensionInfo>();
+    return std::unique_ptr<ExtensionInfo>();
 
   // Make path absolute. Most (but not all) extension types have relative paths.
   if (!base::FilePath(path).IsAbsolute())
     path = install_directory_.Append(path).value();
 
-  return scoped_ptr<ExtensionInfo>(new ExtensionInfo(
+  return std::unique_ptr<ExtensionInfo>(new ExtensionInfo(
       manifest, extension_id, base::FilePath(path), location));
 }
 
-scoped_ptr<ExtensionInfo> ExtensionPrefs::GetInstalledExtensionInfo(
+std::unique_ptr<ExtensionInfo> ExtensionPrefs::GetInstalledExtensionInfo(
     const std::string& extension_id) const {
   const base::DictionaryValue* ext = NULL;
   const base::DictionaryValue* extensions =
       prefs_->GetDictionary(pref_names::kExtensions);
   if (!extensions ||
       !extensions->GetDictionaryWithoutPathExpansion(extension_id, &ext))
-    return scoped_ptr<ExtensionInfo>();
+    return std::unique_ptr<ExtensionInfo>();
   int state_value;
   if (ext->GetInteger(kPrefState, &state_value) &&
       state_value == Extension::EXTERNAL_EXTENSION_UNINSTALLED) {
     LOG(WARNING) << "External extension with id " << extension_id
                  << " has been uninstalled by the user";
-    return scoped_ptr<ExtensionInfo>();
+    return std::unique_ptr<ExtensionInfo>();
   }
 
   return GetInstalledInfoHelper(extension_id, ext);
 }
 
-scoped_ptr<ExtensionPrefs::ExtensionsInfo>
+std::unique_ptr<ExtensionPrefs::ExtensionsInfo>
 ExtensionPrefs::GetInstalledExtensionsInfo() const {
-  scoped_ptr<ExtensionsInfo> extensions_info(new ExtensionsInfo);
+  std::unique_ptr<ExtensionsInfo> extensions_info(new ExtensionsInfo);
 
   const base::DictionaryValue* extensions =
       prefs_->GetDictionary(pref_names::kExtensions);
   for (base::DictionaryValue::Iterator extension_id(*extensions);
        !extension_id.IsAtEnd(); extension_id.Advance()) {
     if (!crx_file::id_util::IdIsValid(extension_id.key()))
       continue;
 
-    scoped_ptr<ExtensionInfo> info =
+    std::unique_ptr<ExtensionInfo> info =
         GetInstalledExtensionInfo(extension_id.key());
     if (info)
       extensions_info->push_back(linked_ptr<ExtensionInfo>(info.release()));
   }
 
   return extensions_info;
 }
 
-scoped_ptr<ExtensionPrefs::ExtensionsInfo>
+std::unique_ptr<ExtensionPrefs::ExtensionsInfo>
 ExtensionPrefs::GetUninstalledExtensionsInfo() const {
-  scoped_ptr<ExtensionsInfo> extensions_info(new ExtensionsInfo);
+  std::unique_ptr<ExtensionsInfo> extensions_info(new ExtensionsInfo);
 
   const base::DictionaryValue* extensions =
       prefs_->GetDictionary(pref_names::kExtensions);
   for (base::DictionaryValue::Iterator extension_id(*extensions);
        !extension_id.IsAtEnd(); extension_id.Advance()) {
     const base::DictionaryValue* ext = NULL;
     if (!crx_file::id_util::IdIsValid(extension_id.key()) ||
         !IsExternalExtensionUninstalled(extension_id.key()) ||
         !extension_id.value().GetAsDictionary(&ext))
       continue;
 
-    scoped_ptr<ExtensionInfo> info =
+    std::unique_ptr<ExtensionInfo> info =
         GetInstalledInfoHelper(extension_id.key(), ext);
     if (info)
       extensions_info->push_back(linked_ptr<ExtensionInfo>(info.release()));
   }
 
   return extensions_info;
 }
 
 void ExtensionPrefs::SetDelayedInstallInfo(
     const Extension* extension,
@@ skipping 67 matching lines @@
   // Commit the delayed install data.
   for (base::DictionaryValue::Iterator it(*pending_install_dict); !it.IsAtEnd();
        it.Advance()) {
     extension_dict->Set(it.key(), it.value().DeepCopy());
   }
   FinishExtensionInfoPrefs(extension_id, install_time, needs_sort_ordinal,
                            suggested_page_ordinal, extension_dict);
   return true;
 }
 
-scoped_ptr<ExtensionInfo> ExtensionPrefs::GetDelayedInstallInfo(
+std::unique_ptr<ExtensionInfo> ExtensionPrefs::GetDelayedInstallInfo(
     const std::string& extension_id) const {
   const base::DictionaryValue* extension_prefs =
       GetExtensionPref(extension_id);
   if (!extension_prefs)
-    return scoped_ptr<ExtensionInfo>();
+    return std::unique_ptr<ExtensionInfo>();
 
   const base::DictionaryValue* ext = NULL;
   if (!extension_prefs->GetDictionary(kDelayedInstallInfo, &ext))
-    return scoped_ptr<ExtensionInfo>();
+    return std::unique_ptr<ExtensionInfo>();
 
   return GetInstalledInfoHelper(extension_id, ext);
 }
 
 ExtensionPrefs::DelayReason ExtensionPrefs::GetDelayedInstallReason(
     const std::string& extension_id) const {
   const base::DictionaryValue* extension_prefs =
       GetExtensionPref(extension_id);
   if (!extension_prefs)
     return DELAY_REASON_NONE;
 
   const base::DictionaryValue* ext = NULL;
   if (!extension_prefs->GetDictionary(kDelayedInstallInfo, &ext))
     return DELAY_REASON_NONE;
 
   int delay_reason;
   if (!ext->GetInteger(kDelayedInstallReason, &delay_reason))
     return DELAY_REASON_NONE;
 
   return static_cast<DelayReason>(delay_reason);
 }
 
-scoped_ptr<ExtensionPrefs::ExtensionsInfo> ExtensionPrefs::
-    GetAllDelayedInstallInfo() const {
-  scoped_ptr<ExtensionsInfo> extensions_info(new ExtensionsInfo);
+std::unique_ptr<ExtensionPrefs::ExtensionsInfo>
+ExtensionPrefs::GetAllDelayedInstallInfo() const {
+  std::unique_ptr<ExtensionsInfo> extensions_info(new ExtensionsInfo);
 
   const base::DictionaryValue* extensions =
       prefs_->GetDictionary(pref_names::kExtensions);
   for (base::DictionaryValue::Iterator extension_id(*extensions);
        !extension_id.IsAtEnd(); extension_id.Advance()) {
     if (!crx_file::id_util::IdIsValid(extension_id.key()))
       continue;
 
-    scoped_ptr<ExtensionInfo> info = GetDelayedInstallInfo(extension_id.key());
+    std::unique_ptr<ExtensionInfo> info =
+        GetDelayedInstallInfo(extension_id.key());
     if (info)
       extensions_info->push_back(linked_ptr<ExtensionInfo>(info.release()));
   }
 
   return extensions_info;
 }
 
 bool ExtensionPrefs::WasAppDraggedByUser(
     const std::string& extension_id) const {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefUserDraggedApp);
@@ skipping 129 matching lines @@
       continue;
 
     if (extension_dict->HasKey(kPrefLastLaunchTime))
       extension_dict->Remove(kPrefLastLaunchTime, NULL);
   }
 }
 
 void ExtensionPrefs::GetExtensions(ExtensionIdList* out) const {
   CHECK(out);
 
-  scoped_ptr<ExtensionsInfo> extensions_info(GetInstalledExtensionsInfo());
+  std::unique_ptr<ExtensionsInfo> extensions_info(GetInstalledExtensionsInfo());
 
   for (size_t i = 0; i < extensions_info->size(); ++i) {
     ExtensionInfo* info = extensions_info->at(i).get();
     out->push_back(info->extension_id);
   }
 }
 
 // static
 ExtensionIdList ExtensionPrefs::GetExtensionsFrom(
     const PrefService* pref_service) {
@@ skipping 74 matching lines @@
 
   const base::DictionaryValue* ext = NULL;
   if (!extension_prefs->GetDictionary(kPrefGeometryCache, &ext))
     return NULL;
 
   return ext;
 }
 
 void ExtensionPrefs::SetGeometryCache(
     const std::string& extension_id,
-    scoped_ptr<base::DictionaryValue> cache) {
+    std::unique_ptr<base::DictionaryValue> cache) {
   UpdateExtensionPref(extension_id, kPrefGeometryCache, cache.release());
 }
 
 const base::DictionaryValue* ExtensionPrefs::GetInstallSignature() const {
   return prefs_->GetDictionary(kInstallSignature);
 }
 
 void ExtensionPrefs::SetInstallSignature(
     const base::DictionaryValue* signature) {
   if (signature) {
@@ skipping 40 matching lines @@
                                   bool needs_sync) {
   UpdateExtensionPref(extension_id, kPrefNeedsSync,
                       needs_sync ? new base::FundamentalValue(true) : nullptr);
 }
 
 ExtensionPrefs::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)
     : browser_context_(browser_context),
       prefs_(prefs),
       install_directory_(root_dir),
       extension_pref_value_map_(extension_pref_value_map),
       time_provider_(std::move(time_provider)),
       extensions_disabled_(extensions_disabled) {
   MakePathsRelative();
 
@@ skipping 232 matching lines @@
   extension_pref_value_map_->RegisterExtension(
       extension_id, install_time, is_enabled, is_incognito_enabled);
 
   FOR_EACH_OBSERVER(
       ExtensionPrefsObserver,
       observer_list_,
       OnExtensionRegistered(extension_id, install_time, is_enabled));
 }
 
 }  // namespace extensions