Switch browser/extensions/api/file_system/file_system_api.[h|cc] to the TaskScheduler API

chrome/browser/extensions/api/file_system/file_system_api.cc

 // Copyright (c) 2012 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 "chrome/browser/extensions/api/file_system/file_system_api.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
@@ skipping 488 matching lines @@
   }
 
   file_path = path_util::PrettifyPath(file_path);
   return RespondNow(
       OneArgument(base::MakeUnique<base::Value>(file_path.value())));
 }
 
 FileSystemEntryFunction::FileSystemEntryFunction()
     : multiple_(false), is_directory_(false) {}
 
+FileSystemEntryFunction::~FileSystemEntryFunction() {}
+
 void FileSystemEntryFunction::PrepareFilesForWritableApp(
     const std::vector<base::FilePath>& paths) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   // TODO(cmihail): Path directory set should be initialized only with the
   // paths that are actually directories, but for now we will consider
   // all paths directories in case is_directory_ is true, otherwise
   // all paths files, as this was the previous logic.
   std::set<base::FilePath> path_directory_set_ =
       is_directory_ ? std::set<base::FilePath>(paths.begin(), paths.end())
                     : std::set<base::FilePath>{};
@@ skipping 65 matching lines @@
   if (!app_file_handler_util::HasFileSystemWritePermission(extension_.get())) {
     error_ = kRequiresFileSystemWriteError;
     return false;
   }
 
   if (!app_file_handler_util::ValidateFileEntryAndGetPath(
           filesystem_name, filesystem_path,
           render_frame_host()->GetProcess()->GetID(), &path_, &error_))
     return false;
 
-  content::BrowserThread::PostTaskAndReply(
-      content::BrowserThread::FILE, FROM_HERE,
+  task_runner_->PostTaskAndReply(

[fdoray, 2017/05/16 15:23:26]

Unless RunAsync() is invoked multiple times on the same instance and it is
important to have mutual exclusion between calls to
SetIsDirectoryOnFileThread(), I don't think we need a sequence here.

You could simply write:

base::PostTaskWithTraitsAndReply(
  FROM_HERE,
  {base::MayBlock(), base::TaskPriority::BACKGROUND},
  base::BindOnce(&FileSystem...),
  base::BindOnce(&FileSystem...));

You can ask owners to confirm whether this is ok.

[Sébastien Marchand, 2017/05/16 15:53:09]

SGTM, I'll check with the owner to make sure that it's fine to run this in
parallel.

+      FROM_HERE,
       base::BindOnce(
           &FileSystemGetWritableEntryFunction::SetIsDirectoryOnFileThread,

[fdoray, 2017/05/16 15:23:26]

s/OnFileThread/Async/

[Sébastien Marchand, 2017/05/16 15:53:09]

Done.

           this),
       base::BindOnce(
           &FileSystemGetWritableEntryFunction::CheckPermissionAndSendResponse,
           this));
   return true;
 }
 
 void FileSystemGetWritableEntryFunction::CheckPermissionAndSendResponse() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (is_directory_ &&
       !extension_->permissions_data()->HasAPIPermission(
           APIPermission::kFileSystemDirectory)) {
     error_ = kRequiresFileSystemDirectoryError;
     SendResponse(false);
   }
   std::vector<base::FilePath> paths;
   paths.push_back(path_);
   PrepareFilesForWritableApp(paths);
 }
 
 void FileSystemGetWritableEntryFunction::SetIsDirectoryOnFileThread() {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   if (base::DirectoryExists(path_)) {
     is_directory_ = true;
   }
 }
 
 ExtensionFunction::ResponseAction FileSystemIsWritableEntryFunction::Run() {
   std::string filesystem_name;
   std::string filesystem_path;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &filesystem_name));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &filesystem_path));
@@ skipping 241 matching lines @@
       return;
     }
 
     DCHECK_EQ(paths.size(), 1u);
     bool non_native_path = false;
 #if defined(OS_CHROMEOS)
     non_native_path =
         file_manager::util::IsUnderNonNativeLocalPath(GetProfile(), paths[0]);
 #endif
 
-    content::BrowserThread::PostTask(
-        content::BrowserThread::FILE, FROM_HERE,
+    task_runner_->PostTask(

[fdoray, 2017/05/16 15:23:26]

ditto (a sequence may not be required)

[Sébastien Marchand, 2017/05/16 15:53:09]

Done.

+        FROM_HERE,
         base::BindOnce(
             &FileSystemChooseEntryFunction::ConfirmDirectoryAccessOnFileThread,
             this, non_native_path, paths, web_contents));
     return;
   }
 
   OnDirectoryAccessConfirmed(paths);
 }
 
 void FileSystemChooseEntryFunction::FileSelectionCanceled() {
@@ skipping 214 matching lines @@
 
 // Check whether the |previous_path| is a non-native directory.
 #if defined(OS_CHROMEOS)
   if (file_manager::util::IsUnderNonNativeLocalPath(GetProfile(),
                                                     previous_path)) {
     file_manager::util::IsNonNativeLocalPathDirectory(
         GetProfile(), previous_path, set_initial_path_callback);
     return true;
   }
 #endif
-  content::BrowserThread::PostTaskAndReplyWithResult(
-      content::BrowserThread::FILE, FROM_HERE,
+  base::PostTaskAndReplyWithResult(
+      task_runner_.get(), FROM_HERE,
       base::Bind(&base::DirectoryExists, previous_path),
       set_initial_path_callback);
 
   return true;
 }
 
 bool FileSystemRetainEntryFunction::RunAsync() {
   std::string entry_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &entry_id));
   SavedFilesService* saved_files_service = SavedFilesService::Get(GetProfile());
@@ skipping 304 matching lines @@
     return RespondNow(Error(kNotSupportedOnNonKioskSessionError));
   std::vector<api::file_system::Volume> result_volume_list;
   FillVolumeList(chrome_details_.GetProfile(), &result_volume_list);
 
   return RespondNow(ArgumentList(
       api::file_system::GetVolumeList::Results::Create(result_volume_list)));
 }
 #endif
 
 }  // namespace extensions