Use TaskScheduler instead of blocking pool in private_api_file_system.cc.

chrome/browser/chromeos/extensions/file_manager/private_api_file_system.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 "chrome/browser/chromeos/extensions/file_manager/private_api_file_system.h"
 
 #include <sys/statvfs.h>
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/extensions/file_manager/event_router.h"
 #include "chrome/browser/chromeos/extensions/file_manager/event_router_factory.h"
 #include "chrome/browser/chromeos/extensions/file_manager/file_stream_md5_digester.h"
 #include "chrome/browser/chromeos/extensions/file_manager/private_api_util.h"
 #include "chrome/browser/chromeos/file_manager/fileapi_util.h"
 #include "chrome/browser/chromeos/file_manager/path_util.h"
 #include "chrome/browser/chromeos/file_manager/volume_manager.h"
@@ skipping 33 matching lines @@
 using file_manager::util::EntryDefinition;
 using file_manager::util::FileDefinition;
 using storage::FileSystemURL;
 
 namespace extensions {
 namespace {
 
 const char kRootPath[] = "/";
 
 // Retrieves total and remaining available size on |mount_path|.
-void GetSizeStatsOnBlockingPool(const base::FilePath& mount_path,
-                                uint64_t* total_size,
-                                uint64_t* remaining_size) {
+void GetSizeStatsAsync(const base::FilePath& mount_path,
+                       uint64_t* total_size,
+                       uint64_t* remaining_size) {
   int64_t size = base::SysInfo::AmountOfTotalDiskSpace(mount_path);
   if (size >= 0)
     *total_size = size;
   size = base::SysInfo::AmountOfFreeDiskSpace(mount_path);
   if (size >= 0)
     *remaining_size = size;
 }
 
 // Retrieves the maximum file name length of the file system of |path|.
 // Returns 0 if it could not be queried.
-size_t GetFileNameMaxLengthOnBlockingPool(const std::string& path) {
+size_t GetFileNameMaxLengthAsync(const std::string& path) {
   struct statvfs stat = {};
   if (HANDLE_EINTR(statvfs(path.c_str(), &stat)) != 0) {
     // The filesystem seems not supporting statvfs(). Assume it to be a commonly
     // used bound 255, and log the failure.
     LOG(ERROR) << "Cannot statvfs() the name length limit for: " << path;
     return 255;
   }
   return stat.f_namemax;
 }
 
@@ skipping 340 matching lines @@
     device::MediaTransferProtocolManager* manager =
         storage_monitor->media_transfer_protocol_manager();
     manager->GetStorageInfoFromDevice(
         storage_name,
         base::Bind(
             &FileManagerPrivateGetSizeStatsFunction::OnGetMtpAvailableSpace,
             this));
   } else {
     uint64_t* total_size = new uint64_t(0);
     uint64_t* remaining_size = new uint64_t(0);
-    BrowserThread::PostBlockingPoolTaskAndReply(
-        FROM_HERE, base::Bind(&GetSizeStatsOnBlockingPool, volume->mount_path(),
-                              total_size, remaining_size),
+    base::PostTaskWithTraitsAndReply(
+        FROM_HERE, base::TaskTraits().MayBlock().WithPriority(
+                       base::TaskPriority::USER_VISIBLE),
+        base::Bind(&GetSizeStatsAsync, volume->mount_path(), total_size,
+                   remaining_size),
         base::Bind(&FileManagerPrivateGetSizeStatsFunction::OnGetSizeStats,
                    this, base::Owned(total_size), base::Owned(remaining_size)));
   }
   return true;
 }
 
 void FileManagerPrivateGetSizeStatsFunction::OnGetDriveAvailableSpace(
     drive::FileError error,
     int64_t bytes_total,
     int64_t bytes_used) {
@@ skipping 51 matching lines @@
   if (!chromeos::FileSystemBackend::CanHandleURL(file_system_url))
     return false;
 
   // No explicit limit on the length of Drive file names.
   if (file_system_url.type() == storage::kFileSystemTypeDrive) {
     SetResult(base::MakeUnique<base::FundamentalValue>(true));
     SendResponse(true);
     return true;
   }
 
-  base::PostTaskAndReplyWithResult(
-      BrowserThread::GetBlockingPool(), FROM_HERE,
-      base::Bind(&GetFileNameMaxLengthOnBlockingPool,
+  base::PostTaskWithTraitsAndReplyWithResult(
+      FROM_HERE, base::TaskTraits().MayBlock().WithPriority(
+                     base::TaskPriority::USER_BLOCKING),
+      base::Bind(&GetFileNameMaxLengthAsync,
                  file_system_url.path().AsUTF8Unsafe()),
       base::Bind(&FileManagerPrivateInternalValidatePathNameLengthFunction::
                      OnFilePathLimitRetrieved,
                  this, params->name.size()));
   return true;
 }
 
 void FileManagerPrivateInternalValidatePathNameLengthFunction::
     OnFilePathLimitRetrieved(size_t current_length, size_t max_length) {
   SetResult(
@@ skipping 444 matching lines @@
     return false;
   }
 
   const base::FilePath root_path = file_manager::util::GetLocalPathFromURL(
       render_frame_host(), GetProfile(), GURL(params->url));
   if (root_path.empty()) {
     SetError("Failed to get a local path from the entry's url.");
     return false;
   }
 
-  base::PostTaskAndReplyWithResult(
-      BrowserThread::GetBlockingPool(), FROM_HERE,
+  base::PostTaskWithTraitsAndReplyWithResult(
+      FROM_HERE, base::TaskTraits().MayBlock().WithPriority(
+                     base::TaskPriority::USER_VISIBLE),
       base::Bind(&base::ComputeDirectorySize, root_path),
       base::Bind(&FileManagerPrivateInternalGetDirectorySizeFunction::
                      OnDirectorySizeRetrieved,
                  this));
   return true;
 }
 
 void FileManagerPrivateInternalGetDirectorySizeFunction::
     OnDirectorySizeRetrieved(int64_t size) {
   SetResult(
       base::MakeUnique<base::FundamentalValue>(static_cast<double>(size)));
   SendResponse(true);
 }
 
 }  // namespace extensions