Migrate Extensions code to Task Scheduler API

extensions/browser/api/storage/storage_frontend.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/api/storage/storage_frontend.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/api/extensions_api_client.h"
+#include "extensions/browser/api/storage/backend_task_runner.h"
 #include "extensions/browser/api/storage/local_value_store_cache.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/value_store/value_store_factory.h"
 #include "extensions/common/api/storage.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 
@@ skipping 81 matching lines @@
   ExtensionsAPIClient::Get()->AddAdditionalValueStoreCaches(
       browser_context_, factory, observers_, &caches_);
 }
 
 StorageFrontend::~StorageFrontend() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observers_->RemoveObserver(browser_context_observer_.get());
   for (CacheMap::iterator it = caches_.begin(); it != caches_.end(); ++it) {
     ValueStoreCache* cache = it->second;
     cache->ShutdownOnUI();
-    BrowserThread::DeleteSoon(BrowserThread::FILE, FROM_HERE, cache);
+    GetBackendTaskRunner()->DeleteSoon(FROM_HERE, cache);
   }
 }
 
 ValueStoreCache* StorageFrontend::GetValueStoreCache(
     settings_namespace::Namespace settings_namespace) const {
   CacheMap::const_iterator it = caches_.find(settings_namespace);
   if (it != caches_.end())
     return it->second;
   return NULL;
 }
 
 bool StorageFrontend::IsStorageEnabled(
     settings_namespace::Namespace settings_namespace) const {
   return caches_.find(settings_namespace) != caches_.end();
 }
 
 void StorageFrontend::RunWithStorage(
     scoped_refptr<const Extension> extension,
     settings_namespace::Namespace settings_namespace,
     const ValueStoreCache::StorageCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   CHECK(extension.get());
 
   ValueStoreCache* cache = caches_[settings_namespace];
   CHECK(cache);
 
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(&ValueStoreCache::RunWithValueStoreForExtension,
-                 base::Unretained(cache), callback, extension));
+  GetBackendTaskRunner()->PostTask(
+      FROM_HERE, base::Bind(&ValueStoreCache::RunWithValueStoreForExtension,
+                            base::Unretained(cache), callback, extension));
 }
 
 void StorageFrontend::DeleteStorageSoon(const std::string& extension_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   for (CacheMap::iterator it = caches_.begin(); it != caches_.end(); ++it) {
     ValueStoreCache* cache = it->second;
-    BrowserThread::PostTask(
-        BrowserThread::FILE, FROM_HERE,
-        base::Bind(&ValueStoreCache::DeleteStorageSoon,
-                   base::Unretained(cache),
-                   extension_id));
+    GetBackendTaskRunner()->PostTask(
+        FROM_HERE, base::Bind(&ValueStoreCache::DeleteStorageSoon,
+                              base::Unretained(cache), extension_id));
   }
 }
 
 scoped_refptr<SettingsObserverList> StorageFrontend::GetObservers() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return observers_;
 }
 
 void StorageFrontend::DisableStorageForTesting(
     settings_namespace::Namespace settings_namespace) {
   CacheMap::iterator it = caches_.find(settings_namespace);
   if (it != caches_.end()) {
     ValueStoreCache* cache = it->second;
     cache->ShutdownOnUI();
-    BrowserThread::DeleteSoon(BrowserThread::FILE, FROM_HERE, cache);
+    GetBackendTaskRunner()->DeleteSoon(FROM_HERE, cache);
     caches_.erase(it);
   }
 }
 
 // BrowserContextKeyedAPI implementation.
 
 // static
 BrowserContextKeyedAPIFactory<StorageFrontend>*
 StorageFrontend::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 // static
 const char* StorageFrontend::service_name() { return "StorageFrontend"; }
 
 }  // namespace extensions