Use TaskScheduler instead of WorkerPool in extension_printer_handler.cc.

chrome/browser/ui/webui/print_preview/extension_printer_handler.cc

 // Copyright 2015 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/ui/webui/print_preview/extension_printer_handler.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/strings/string_split.h"
-#include "base/task_runner_util.h"
+#include "base/task_scheduler/post_task.h"
 #include "chrome/browser/printing/pwg_raster_converter.h"
 #include "components/cloud_devices/common/cloud_device_description.h"
 #include "components/cloud_devices/common/printer_description.h"
 #include "device/base/device_client.h"
 #include "device/usb/usb_device.h"
 #include "device/usb/usb_service.h"
 #include "extensions/browser/api/device_permissions_manager.h"
 #include "extensions/browser/api/printer_provider/printer_provider_api.h"
 #include "extensions/browser/api/printer_provider/printer_provider_api_factory.h"
 #include "extensions/browser/api/printer_provider/printer_provider_print_job.h"
@@ skipping 32 matching lines @@
 UpdateJobFileInfoOnWorkerThread(
     const base::FilePath& raster_path,
     std::unique_ptr<extensions::PrinterProviderPrintJob> job) {
   if (base::GetFileInfo(raster_path, &job->file_info))
     job->document_path = raster_path;
   return job;
 }
 
 // Callback to PWG raster conversion.
 // Posts a task to update print job with info about file containing converted
-// PWG raster data. The task is posted to |slow_task_runner|.
+// PWG raster data.
 void UpdateJobFileInfo(
     std::unique_ptr<extensions::PrinterProviderPrintJob> job,
-    const scoped_refptr<base::TaskRunner>& slow_task_runner,
     const ExtensionPrinterHandler::PrintJobCallback& callback,
     bool success,
     const base::FilePath& pwg_file_path) {
   if (!success) {
     callback.Run(std::move(job));
     return;
   }
 
-  base::PostTaskAndReplyWithResult(
-      slow_task_runner.get(), FROM_HERE,
+  base::PostTaskWithTraitsAndReplyWithResult(
+      FROM_HERE, base::TaskTraits()
+                     .WithShutdownBehavior(
+                         base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)
+                     .MayBlock(),
       base::Bind(&UpdateJobFileInfoOnWorkerThread, pwg_file_path,
                  base::Passed(&job)),
       callback);
 }
 
 bool HasUsbPrinterProviderPermissions(const Extension* extension) {
   return extension->permissions_data() &&
         extension->permissions_data()->HasAPIPermission(
             extensions::APIPermission::kPrinterProvider) &&
         extension->permissions_data()->HasAPIPermission(
@@ skipping 19 matching lines @@
     return false;
 
   *extension_id = components[1];
   *device_guid = components[2];
   return true;
 }
 
 }  // namespace
 
 ExtensionPrinterHandler::ExtensionPrinterHandler(
-    content::BrowserContext* browser_context,
-    const scoped_refptr<base::TaskRunner>& slow_task_runner)
-    : browser_context_(browser_context),
-      slow_task_runner_(slow_task_runner),
-      weak_ptr_factory_(this) {
-}
+    content::BrowserContext* browser_context)
+    : browser_context_(browser_context), weak_ptr_factory_(this) {}
 
 ExtensionPrinterHandler::~ExtensionPrinterHandler() {
 }
 
 void ExtensionPrinterHandler::Reset() {
   // TODO(tbarzic): Keep track of pending request ids issued by |this| and
   // cancel them from here.
   pending_enumeration_count_ = 0;
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
@@ skipping 126 matching lines @@
     const gfx::Size& page_size,
     std::unique_ptr<extensions::PrinterProviderPrintJob> job,
     const ExtensionPrinterHandler::PrintJobCallback& callback) {
   if (!pwg_raster_converter_) {
     pwg_raster_converter_ = PWGRasterConverter::CreateDefault();
   }
   pwg_raster_converter_->Start(
       data.get(),
       PWGRasterConverter::GetConversionSettings(printer_description, page_size),
       PWGRasterConverter::GetBitmapSettings(printer_description, ticket),
-      base::Bind(&UpdateJobFileInfo, base::Passed(&job), slow_task_runner_,
-                 callback));
+      base::Bind(&UpdateJobFileInfo, base::Passed(&job), callback));
 }
 
 void ExtensionPrinterHandler::DispatchPrintJob(
     const PrinterHandler::PrintCallback& callback,
     std::unique_ptr<extensions::PrinterProviderPrintJob> print_job) {
   if (print_job->document_path.empty() && !print_job->document_bytes) {
     WrapPrintCallback(callback, false, kInvalidDataPrintError);
     return;
   }
 
@@ skipping 78 matching lines @@
                 .Set("provisional", true)
                 .Build());
       }
     }
   }
 
   DCHECK_GT(pending_enumeration_count_, 0);
   pending_enumeration_count_--;
   callback.Run(*printer_list.Build().get(), pending_enumeration_count_ == 0);
 }