fileapi: Use standard task-runner to run the fileapi callbacks.

content/child/fileapi/webfilesystem_impl.cc

 // Copyright 2013 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 "content/child/fileapi/webfilesystem_impl.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_local.h"
 #include "content/child/child_thread_impl.h"
 #include "content/child/file_info_util.h"
 #include "content/child/fileapi/file_system_dispatcher.h"
 #include "content/child/fileapi/webfilewriter_impl.h"
-#include "content/child/worker_task_runner.h"
 #include "content/common/fileapi/file_system_messages.h"
 #include "storage/common/fileapi/directory_entry.h"
 #include "storage/common/fileapi/file_system_util.h"
 #include "third_party/WebKit/public/platform/WebFileInfo.h"
 #include "third_party/WebKit/public/platform/WebFileSystemCallbacks.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebHeap.h"
 #include "url/gurl.h"
 
@@ skipping 55 matching lines @@
 
 base::LazyInstance<base::ThreadLocalPointer<WebFileSystemImpl> >::Leaky
     g_webfilesystem_tls = LAZY_INSTANCE_INITIALIZER;
 
 void DidReceiveSnapshotFile(int request_id) {
   if (ChildThreadImpl::current())
     ChildThreadImpl::current()->Send(
         new FileSystemHostMsg_DidReceiveSnapshotFile(request_id));
 }
 
