[storage] Replace MessageLoopProxy usage with ThreadTaskRunnerHandle

storage/browser/fileapi/async_file_util_adapter.cc

 // Copyright (c) 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/async_file_util_adapter.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/sequenced_task_runner.h"
@@ skipping 68 matching lines @@
   base::File::Error error_;
   base::File::Info file_info_;
   base::FilePath platform_path_;
   storage::ScopedFile scoped_file_;
   DISALLOW_COPY_AND_ASSIGN(GetFileInfoHelper);
 };
 
 void ReadDirectoryHelper(FileSystemFileUtil* file_util,
                          FileSystemOperationContext* context,
                          const FileSystemURL& url,
-                         base::SingleThreadTaskRunner* origin_loop,
+                         base::SingleThreadTaskRunner* origin_runner,
                          const AsyncFileUtil::ReadDirectoryCallback& callback) {
   base::File::Info file_info;
   base::FilePath platform_path;
   base::File::Error error = file_util->GetFileInfo(
       context, url, &file_info, &platform_path);
 
   if (error == base::File::FILE_OK && !file_info.is_directory)
     error = base::File::FILE_ERROR_NOT_A_DIRECTORY;
 
   std::vector<DirectoryEntry> entries;
   if (error != base::File::FILE_OK) {
-    origin_loop->PostTask(
+    origin_runner->PostTask(
         FROM_HERE, base::Bind(callback, error, entries, false /* has_more */));
     return;
   }
 
   // Note: Increasing this value may make some tests in LayoutTests meaningless.
   // (Namely, read-directory-many.html and read-directory-sync-many.html are
   // assuming that they are reading much more entries than this constant.)
   const size_t kResultChunkSize = 100;
 
   scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> file_enum(
       file_util->CreateFileEnumerator(context, url));
 
   base::FilePath current;
   while (!(current = file_enum->Next()).empty()) {
     DirectoryEntry entry;
     entry.is_directory = file_enum->IsDirectory();
     entry.name = VirtualPath::BaseName(current).value();
     entry.size = file_enum->Size();
     entry.last_modified_time = file_enum->LastModifiedTime();
     entries.push_back(entry);
 
     if (entries.size() == kResultChunkSize) {
-      origin_loop->PostTask(
+      origin_runner->PostTask(
           FROM_HERE, base::Bind(callback, base::File::FILE_OK, entries,
                                 true /* has_more */));
       entries.clear();
     }
   }
-  origin_loop->PostTask(
+  origin_runner->PostTask(
       FROM_HERE, base::Bind(callback, base::File::FILE_OK, entries,
                             false /* has_more */));
 }
 
 void RunCreateOrOpenCallback(
     FileSystemOperationContext* context,
     const AsyncFileUtil::CreateOrOpenCallback& callback,
     base::File file) {
   callback.Run(file.Pass(), base::Closure());
 }
@@ skipping 202 matching lines @@
   GetFileInfoHelper* helper = new GetFileInfoHelper;
   const bool success = context_ptr->task_runner()->PostTaskAndReply(
       FROM_HERE,
       Bind(&GetFileInfoHelper::CreateSnapshotFile, Unretained(helper),
            sync_file_util_.get(), base::Owned(context_ptr), url),
       Bind(&GetFileInfoHelper::ReplySnapshotFile, Owned(helper), callback));
   DCHECK(success);
 }
 
 }  // namespace storage