Migrate Extensions code to Task Scheduler API

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"
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_observer.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/extensions/api/storage/policy_value_store.h"
 #include "chrome/browser/policy/profile_policy_connector.h"
 #include "chrome/browser/policy/profile_policy_connector_factory.h"
 #include "chrome/browser/policy/schema_registry_service.h"
 #include "chrome/browser/policy/schema_registry_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/storage/storage_schema_manifest_handler.h"
 #include "components/policy/core/common/schema.h"
 #include "components/policy/core/common/schema_map.h"
 #include "components/policy/core/common/schema_registry.h"
 #include "content/public/browser/browser_thread.h"
+#include "extensions/browser/api/storage/backend_task_runner.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_registry_observer.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/value_store/value_store_change.h"
 #include "extensions/browser/value_store/value_store_factory.h"
 #include "extensions/common/api/storage.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
@@ skipping 213 matching lines @@
 
   policy_service_->AddObserver(policy_domain_, this);
 
   extension_tracker_.reset(new ExtensionTracker(profile_, policy_domain_));
 
   if (policy_service_->IsInitializationComplete(policy_domain_))
     OnPolicyServiceInitialized(policy_domain_);
 }
 
 ManagedValueStoreCache::~ManagedValueStoreCache() {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
   // Delete the PolicyValueStores on FILE.
   store_map_.clear();
 }
 
 void ManagedValueStoreCache::ShutdownOnUI() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   policy_service_->RemoveObserver(policy_domain_, this);
   extension_tracker_.reset();
 }
 
 void ManagedValueStoreCache::RunWithValueStoreForExtension(
     const StorageCallback& callback,
     scoped_refptr<const Extension> extension) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
   callback.Run(GetStoreFor(extension->id()));
 }
 
 void ManagedValueStoreCache::DeleteStorageSoon(
     const std::string& extension_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
   // It's possible that the store exists, but hasn't been loaded yet
   // (because the extension is unloaded, for example). Open the database to
   // clear it if it exists.
   if (!HasStore(extension_id))
     return;
   GetStoreFor(extension_id)->DeleteStorage();
   store_map_.erase(extension_id);
 }
 
 void ManagedValueStoreCache::OnPolicyServiceInitialized(
@@ skipping 27 matching lines @@
                                              const policy::PolicyMap& current) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   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::BindOnce(&ManagedValueStoreCache::UpdatePolicyOnFILE,
-                     base::Unretained(this), ns.component_id,
-                     base::Passed(current.DeepCopy())));
+  GetBackendTaskRunner()->PostTask(
+      FROM_HERE, base::BindOnce(&ManagedValueStoreCache::UpdatePolicyOnBackend,
+                                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;
 #endif
 }
 
-void ManagedValueStoreCache::UpdatePolicyOnFILE(
+void ManagedValueStoreCache::UpdatePolicyOnBackend(
     const std::string& extension_id,
     std::unique_ptr<policy::PolicyMap> current_policy) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
 
   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);
 }
 
 PolicyValueStore* ManagedValueStoreCache::GetStoreFor(
     const std::string& extension_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
 
   auto it = store_map_.find(extension_id);
   if (it != store_map_.end())
     return it->second.get();
 
   // Create the store now, and serve the cached policy until the PolicyService
   // sends updated values.
   std::unique_ptr<PolicyValueStore> store(new PolicyValueStore(
       extension_id, observers_,
       storage_factory_->CreateSettingsStore(settings_namespace::MANAGED,
                                             kManagedModelType, extension_id)));
   PolicyValueStore* raw_store = store.get();
   store_map_[extension_id] = std::move(store);
 
   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