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

chrome/browser/extensions/api/storage/managed_value_store_cache.cc

 // Copyright (c) 2012 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/extensions/api/storage/managed_value_store_cache.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 73 matching lines @@
                                   bool is_update,
                                   const std::string& old_name) override;
   void OnExtensionUninstalled(content::BrowserContext* browser_context,
                               const Extension* extension,
                               extensions::UninstallReason reason) override;
 
   // Handler for the signal from ExtensionSystem::ready().
   void OnExtensionsReady();
 
   // Starts a schema load for all extensions that use managed storage.
-  void LoadSchemas(scoped_ptr<ExtensionSet> added);
+  void LoadSchemas(std::unique_ptr<ExtensionSet> added);
 
   bool UsesManagedStorage(const Extension* extension) const;
 
   // Loads the schemas of the |extensions| and passes a ComponentMap to
   // Register().
-  static void LoadSchemasOnBlockingPool(scoped_ptr<ExtensionSet> extensions,
-                                        base::WeakPtr<ExtensionTracker> self);
+  static void LoadSchemasOnBlockingPool(
+      std::unique_ptr<ExtensionSet> extensions,
+      base::WeakPtr<ExtensionTracker> self);
   void Register(const policy::ComponentMap* components);
 
   Profile* profile_;
   ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
       extension_registry_observer_;
   policy::SchemaRegistry* schema_registry_;
   base::WeakPtrFactory<ExtensionTracker> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionTracker);
 };
@@ skipping 16 matching lines @@
     content::BrowserContext* browser_context,
     const Extension* extension,
     bool is_update,
     const std::string& old_name) {
   // Some extensions are installed on the first run before the ExtensionSystem
   // becomes ready. Wait until all of them are ready before registering the
   // schemas of managed extensions, so that the policy loaders are reloaded at
   // most once.
   if (!ExtensionSystem::Get(profile_)->ready().is_signaled())
     return;
-  scoped_ptr<ExtensionSet> added(new ExtensionSet);
+  std::unique_ptr<ExtensionSet> added(new ExtensionSet);
   added->Insert(extension);
   LoadSchemas(std::move(added));
 }
 
 void ManagedValueStoreCache::ExtensionTracker::OnExtensionUninstalled(
     content::BrowserContext* browser_context,
     const Extension* extension,
     extensions::UninstallReason reason) {
   if (!ExtensionSystem::Get(profile_)->ready().is_signaled())
     return;
   if (extension && UsesManagedStorage(extension)) {
     schema_registry_->UnregisterComponent(policy::PolicyNamespace(
         policy::POLICY_DOMAIN_EXTENSIONS, extension->id()));
   }
 }
 
 void ManagedValueStoreCache::ExtensionTracker::OnExtensionsReady() {
   // Load schemas for all installed extensions.
   LoadSchemas(
       ExtensionRegistry::Get(profile_)->GenerateInstalledExtensionsSet());
 }
 
 void ManagedValueStoreCache::ExtensionTracker::LoadSchemas(
-    scoped_ptr<ExtensionSet> added) {
+    std::unique_ptr<ExtensionSet> added) {
   // Filter out extensions that don't use managed storage.
   ExtensionSet::const_iterator it = added->begin();
   while (it != added->end()) {
     std::string to_remove;
     if (!UsesManagedStorage(it->get()))
       to_remove = (*it)->id();
     ++it;
     if (!to_remove.empty())
       added->Remove(to_remove);
   }
@@ skipping 10 matching lines @@
     const Extension* extension) const {
   if (extension->manifest()->HasPath(manifest_keys::kStorageManagedSchema))
     return true;
 
   // TODO(joaodasilva): remove this by M35.
   return extension->id() == kLegacyBrowserSupportExtensionId;
 }
 
 // static
 void ManagedValueStoreCache::ExtensionTracker::LoadSchemasOnBlockingPool(
-    scoped_ptr<ExtensionSet> extensions,
+    std::unique_ptr<ExtensionSet> extensions,
     base::WeakPtr<ExtensionTracker> self) {
   DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
-  scoped_ptr<policy::ComponentMap> components(new policy::ComponentMap);
+  std::unique_ptr<policy::ComponentMap> components(new policy::ComponentMap);
 
   for (ExtensionSet::const_iterator it = extensions->begin();
        it != extensions->end(); ++it) {
     std::string schema_file;
     if (!(*it)->manifest()->GetString(
             manifest_keys::kStorageManagedSchema, &schema_file)) {
       // TODO(joaodasilva): Remove this. http://crbug.com/325349
       (*components)[(*it)->id()] = policy::Schema();
       continue;
     }
@@ skipping 125 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&ManagedValueStoreCache::UpdatePolicyOnFILE,
                  base::Unretained(this),
                  ns.component_id,
                  base::Passed(current.DeepCopy())));
 }
 
 void ManagedValueStoreCache::UpdatePolicyOnFILE(
     const std::string& extension_id,
-    scoped_ptr<policy::PolicyMap> current_policy) {
+    std::unique_ptr<policy::PolicyMap> current_policy) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   if (!HasStore(extension_id) && current_policy->empty()) {
     // Don't create the store now if there are no policies configured for this
     // extension. If the extension uses the storage.managed API then the store
     // will be created at RunWithValueStoreForExtension().
     return;
   }
 
   GetStoreFor(extension_id)->SetCurrentPolicy(*current_policy);
@@ skipping 18 matching lines @@
   return store;
 }
 
 bool ManagedValueStoreCache::HasStore(const std::string& extension_id) const {
   // Note: Currently only manage extensions (not apps).
   return storage_factory_->HasSettings(settings_namespace::MANAGED,
                                        kManagedModelType, extension_id);
 }
 
 }  // namespace extensions