Use TaskScheduler instead of blocking pool in mime_util.cc.

chrome/browser/extensions/api/file_handlers/mime_util.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/extensions/api/file_handlers/mime_util.h"
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/filename_util.h"
 #include "net/base/mime_sniffer.h"
 #include "net/base/mime_util.h"
 #include "storage/browser/fileapi/file_system_url.h"
 
 #if defined(OS_CHROMEOS)
@@ skipping 49 matching lines @@
   if (success) {
     callback.Run(mime_type);
     return;
   }
 
   // MIME type not available with metadata, hence try to guess it from the
   // file's extension.
   std::unique_ptr<std::string> mime_type_from_extension(new std::string);
   std::string* const mime_type_from_extension_ptr =
       mime_type_from_extension.get();
-  BrowserThread::PostBlockingPoolTaskAndReply(
-      FROM_HERE,
-      base::Bind(base::IgnoreResult(&net::GetMimeTypeFromFile),
-                 local_path,
+  base::PostTaskWithTraitsAndReply(
+      FROM_HERE, base::TaskTraits().MayBlock().WithPriority(
+                     base::TaskPriority::BACKGROUND),

[benwells, 2017/02/14 06:03:21]

I think the priority for all of these should be USER_BLOCKING. For example,
these calls block the progress of opening files.

+      base::Bind(base::IgnoreResult(&net::GetMimeTypeFromFile), local_path,
                  mime_type_from_extension_ptr),
       base::Bind(&OnGetMimeTypeFromFileForNonNativeLocalPathCompleted,
-                 base::Passed(&mime_type_from_extension),
-                 callback));
+                 base::Passed(&mime_type_from_extension), callback));
 }
 #endif
 
 // Called when sniffing for MIME type in the native local file is completed.
 void OnSniffMimeTypeForNativeLocalPathCompleted(
     std::unique_ptr<std::string> mime_type,
     const base::Callback<void(const std::string&)>& callback) {
   // Do not return application/zip as sniffed result. If the file has .zip
   // extension, it should be already returned as application/zip. If the file
   // does not have .zip extension and couldn't find mime type from the
@@ skipping 16 matching lines @@
     std::unique_ptr<std::string> mime_type,
     const base::Callback<void(const std::string&)>& callback) {
   if (!mime_type->empty()) {
     callback.Run(*mime_type);
     return;
   }
 
   std::unique_ptr<std::string> sniffed_mime_type(
       new std::string(kMimeTypeApplicationOctetStream));
   std::string* const sniffed_mime_type_ptr = sniffed_mime_type.get();
-  BrowserThread::PostBlockingPoolTaskAndReply(
-      FROM_HERE,
+  base::PostTaskWithTraitsAndReply(
+      FROM_HERE, base::TaskTraits().MayBlock().WithPriority(
+                     base::TaskPriority::BACKGROUND),
       base::Bind(&SniffMimeType, local_path, sniffed_mime_type_ptr),
       base::Bind(&OnSniffMimeTypeForNativeLocalPathCompleted,
-                 base::Passed(&sniffed_mime_type),
-                 callback));
+                 base::Passed(&sniffed_mime_type), callback));
 }
 
 // Fetches MIME type for a local path and returns it with a |callback|.
 void GetMimeTypeForLocalPath(
     Profile* profile,
     const base::FilePath& local_path,
     const base::Callback<void(const std::string&)>& callback) {
 #if defined(OS_CHROMEOS)
   if (file_manager::util::IsUnderNonNativeLocalPath(profile, local_path)) {
     // For non-native files, try to get the MIME type from metadata. If not
     // available, then try to guess from the extension. Never sniff (because
     // it can be very slow).
     file_manager::util::GetNonNativeLocalPathMimeType(
         profile,
         local_path,
         base::Bind(&OnGetMimeTypeFromMetadataForNonNativeLocalPathCompleted,
                    local_path,
                    callback));
     return;
   }
 #endif
 
   // For native local files, try to guess the mime from the extension. If
   // not available, then try to sniff if.
   std::unique_ptr<std::string> mime_type_from_extension(new std::string);
   std::string* const mime_type_from_extension_ptr =
       mime_type_from_extension.get();
-  BrowserThread::PostBlockingPoolTaskAndReply(
-      FROM_HERE,
-      base::Bind(base::IgnoreResult(&net::GetMimeTypeFromFile),
-                 local_path,
+  base::PostTaskWithTraitsAndReply(
+      FROM_HERE, base::TaskTraits().MayBlock().WithPriority(
+                     base::TaskPriority::BACKGROUND),
+      base::Bind(base::IgnoreResult(&net::GetMimeTypeFromFile), local_path,
                  mime_type_from_extension_ptr),
-      base::Bind(&OnGetMimeTypeFromFileForNativeLocalPathCompleted,
-                 local_path,
-                 base::Passed(&mime_type_from_extension),
-                 callback));
+      base::Bind(&OnGetMimeTypeFromFileForNativeLocalPathCompleted, local_path,
+                 base::Passed(&mime_type_from_extension), callback));
 }
 
 MimeTypeCollector::MimeTypeCollector(Profile* profile)
     : profile_(profile), left_(0), weak_ptr_factory_(this) {
 }
 
 MimeTypeCollector::~MimeTypeCollector() {
 }
 
 void MimeTypeCollector::CollectForURLs(
@@ skipping 42 matching lines @@
         FROM_HERE, base::Bind(callback_, base::Passed(&result_)));
     // Release the callback to avoid a circullar reference in case an instance
     // of this class is a member of a ref counted class, which instance is bound
     // to this callback.
     callback_ = CompletionCallback();
   }
 }
 
 }  // namespace app_file_handler_util
 }  // namespace extensions