-int CurrentWorkerId() {
-  return WorkerTaskRunner::Instance()->CurrentWorkerId();
-}
-
 template <typename Method, typename Params>
 void CallDispatcherOnMainThread(
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread_task_runner,
     Method method, const Params& params,
     WaitableCallbackResults* waitable_results) {
   if (!main_thread_task_runner->RunsTasksOnCurrentThread()) {
     main_thread_task_runner->PostTask(
         FROM_HERE,
         base::Bind(&CallDispatcherOnMainThread<Method, Params>,
                    main_thread_task_runner, method, params,
@@ skipping 76 matching lines @@
   WebFileSystemImpl* filesystem =
       WebFileSystemImpl::ThreadSpecificInstance(NULL);
   if (!filesystem)
     return;
   WebFileSystemCallbacks callbacks = filesystem->GetCallbacks(callbacks_id);
   if (callbacks_unregister_mode == UNREGISTER_CALLBACKS)
     filesystem->UnregisterCallbacks(callbacks_id);
   callback.Run(&callbacks);
 }
 
-void DispatchResultsClosure(int thread_id, int callbacks_id,
-                            WaitableCallbackResults* waitable_results,
-                            const base::Closure& results_closure) {
-  if (thread_id != CurrentWorkerId()) {
-    if (waitable_results) {
-      // If someone is waiting, this should result in running the closure.
-      waitable_results->AddResultsAndSignal(results_closure);
-      // In case no one is waiting, post a task to run the closure.
-      WorkerTaskRunner::Instance()->PostTask(
-          thread_id,
-          base::Bind(&WaitableCallbackResults::Run,
-                     make_scoped_refptr(waitable_results)));
-      return;
-    }
-    WorkerTaskRunner::Instance()->PostTask(thread_id, results_closure);
+void DispatchResultsClosure(
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    int callbacks_id,
+    WaitableCallbackResults* waitable_results,
+    const base::Closure& results_closure) {
+  if (task_runner->BelongsToCurrentThread()) {
+    results_closure.Run();
     return;
   }
-  results_closure.Run();
+
+  if (waitable_results) {
+    // If someone is waiting, this should result in running the closure.
+    waitable_results->AddResultsAndSignal(results_closure);
+    // In case no one is waiting, post a task to run the closure.
+    task_runner->PostTask(FROM_HERE,
+                          base::Bind(&WaitableCallbackResults::Run,
+                                     make_scoped_refptr(waitable_results)));
+    return;
+  }
+  task_runner->PostTask(FROM_HERE, results_closure);
 }
 
 void CallbackFileSystemCallbacks(
-    int thread_id, int callbacks_id,
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    int callbacks_id,
     WaitableCallbackResults* waitable_results,
     const base::Callback<void(WebFileSystemCallbacks*)>& callback,
     CallbacksUnregisterMode callbacksunregister_mode) {
-  DispatchResultsClosure(
-      thread_id, callbacks_id, waitable_results,
-      base::Bind(&RunCallbacks, callbacks_id, callback,
-                 callbacksunregister_mode));
+  DispatchResultsClosure(task_runner, callbacks_id, waitable_results,
+                         base::Bind(&RunCallbacks, callbacks_id, callback,
+                                    callbacksunregister_mode));
 }
 
 //-----------------------------------------------------------------------------
 // Callback adapters. Callbacks must be called on the original calling thread,
 // so these callback adapters relay back the results to the calling thread
 // if necessary.
 
 void OpenFileSystemCallbackAdapter(
-    int thread_id, int callbacks_id,
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    int callbacks_id,
     WaitableCallbackResults* waitable_results,
-    const std::string& name, const GURL& root) {
+    const std::string& name,
+    const GURL& root) {
   CallbackFileSystemCallbacks(
-      thread_id, callbacks_id, waitable_results,
+      task_runner, callbacks_id, waitable_results,
       base::Bind(&DidOpenFileSystem, base::UTF8ToUTF16(name), root),
       UNREGISTER_CALLBACKS);
 }
 
-void ResolveURLCallbackAdapter(int thread_id,
-                               int callbacks_id,
-                               WaitableCallbackResults* waitable_results,
-                               const storage::FileSystemInfo& info,
-                               const base::FilePath& file_path,
-                               bool is_directory) {
+void ResolveURLCallbackAdapter(
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    int callbacks_id,
+    WaitableCallbackResults* waitable_results,
+    const storage::FileSystemInfo& info,
+    const base::FilePath& file_path,
+    bool is_directory) {
   base::FilePath normalized_path(
       storage::VirtualPath::GetNormalizedFilePath(file_path));
   CallbackFileSystemCallbacks(
-      thread_id, callbacks_id, waitable_results,
+      task_runner, callbacks_id, waitable_results,
       base::Bind(&DidResolveURL, base::UTF8ToUTF16(info.name), info.root_url,
-                 info.mount_type,
-                 normalized_path.AsUTF16Unsafe(), is_directory),
+                 info.mount_type, normalized_path.AsUTF16Unsafe(),
+                 is_directory),
       UNREGISTER_CALLBACKS);
 }
 
-void StatusCallbackAdapter(int thread_id, int callbacks_id,
-                           WaitableCallbackResults* waitable_results,
-                           base::File::Error error) {
+void StatusCallbackAdapter(
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    int callbacks_id,
+    WaitableCallbackResults* waitable_results,
+    base::File::Error error) {
   if (error == base::File::FILE_OK) {
-    CallbackFileSystemCallbacks(
-        thread_id, callbacks_id, waitable_results,
-        base::Bind(&DidSucceed),
-        UNREGISTER_CALLBACKS);
+    CallbackFileSystemCallbacks(task_runner, callbacks_id, waitable_results,
+                                base::Bind(&DidSucceed), UNREGISTER_CALLBACKS);
   } else {
-    CallbackFileSystemCallbacks(
-        thread_id, callbacks_id, waitable_results,
-        base::Bind(&DidFail, error),
-        UNREGISTER_CALLBACKS);
+    CallbackFileSystemCallbacks(task_runner, callbacks_id, waitable_results,
+                                base::Bind(&DidFail, error),
+                                UNREGISTER_CALLBACKS);
   }
 }
 
-void ReadMetadataCallbackAdapter(int thread_id, int callbacks_id,
-                                 WaitableCallbackResults* waitable_results,
-                                 const base::File::Info& file_info) {
-  CallbackFileSystemCallbacks(
-      thread_id, callbacks_id, waitable_results,
-      base::Bind(&DidReadMetadata, file_info),
-      UNREGISTER_CALLBACKS);
+void ReadMetadataCallbackAdapter(
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    int callbacks_id,
+    WaitableCallbackResults* waitable_results,
+    const base::File::Info& file_info) {
+  CallbackFileSystemCallbacks(task_runner, callbacks_id, waitable_results,
+                              base::Bind(&DidReadMetadata, file_info),
+                              UNREGISTER_CALLBACKS);
 }
 
 void ReadDirectoryCallbackAdapter(
-    int thread_id,
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     int callbacks_id,
     WaitableCallbackResults* waitable_results,
     const std::vector<storage::DirectoryEntry>& entries,
     bool has_more) {
   CallbackFileSystemCallbacks(
-      thread_id, callbacks_id, waitable_results,
+      task_runner, callbacks_id, waitable_results,
       base::Bind(&DidReadDirectory, entries, has_more),
       has_more ? DO_NOT_UNREGISTER_CALLBACKS : UNREGISTER_CALLBACKS);
 }
 
 void DidCreateFileWriter(
     int callbacks_id,
     const GURL& path,
     blink::WebFileWriterClient* client,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread_task_runner,
     const base::File::Info& file_info) {
@@ skipping 11 matching lines @@
   }
   WebFileWriterImpl::Type type =
       callbacks.shouldBlockUntilCompletion() ?
           WebFileWriterImpl::TYPE_SYNC : WebFileWriterImpl::TYPE_ASYNC;
   callbacks.didCreateFileWriter(
       new WebFileWriterImpl(path, client, type, main_thread_task_runner),
       file_info.size);
 }
 
 void CreateFileWriterCallbackAdapter(
-    int thread_id, int callbacks_id,
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    int callbacks_id,
     WaitableCallbackResults* waitable_results,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread_task_runner,
     const GURL& path,
     blink::WebFileWriterClient* client,
     const base::File::Info& file_info) {
   DispatchResultsClosure(
-      thread_id, callbacks_id, waitable_results,
+      task_runner, callbacks_id, waitable_results,
       base::Bind(&DidCreateFileWriter, callbacks_id, path, client,
                  main_thread_task_runner, file_info));
 }
 
 void DidCreateSnapshotFile(
     int callbacks_id,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread_task_runner,
     const base::File::Info& file_info,
     const base::FilePath& platform_path,
     int request_id) {
@@ skipping 10 matching lines @@
   web_file_info.platformPath = platform_path.AsUTF16Unsafe();
   callbacks.didCreateSnapshotFile(web_file_info);
 
   // TODO(michaeln,kinuko): Use ThreadSafeSender when Blob becomes
   // non-bridge model.
   main_thread_task_runner->PostTask(
       FROM_HERE, base::Bind(&DidReceiveSnapshotFile, request_id));
 }
 
 void CreateSnapshotFileCallbackAdapter(
-    int thread_id, int callbacks_id,
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    int callbacks_id,
     WaitableCallbackResults* waitable_results,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread_task_runner,
     const base::File::Info& file_info,
     const base::FilePath& platform_path,
     int request_id) {
   DispatchResultsClosure(
-      thread_id, callbacks_id, waitable_results,
+      task_runner, callbacks_id, waitable_results,
       base::Bind(&DidCreateSnapshotFile, callbacks_id, main_thread_task_runner,
                  file_info, platform_path, request_id));
 }
 
 }  // namespace
 
 //-----------------------------------------------------------------------------
 // WebFileSystemImpl
 
 WebFileSystemImpl* WebFileSystemImpl::ThreadSpecificInstance(
@@ skipping 30 matching lines @@
 }
 
 void WebFileSystemImpl::openFileSystem(
     const blink::WebURL& storage_partition,
     blink::WebFileSystemType type,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
-      main_thread_task_runner_,
-      &FileSystemDispatcher::OpenFileSystem,
+      main_thread_task_runner_, &FileSystemDispatcher::OpenFileSystem,
       MakeTuple(GURL(storage_partition),
                 static_cast<storage::FileSystemType>(type),
                 base::Bind(&OpenFileSystemCallbackAdapter,
-                           CurrentWorkerId(),
-                           callbacks_id,
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
                            waitable_results),
                 base::Bind(&StatusCallbackAdapter,
-                           CurrentWorkerId(),
-                           callbacks_id,
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
                            waitable_results)),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::resolveURL(
     const blink::WebURL& filesystem_url,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
-      main_thread_task_runner_,
-      &FileSystemDispatcher::ResolveURL,
+      main_thread_task_runner_, &FileSystemDispatcher::ResolveURL,
       MakeTuple(GURL(filesystem_url),
                 base::Bind(&ResolveURLCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results),
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                           waitable_results),
                 base::Bind(&StatusCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results)),
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                           waitable_results)),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::deleteFileSystem(
     const blink::WebURL& storage_partition,
     blink::WebFileSystemType type,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
-      main_thread_task_runner_,
-      &FileSystemDispatcher::DeleteFileSystem,
+      main_thread_task_runner_, &FileSystemDispatcher::DeleteFileSystem,
       MakeTuple(GURL(storage_partition),
                 static_cast<storage::FileSystemType>(type),
                 base::Bind(&StatusCallbackAdapter,
-                           CurrentWorkerId(),
-                           callbacks_id,
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
                            waitable_results)),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::move(
     const blink::WebURL& src_path,
     const blink::WebURL& dest_path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
-      main_thread_task_runner_,
-      &FileSystemDispatcher::Move,
+      main_thread_task_runner_, &FileSystemDispatcher::Move,
       MakeTuple(GURL(src_path), GURL(dest_path),
                 base::Bind(&StatusCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results)),
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                           waitable_results)),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::copy(
     const blink::WebURL& src_path,
     const blink::WebURL& dest_path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
-      main_thread_task_runner_,
-      &FileSystemDispatcher::Copy,
+      main_thread_task_runner_, &FileSystemDispatcher::Copy,
       MakeTuple(GURL(src_path), GURL(dest_path),
                 base::Bind(&StatusCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results)),
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                           waitable_results)),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::remove(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
-      main_thread_task_runner_,
-      &FileSystemDispatcher::Remove,
+      main_thread_task_runner_, &FileSystemDispatcher::Remove,
       MakeTuple(GURL(path), false /* recursive */,
                 base::Bind(&StatusCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results)),
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                           waitable_results)),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::removeRecursively(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
-      main_thread_task_runner_,
-      &FileSystemDispatcher::Remove,
+      main_thread_task_runner_, &FileSystemDispatcher::Remove,
       MakeTuple(GURL(path), true /* recursive */,
                 base::Bind(&StatusCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results)),
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                           waitable_results)),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::readMetadata(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
-      main_thread_task_runner_,
-      &FileSystemDispatcher::ReadMetadata,
-      MakeTuple(GURL(path),
-                base::Bind(&ReadMetadataCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results),
+      main_thread_task_runner_, &FileSystemDispatcher::ReadMetadata,
+      MakeTuple(GURL(path), base::Bind(&ReadMetadataCallbackAdapter,
+                                       base::ThreadTaskRunnerHandle::Get(),
+                                       callbacks_id, waitable_results),
                 base::Bind(&StatusCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results)),
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                           waitable_results)),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::createFile(
     const blink::WebURL& path,
     bool exclusive,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
-      main_thread_task_runner_,
-      &FileSystemDispatcher::CreateFile,
+      main_thread_task_runner_, &FileSystemDispatcher::CreateFile,
       MakeTuple(GURL(path), exclusive,
                 base::Bind(&StatusCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results)),
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                           waitable_results)),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::createDirectory(
     const blink::WebURL& path,
     bool exclusive,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
-      main_thread_task_runner_,
-      &FileSystemDispatcher::CreateDirectory,
+      main_thread_task_runner_, &FileSystemDispatcher::CreateDirectory,
       MakeTuple(GURL(path), exclusive, false /* recursive */,
                 base::Bind(&StatusCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results)),
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                           waitable_results)),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::fileExists(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
-      main_thread_task_runner_,
-      &FileSystemDispatcher::Exists,
+      main_thread_task_runner_, &FileSystemDispatcher::Exists,
       MakeTuple(GURL(path), false /* directory */,
                 base::Bind(&StatusCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results)),
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                           waitable_results)),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::directoryExists(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
-      main_thread_task_runner_,
-      &FileSystemDispatcher::Exists,
+      main_thread_task_runner_, &FileSystemDispatcher::Exists,
       MakeTuple(GURL(path), true /* directory */,
                 base::Bind(&StatusCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results)),
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                           waitable_results)),
       waitable_results.get());
 }
 
 int WebFileSystemImpl::readDirectory(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
-      main_thread_task_runner_,
-      &FileSystemDispatcher::ReadDirectory,
-      MakeTuple(GURL(path),
-                base::Bind(&ReadDirectoryCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results),
+      main_thread_task_runner_, &FileSystemDispatcher::ReadDirectory,
+      MakeTuple(GURL(path), base::Bind(&ReadDirectoryCallbackAdapter,
+                                       base::ThreadTaskRunnerHandle::Get(),
+                                       callbacks_id, waitable_results),
                 base::Bind(&StatusCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results)),
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                           waitable_results)),
       waitable_results.get());
   return callbacks_id;
 }
 
 void WebFileSystemImpl::createFileWriter(
     const WebURL& path,
     blink::WebFileWriterClient* client,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
-      main_thread_task_runner_,
-      &FileSystemDispatcher::ReadMetadata,
+      main_thread_task_runner_, &FileSystemDispatcher::ReadMetadata,
       MakeTuple(GURL(path),
                 base::Bind(&CreateFileWriterCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results,
-                           main_thread_task_runner_, GURL(path), client),
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                           waitable_results, main_thread_task_runner_,
+                           GURL(path), client),
                 base::Bind(&StatusCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results)),
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                           waitable_results)),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::createSnapshotFileAndReadMetadata(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
-      main_thread_task_runner_,
-      &FileSystemDispatcher::CreateSnapshotFile,
+      main_thread_task_runner_, &FileSystemDispatcher::CreateSnapshotFile,
       MakeTuple(GURL(path),
                 base::Bind(&CreateSnapshotFileCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results,
-                           main_thread_task_runner_),
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                           waitable_results, main_thread_task_runner_),
                 base::Bind(&StatusCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results)),
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                           waitable_results)),
       waitable_results.get());
 }
 
 bool WebFileSystemImpl::waitForAdditionalResult(int callbacksId) {
   WaitableCallbackResultsMap::iterator found =
       waitable_results_.find(callbacksId);
   if (found == waitable_results_.end())
     return false;
 
   found->second->WaitAndRun();
@@ skipping 27 matching lines @@
 WaitableCallbackResults* WebFileSystemImpl::MaybeCreateWaitableResults(
     const WebFileSystemCallbacks& callbacks, int callbacks_id) {
   if (!callbacks.shouldBlockUntilCompletion())
     return NULL;
   WaitableCallbackResults* results = new WaitableCallbackResults();
   waitable_results_[callbacks_id] = results;
   return results;
 }
 
 }  // namespace content