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>
 #include <utility>
 #include <vector>
 
 #include "apps/saved_files_service.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/value_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/path_util.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/apps/directory_access_confirmation_dialog.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
@@ skipping 548 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,
-      base::BindOnce(
-          &FileSystemGetWritableEntryFunction::SetIsDirectoryOnFileThread,
-          this),
+  base::PostTaskWithTraitsAndReply(
+      FROM_HERE, {base::MayBlock(), base::TaskPriority::BACKGROUND},
+      base::BindOnce(&FileSystemGetWritableEntryFunction::SetIsDirectoryAsync,
+                     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);
+void FileSystemGetWritableEntryFunction::SetIsDirectoryAsync() {
   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,
+    base::PostTaskWithTraits(
+        FROM_HERE, {base::MayBlock(), base::TaskPriority::BACKGROUND},
         base::BindOnce(
             &FileSystemChooseEntryFunction::ConfirmDirectoryAccessOnFileThread,

[benwells, 2017/05/17 01:03:52]

Could you rename ConfirmDirectoryAccessOnFileThread while you're here?

[Sébastien Marchand, 2017/05/17 18:43:00]

Done.

             this, non_native_path, paths, web_contents));
     return;
   }
 
   OnDirectoryAccessConfirmed(paths);
 }
 
 void FileSystemChooseEntryFunction::FileSelectionCanceled() {
   error_ = kUserCancelled;
   SendResponse(false);
@@ skipping 212 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::PostTaskWithTraitsAndReplyWithResult(
+      FROM_HERE, {base::MayBlock(), base::TaskPriority::BACKGROUND},
       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