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

content/child/fileapi/webfilewriter_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/webfilewriter_impl.h"
 
 #include "base/bind.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/thread_task_runner_handle.h"
 #include "content/child/child_thread_impl.h"
 #include "content/child/fileapi/file_system_dispatcher.h"
 #include "content/child/worker_task_runner.h"
 
 namespace content {
 
 namespace {
 
 FileSystemDispatcher* GetFileSystemDispatcher() {
   return ChildThreadImpl::current() ?
       ChildThreadImpl::current()->file_system_dispatcher() : NULL;
 }
 
 }  // namespace
 
 typedef FileSystemDispatcher::StatusCallback StatusCallback;
 typedef FileSystemDispatcher::WriteCallback WriteCallback;
 
 // This instance may be created outside main thread but runs mainly
 // on main thread.
 class WebFileWriterImpl::WriterBridge
     : public base::RefCountedThreadSafe<WriterBridge> {
  public:
   WriterBridge(WebFileWriterImpl::Type type)
       : request_id_(0),
-        thread_id_(WorkerTaskRunner::Instance()->CurrentWorkerId()),
+        running_on_worker_(WorkerTaskRunner::Instance()->CurrentWorkerId() > 0),
+        task_runner_(running_on_worker_ ? base::ThreadTaskRunnerHandle::Get()
+                                        : nullptr),
         written_bytes_(0) {
     if (type == WebFileWriterImpl::TYPE_SYNC)
       waitable_event_.reset(new base::WaitableEvent(false, false));
   }
 
   void Truncate(const GURL& path, int64 offset,
                 const StatusCallback& status_callback) {
     status_callback_ = status_callback;
     if (!GetFileSystemDispatcher())
       return;
@@ skipping 44 matching lines @@
       return;
     PostTaskToWorker(base::Bind(write_callback_, written_bytes_, complete));
   }
 
   void DidFinish(base::File::Error status) {
     PostTaskToWorker(base::Bind(status_callback_, status));
   }
 
   void PostTaskToWorker(const base::Closure& closure) {
     written_bytes_ = 0;
-    if (!thread_id_) {
+    if (!running_on_worker_) {
       DCHECK(!waitable_event_);
       closure.Run();
       return;
     }
+    DCHECK(task_runner_);
     if (waitable_event_) {
       results_closure_ = closure;
       waitable_event_->Signal();
       return;
     }
-    WorkerTaskRunner::Instance()->PostTask(thread_id_, closure);
+    task_runner_->PostTask(FROM_HERE, closure);
   }
 
   StatusCallback status_callback_;
   WriteCallback write_callback_;
   int request_id_;
-  int thread_id_;
+  const bool running_on_worker_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   int written_bytes_;
   scoped_ptr<base::WaitableEvent> waitable_event_;
   base::Closure results_closure_;
 };
 
 WebFileWriterImpl::WebFileWriterImpl(
      const GURL& path, blink::WebFileWriterClient* client,
      Type type,
      const scoped_refptr<base::SingleThreadTaskRunner>& main_thread_task_runner)
   : WebFileWriterBase(path, client),
@@ skipping 28 matching lines @@
     DCHECK(!bridge_->waitable_event());
     closure.Run();
     return;
   }
   main_thread_task_runner_->PostTask(FROM_HERE, closure);
   if (bridge_->waitable_event())
     bridge_->WaitAndRun();
 }
 
 }  // namespace content