Replace usage of single-threaded SequencedWorkerPool with base::Thread in WebCrypto.

components/webcrypto/webcrypto_impl.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 "components/webcrypto/webcrypto_impl.h"
 
 #include <limits.h>
 #include <stdint.h>
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner.h"
-#include "base/threading/sequenced_worker_pool.h"
+#include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "base/threading/worker_pool.h"
 #include "components/webcrypto/algorithm_dispatch.h"
 #include "components/webcrypto/crypto_data.h"
 #include "components/webcrypto/generate_key_result.h"
 #include "components/webcrypto/status.h"
 #include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 
 namespace webcrypto {
 
 using webcrypto::Status;
 
 namespace {
 
 // ---------------------
 // Threading
 // ---------------------
 //
 // WebCrypto operations can be slow. For instance generating an RSA key can
 // take seconds.
 //
-// The strategy used here is to run a sequenced worker pool for all WebCrypto
-// operations (except structured cloning). This same pool is also used by
-// requests started from Blink Web Workers.
+// The strategy used here is to run a worker pool for all WebCrypto operations
+// (except structured cloning). This same pool is also used by requests started
+// from Blink Web Workers.
 //
 // A few notes to keep in mind:
 //
 // * PostTaskAndReply() is not used because of how it handles failures -- it
 //   leaks the callback when failing to post back to the origin thread.
 //
 //   This is a problem since WebCrypto may be called from WebWorker threads,
 //   which may be aborted at any time. Leaking would be undesirable, and
 //   reachable in practice.
 //
@@ skipping 10 matching lines @@
 //   following ImportKey()).
 //
 // * blink::WebCryptoResult is not threadsafe and should only be operated on
 //   the target Blink thread. HOWEVER, it is safe to delete it from any thread.
 //   This can happen if by the time the operation has completed in the crypto
 //   worker pool, the Blink worker thread that initiated the request is gone.
 //   Posting back to the origin thread will fail, and the WebCryptoResult will
 //   be deleted while running in the crypto worker pool.
 class CryptoThreadPool {
  public:
-  CryptoThreadPool()
-      : worker_pool_(
-            new base::SequencedWorkerPool(1,
-                                          "WebCrypto",
-                                          base::TaskPriority::USER_BLOCKING)),
-        task_runner_(worker_pool_->GetSequencedTaskRunnerWithShutdownBehavior(
-            worker_pool_->GetSequenceToken(),
-            base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN)) {}
+  CryptoThreadPool() : worker_thread_("WebCrypto") {
+    base::Thread::Options options;
+    options.joinable = false;
+    worker_thread_.StartWithOptions(options);
+  }
 
   static bool PostTask(const tracked_objects::Location& from_here,
                        const base::Closure& task);
 
  private:
-  scoped_refptr<base::SequencedWorkerPool> worker_pool_;
-  scoped_refptr<base::SequencedTaskRunner> task_runner_;
+  // TODO(gab): the pool is currently using a single non-joinable thread to
+  // mimic the old behavior of using a CONTINUE_ON_SHUTDOWN SequencedTaskRunner
+  // on a single-threaded SequencedWorkerPool, but we'd like to consider using
+  // the TaskScheduler here and allowing multiple threads (SEQUENCED or even
+  // PARALLEL ExecutionMode: http://crbug.com/623700).
+  base::Thread worker_thread_;
+
+  DISALLOW_COPY_AND_ASSIGN(CryptoThreadPool);
 };
 
 base::LazyInstance<CryptoThreadPool>::Leaky crypto_thread_pool =
     LAZY_INSTANCE_INITIALIZER;
 
 bool CryptoThreadPool::PostTask(const tracked_objects::Location& from_here,
                                 const base::Closure& task) {
-  return crypto_thread_pool.Get().task_runner_->PostTask(from_here, task);
+  return crypto_thread_pool.Get().worker_thread_.task_runner()->PostTask(
+      from_here, task);
 }
 
 void CompleteWithThreadPoolError(blink::WebCryptoResult* result) {
   result->completeWithError(blink::WebCryptoErrorTypeOperation,
                             "Failed posting to crypto worker pool");
 }
 
 void CompleteWithError(const Status& status, blink::WebCryptoResult* result) {
   DCHECK(status.IsError());
 
@@ skipping 664 matching lines @@
       webcrypto::CryptoData(key_data, key_data_size), &key);
 }
 
 bool WebCryptoImpl::serializeKeyForClone(
     const blink::WebCryptoKey& key,
     blink::WebVector<unsigned char>& key_data) {
   return webcrypto::SerializeKeyForClone(key, &key_data);
 }
 
 }  // namespace webcrypto