Use TaskScheduler instead of WorkerPool in platform_keys_nss.cc.

chrome/browser/chromeos/platform_keys/platform_keys_nss.cc

 // Copyright 2014 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 <cert.h>
 #include <cryptohi.h>
 #include <keyhi.h>
 #include <secder.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "base/threading/worker_pool.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part_chromeos.h"
 #include "chrome/browser/chromeos/certificate_provider/certificate_provider.h"
 #include "chrome/browser/chromeos/net/client_cert_filter_chromeos.h"
 #include "chrome/browser/chromeos/net/client_cert_store_chromeos.h"
 #include "chrome/browser/chromeos/platform_keys/platform_keys.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api.h"
 #include "chrome/browser/net/nss_context.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 399 matching lines @@
                   public_key_der->len),
       std::string() /* no error */);
 }
 
 // Continues generating a RSA key with the obtained NSSCertDatabase. Used by
 // GenerateRSAKey().
 void GenerateRSAKeyWithDB(std::unique_ptr<GenerateRSAKeyState> state,
                           net::NSSCertDatabase* cert_db) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Only the slot and not the NSSCertDatabase is required. Ignore |cert_db|.
-  base::WorkerPool::PostTask(
-      FROM_HERE,
-      base::Bind(&GenerateRSAKeyOnWorkerThread, base::Passed(&state)),
-      true /*task is slow*/);
+  // This task interacts with the TPM, hence WithFileIO() and WithWait().
+  base::PostTaskWithTraits(
+      FROM_HERE, base::TaskTraits()
+                     .WithFileIO()
+                     .WithWait()
+                     .WithPriority(base::TaskPriority::BACKGROUND)
+                     .WithShutdownBehavior(
+                         base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
+      base::Bind(&GenerateRSAKeyOnWorkerThread, base::Passed(&state)));
 }
 
 // Does the actual signing on a worker thread. Used by SignRSAWithDB().
 void SignRSAOnWorkerThread(std::unique_ptr<SignRSAState> state) {
   const uint8_t* public_key_uint8 =
       reinterpret_cast<const uint8_t*>(state->public_key_.data());
   std::vector<uint8_t> public_key_vector(
       public_key_uint8, public_key_uint8 + state->public_key_.size());
 
   crypto::ScopedSECKEYPrivateKey rsa_key;
@@ skipping 68 matching lines @@
   }
 
   state->CallBack(FROM_HERE, signature_str, std::string() /* no error */);
 }
 
 // Continues signing with the obtained NSSCertDatabase. Used by Sign().
 void SignRSAWithDB(std::unique_ptr<SignRSAState> state,
                    net::NSSCertDatabase* cert_db) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Only the slot and not the NSSCertDatabase is required. Ignore |cert_db|.
-  base::WorkerPool::PostTask(
-      FROM_HERE, base::Bind(&SignRSAOnWorkerThread, base::Passed(&state)),
-      true /*task is slow*/);
+  // This task interacts with the TPM, hence WithFileIO() and WithWait().
+  base::PostTaskWithTraits(
+      FROM_HERE, base::TaskTraits()
+                     .WithFileIO()
+                     .WithWait()
+                     .WithPriority(base::TaskPriority::BACKGROUND)
+                     .WithShutdownBehavior(
+                         base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
+      base::Bind(&SignRSAOnWorkerThread, base::Passed(&state)));
 }
 
 // Called when ClientCertStoreChromeOS::GetClientCerts is done. Builds the list
 // of net::CertificateList and calls back. Used by
 // SelectCertificatesOnIOThread().
 void DidSelectCertificatesOnIOThread(
     std::unique_ptr<SelectCertificatesState> state) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   state->CallBack(FROM_HERE, std::move(state->certs_),
                   std::string() /* no error */);
@@ skipping 42 matching lines @@
   state->CallBack(FROM_HERE, std::move(client_certs),
                   std::string() /* no error */);
 }
 
 // Passes the obtained certificates to the worker thread for filtering. Used by
 // GetCertificatesWithDB().
 void DidGetCertificates(std::unique_ptr<GetCertificatesState> state,
                         std::unique_ptr<net::CertificateList> all_certs) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   state->certs_ = std::move(all_certs);
-  base::WorkerPool::PostTask(
-      FROM_HERE,
-      base::Bind(&FilterCertificatesOnWorkerThread, base::Passed(&state)),
-      true /*task is slow*/);
+  // This task interacts with the TPM, hence WithFileIO() and WithWait().
+  base::PostTaskWithTraits(
+      FROM_HERE, base::TaskTraits()
+                     .WithFileIO()
+                     .WithWait()
+                     .WithPriority(base::TaskPriority::BACKGROUND)
+                     .WithShutdownBehavior(
+                         base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
+      base::Bind(&FilterCertificatesOnWorkerThread, base::Passed(&state)));
 }
 
 // Continues getting certificates with the obtained NSSCertDatabase. Used by
 // GetCertificates().
 void GetCertificatesWithDB(std::unique_ptr<GetCertificatesState> state,
                            net::NSSCertDatabase* cert_db) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Get the pointer to slot before base::Passed releases |state|.
   PK11SlotInfo* slot = state->slot_.get();
   cert_db->ListCertsInSlot(
@@ skipping 279 matching lines @@
   NSSOperationState* state_ptr = state.get();
   GetCertDatabase(std::string() /* don't get any specific slot */,
                   base::Bind(&GetTokensWithDB, base::Passed(&state)),
                   browser_context,
                   state_ptr);
 }
 
 }  // namespace platform_keys
 
 }  // namespace chromeos