Use TaskScheduler instead of WorkerPool in easy_unlock_tpm_key_manager.cc.

chrome/browser/chromeos/login/easy_unlock/easy_unlock_tpm_key_manager.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 "chrome/browser/chromeos/login/easy_unlock/easy_unlock_tpm_key_manager.h"
 
 #include <cryptohi.h>
 #include <keyhi.h>
 #include <stdint.h>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.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 "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/pref_names.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "content/public/browser/browser_thread.h"
 #include "crypto/nss_key_util.h"
 #include "crypto/nss_util_internal.h"
@@ skipping 300 matching lines @@
     crypto::ScopedPK11Slot system_slot) {
   CHECK(system_slot);
   create_tpm_key_state_ = CREATE_TPM_KEY_GOT_SYSTEM_SLOT;
 
   // If there are any delayed tasks posted using |StartGetSystemSlotTimeoutMs|,
   // this will cancel them.
   // Note that this would cancel other pending |CreateKeyInSystemSlot| tasks,
   // but there should be at most one such task at a time.
   get_tpm_slot_weak_ptr_factory_.InvalidateWeakPtrs();
 
-  base::WorkerPool::PostTask(
+  // This task interacts with the TPM, hence WithFileIO() and WithWait().
+  base::PostTaskWithTraits(
       FROM_HERE,
-      base::Bind(&CreateTpmKeyPairOnWorkerThread,
-                 base::Passed(&system_slot),
-                 public_key,
-                 base::ThreadTaskRunnerHandle::Get(),
+      base::TaskTraits().WithFileIO().WithWait().WithShutdownBehavior(
+          base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
+      base::Bind(&CreateTpmKeyPairOnWorkerThread, base::Passed(&system_slot),
+                 public_key, base::ThreadTaskRunnerHandle::Get(),
                  base::Bind(&EasyUnlockTpmKeyManager::OnTpmKeyCreated,
-                            weak_ptr_factory_.GetWeakPtr())),
-      true /* long task */);
+                            weak_ptr_factory_.GetWeakPtr())));
 }
 
 void EasyUnlockTpmKeyManager::SignDataWithSystemSlot(
     const std::string& public_key,
     const std::string& data,
     const base::Callback<void(const std::string& data)> callback,
     crypto::ScopedPK11Slot system_slot) {
   CHECK(system_slot);
 
-  base::WorkerPool::PostTask(
+  // This task interacts with the TPM, hence WithFileIO() and WithWait().
+  base::PostTaskWithTraits(
       FROM_HERE,
-      base::Bind(&SignDataOnWorkerThread,
-                 base::Passed(&system_slot),
-                 public_key,
-                 data,
-                 base::ThreadTaskRunnerHandle::Get(),
+      base::TaskTraits().WithFileIO().WithWait().WithShutdownBehavior(
+          base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
+      base::Bind(&SignDataOnWorkerThread, base::Passed(&system_slot),
+                 public_key, data, base::ThreadTaskRunnerHandle::Get(),
                  base::Bind(&EasyUnlockTpmKeyManager::OnDataSigned,
-                            weak_ptr_factory_.GetWeakPtr(),
-                            callback)),
-      true /* long task */);
+                            weak_ptr_factory_.GetWeakPtr(), callback)));
 }
 
 void EasyUnlockTpmKeyManager::OnTpmKeyCreated(const std::string& public_key) {
   // |OnTpmKeyCreated| is called by a timeout task posted by
   // |StartGetSystemSlotTimeoutMs|. Invalidating the factory will have
   // an effect of canceling any pending |GetSystemSlotOnIOThread| callbacks,
   // as well as other pending timeouts.
   // Note that in the case |OnTpmKeyCreated| was called as a result of
   // |CreateKeyInSystemSlot|, this should have no effect as no weak ptrs from
   // this factory should be in use in this case.
@@ skipping 12 matching lines @@
   // If key creation failed, reset the state machine.
   create_tpm_key_state_ =
       public_key.empty() ? CREATE_TPM_KEY_NOT_STARTED : CREATE_TPM_KEY_DONE;
 }
 
 void EasyUnlockTpmKeyManager::OnDataSigned(
     const base::Callback<void(const std::string&)>& callback,
     const std::string& signature) {
   callback.Run(signature);
 }