[storage/browser/fileapi] Replace MessageLoopProxy usage with ThreadTaskRunnerHandle

storage/browser/fileapi/file_system_operation_runner.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 "storage/browser/fileapi/file_system_operation_runner.h"
 
 #include "base/bind.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/stl_util.h"
+#include "base/thread_task_runner_handle.h"
 #include "net/url_request/url_request_context.h"
 #include "storage/browser/blob/blob_url_request_job_factory.h"
 #include "storage/browser/blob/shareable_file_reference.h"
 #include "storage/browser/fileapi/file_observers.h"
 #include "storage/browser/fileapi/file_stream_writer.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/file_system_operation.h"
 #include "storage/browser/fileapi/file_writer_delegate.h"
 
 namespace storage {
@@ skipping 487 matching lines @@
 FileSystemOperationRunner::FileSystemOperationRunner(
     FileSystemContext* file_system_context)
     : file_system_context_(file_system_context) {}
 
 void FileSystemOperationRunner::DidFinish(
     const OperationHandle& handle,
     const StatusCallback& callback,
     base::File::Error rv) {
   if (handle.scope) {
     finished_operations_.insert(handle.id);
-    base::MessageLoopProxy::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&FileSystemOperationRunner::DidFinish,
                               AsWeakPtr(), handle, callback, rv));
     return;
   }
   callback.Run(rv);
   FinishOperation(handle.id);
 }
 
 void FileSystemOperationRunner::DidGetMetadata(
     const OperationHandle& handle,
     const GetMetadataCallback& callback,
     base::File::Error rv,
     const base::File::Info& file_info) {
   if (handle.scope) {
     finished_operations_.insert(handle.id);
-    base::MessageLoopProxy::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&FileSystemOperationRunner::DidGetMetadata,
                               AsWeakPtr(), handle, callback, rv, file_info));
     return;
   }
   callback.Run(rv, file_info);
   FinishOperation(handle.id);
 }
 
 void FileSystemOperationRunner::DidReadDirectory(
     const OperationHandle& handle,
     const ReadDirectoryCallback& callback,
     base::File::Error rv,
     const std::vector<DirectoryEntry>& entries,
     bool has_more) {
   if (handle.scope) {
     finished_operations_.insert(handle.id);
-    base::MessageLoopProxy::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&FileSystemOperationRunner::DidReadDirectory,
                               AsWeakPtr(), handle, callback, rv,
                               entries, has_more));
     return;
   }
   callback.Run(rv, entries, has_more);
   if (rv != base::File::FILE_OK || !has_more)
     FinishOperation(handle.id);
 }
 
 void FileSystemOperationRunner::DidWrite(
     const OperationHandle& handle,
     const WriteCallback& callback,
     base::File::Error rv,
     int64 bytes,
     bool complete) {
   if (handle.scope) {
     finished_operations_.insert(handle.id);
-    base::MessageLoopProxy::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&FileSystemOperationRunner::DidWrite, AsWeakPtr(),
                               handle, callback, rv, bytes, complete));
     return;
   }
   callback.Run(rv, bytes, complete);
   if (rv != base::File::FILE_OK || complete)
     FinishOperation(handle.id);
 }
 
 void FileSystemOperationRunner::DidOpenFile(
     const OperationHandle& handle,
     const OpenFileCallback& callback,
     base::File file,
     const base::Closure& on_close_callback) {
   if (handle.scope) {
     finished_operations_.insert(handle.id);
-    base::MessageLoopProxy::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&FileSystemOperationRunner::DidOpenFile,
                               AsWeakPtr(), handle, callback, Passed(&file),
                               on_close_callback));
     return;
   }
   callback.Run(file.Pass(), on_close_callback);
   FinishOperation(handle.id);
 }
 
 void FileSystemOperationRunner::DidCreateSnapshot(
     const OperationHandle& handle,
     const SnapshotFileCallback& callback,
     base::File::Error rv,
     const base::File::Info& file_info,
     const base::FilePath& platform_path,
     const scoped_refptr<storage::ShareableFileReference>& file_ref) {
   if (handle.scope) {
     finished_operations_.insert(handle.id);
-    base::MessageLoopProxy::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&FileSystemOperationRunner::DidCreateSnapshot,
                               AsWeakPtr(), handle, callback, rv, file_info,
                               platform_path, file_ref));
     return;
   }
   callback.Run(rv, file_info, platform_path, file_ref);
   FinishOperation(handle.id);
 }
 
 void FileSystemOperationRunner::OnCopyProgress(
     const OperationHandle& handle,
     const CopyProgressCallback& callback,
     FileSystemOperation::CopyProgressType type,
     const FileSystemURL& source_url,
     const FileSystemURL& dest_url,
     int64 size) {
   if (handle.scope) {
-    base::MessageLoopProxy::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(
             &FileSystemOperationRunner::OnCopyProgress,
             AsWeakPtr(), handle, callback, type, source_url, dest_url, size));
     return;
   }
   callback.Run(type, source_url, dest_url, size);
 }
 
 void FileSystemOperationRunner::PrepareForWrite(OperationID id,
                                                 const FileSystemURL& url) {
@@ skipping 47 matching lines @@
       stray_cancel_callbacks_.find(id);
   if (found_cancel != stray_cancel_callbacks_.end()) {
     // This cancel has been requested after the operation has finished,
     // so report that we failed to stop it.
     found_cancel->second.Run(base::File::FILE_ERROR_INVALID_OPERATION);
     stray_cancel_callbacks_.erase(found_cancel);
   }
 }
 
 }  // namespace storage