Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/extensions

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 159 matching lines @@
     if (!UsesManagedStorage(it->get()))
       to_remove = (*it)->id();
     ++it;
     if (!to_remove.empty())
       added->Remove(to_remove);
   }
 
   // Load the schema files in a background thread.
   BrowserThread::PostBlockingPoolSequencedTask(
       kLoadSchemasBackgroundTaskTokenName, FROM_HERE,
-      base::Bind(&ExtensionTracker::LoadSchemasOnBlockingPool,
-                 base::Passed(&added),
-                 weak_factory_.GetWeakPtr()));
+      base::BindOnce(&ExtensionTracker::LoadSchemasOnBlockingPool,
+                     base::Passed(&added), weak_factory_.GetWeakPtr()));
 }
 
 bool ManagedValueStoreCache::ExtensionTracker::UsesManagedStorage(
     const Extension* extension) const {
   return extension->manifest()->HasPath(manifest_keys::kStorageManagedSchema);
 }
 
 // static
 void ManagedValueStoreCache::ExtensionTracker::LoadSchemasOnBlockingPool(
     std::unique_ptr<ExtensionSet> extensions,
@@ skipping 16 matching lines @@
     policy::Schema schema =
         StorageSchemaManifestHandler::GetSchema(it->get(), &error);
     // If the schema is invalid then proceed with an empty schema. The extension
     // will be listed in chrome://policy but won't be able to load any policies.
     if (!schema.valid())
       schema = policy::Schema();
     (*components)[(*it)->id()] = schema;
   }
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                          base::Bind(&ExtensionTracker::Register, self,
-                                     base::Owned(components.release())));
+                          base::BindOnce(&ExtensionTracker::Register, self,
+                                         base::Owned(components.release())));
 }
 
 void ManagedValueStoreCache::ExtensionTracker::Register(
     const policy::ComponentMap* components) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   schema_registry_->RegisterComponents(policy_domain_, *components);
 
   // The first SetExtensionsDomainsReady() call is performed after the
   // ExtensionSystem is ready, even if there are no managed extensions. It will
   // trigger a loading of the initial policy for any managed extensions, and
@@ skipping 92 matching lines @@
 
   if (!policy_service_->IsInitializationComplete(policy_domain_)) {
     // OnPolicyUpdated is called whenever a policy changes, but it doesn't
     // mean that all the policy providers are ready; wait until we get the
     // final policy values before passing them to the store.
     return;
   }
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
-      base::Bind(&ManagedValueStoreCache::UpdatePolicyOnFILE,
-                 base::Unretained(this),
-                 ns.component_id,
-                 base::Passed(current.DeepCopy())));
+      base::BindOnce(&ManagedValueStoreCache::UpdatePolicyOnFILE,
+                     base::Unretained(this), ns.component_id,
+                     base::Passed(current.DeepCopy())));
 }
 
 // static
 policy::PolicyDomain ManagedValueStoreCache::GetPolicyDomain(Profile* profile) {
 #if defined(OS_CHROMEOS)
   return chromeos::ProfileHelper::IsSigninProfile(profile)
              ? policy::POLICY_DOMAIN_SIGNIN_EXTENSIONS
              : policy::POLICY_DOMAIN_EXTENSIONS;
 #else
   return policy::POLICY_DOMAIN_EXTENSIONS;
@@ skipping 35 matching lines @@
   return raw_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