Use TaskScheduler instead of WorkerPool in multi_threaded_cert_verifier.cc.

net/cert/multi_threaded_cert_verifier.cc

 // Copyright (c) 2012 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 "net/cert/multi_threaded_cert_verifier.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/containers/linked_list.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/sha1.h"
-#include "base/threading/worker_pool.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
 #include "net/base/hash_value.h"
 #include "net/base/net_errors.h"
 #include "net/base/trace_constants.h"
 #include "net/cert/cert_verify_proc.h"
 #include "net/cert/cert_verify_result.h"
 #include "net/cert/crl_set.h"
 #include "net/cert/x509_certificate.h"
@@ skipping 140 matching lines @@
 
   const NetLogWithSource& net_log() const { return net_log_; }
 
  private:
   CertVerifierJob* job_;  // Not owned.
   CompletionCallback callback_;
   CertVerifyResult* verify_result_;
   const NetLogWithSource net_log_;
 };
 
-// DoVerifyOnWorkerThread runs the verification synchronously on a worker
-// thread. The output parameters (error and result) must remain alive.
-void DoVerifyOnWorkerThread(const scoped_refptr<CertVerifyProc>& verify_proc,
-                            const scoped_refptr<X509Certificate>& cert,
-                            const std::string& hostname,
-                            const std::string& ocsp_response,
-                            int flags,
-                            const scoped_refptr<CRLSet>& crl_set,
-                            const CertificateList& additional_trust_anchors,
-                            int* error,
-                            CertVerifyResult* result) {
-  TRACE_EVENT0(kNetTracingCategory, "DoVerifyOnWorkerThread");
+// DoVerifyAsync runs the verification in TaskScheduler. The output parameters
+// (error and result) must remain alive.
+void DoVerifyAsync(const scoped_refptr<CertVerifyProc>& verify_proc,
+                   const scoped_refptr<X509Certificate>& cert,
+                   const std::string& hostname,
+                   const std::string& ocsp_response,
+                   int flags,
+                   const scoped_refptr<CRLSet>& crl_set,
+                   const CertificateList& additional_trust_anchors,
+                   int* error,
+                   CertVerifyResult* result) {
+  TRACE_EVENT0(kNetTracingCategory, "DoVerifyAsync");
   *error = verify_proc->Verify(cert.get(), hostname, ocsp_response, flags,
                                crl_set.get(), additional_trust_anchors, result);
 
 #if defined(USE_NSS_CERTS)
   // Detach the thread from NSPR.
   // Calling NSS functions attaches the thread to NSPR, which stores
   // the NSPR thread ID in thread-specific data.
   // The threads in our thread pool terminate after we have called
   // PR_Cleanup.  Unless we detach them from NSPR, net_unittests gets
   // segfaults on shutdown when the threads' thread-specific data
@@ skipping 22 matching lines @@
 
   // Indicates whether this was the first job started by the CertVerifier. This
   // is only used for logging certain UMA stats.
   void set_is_first_job(bool is_first_job) { is_first_job_ = is_first_job; }
 
   const CertVerifier::RequestParams& key() const { return key_; }
 
   // Posts a task to the worker pool to do the verification. Once the
   // verification has completed on the worker thread, it will call
   // OnJobCompleted() on the origin thread.
-  bool Start(const scoped_refptr<CertVerifyProc>& verify_proc,
+  void Start(const scoped_refptr<CertVerifyProc>& verify_proc,
              const scoped_refptr<CRLSet>& crl_set) {
     // Owned by the bound reply callback.
     std::unique_ptr<ResultHelper> owned_result(new ResultHelper());
 
     // Parameter evaluation order is undefined in C++. Ensure the pointer value
     // is gotten before calling base::Passed().
     auto* result = owned_result.get();
 
-    return base::WorkerPool::PostTaskAndReply(
-        FROM_HERE,
-        base::Bind(&DoVerifyOnWorkerThread, verify_proc, key_.certificate(),
+    base::PostTaskWithTraitsAndReply(
+        FROM_HERE, base::TaskTraits()
+                       .WithShutdownBehavior(
+                           base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)
+                       .MayBlock()
+                       .WithBaseSyncPrimitives(),
+        base::Bind(&DoVerifyAsync, verify_proc, key_.certificate(),
                    key_.hostname(), key_.ocsp_response(), key_.flags(), crl_set,
                    key_.additional_trust_anchors(), &result->error,
                    &result->result),
         base::Bind(&CertVerifierJob::OnJobCompleted,
-                   weak_ptr_factory_.GetWeakPtr(), base::Passed(&owned_result)),
-        true /* task is slow */);
+                   weak_ptr_factory_.GetWeakPtr(),
+                   base::Passed(&owned_result)));
   }
 
   ~CertVerifierJob() {
     // If the job is in progress, cancel it.
     if (cert_verifier_) {
       cert_verifier_ = nullptr;
 
       net_log_.AddEvent(NetLogEventType::CANCELLED);
       net_log_.EndEvent(NetLogEventType::CERT_VERIFIER_JOB);
 
@@ skipping 101 matching lines @@
   // See if an identical request is currently in flight.
   CertVerifierJob* job = FindJob(params);
   if (job) {
     // An identical request is in flight already. We'll just attach our
     // callback.
     inflight_joins_++;
   } else {
     // Need to make a new job.
     std::unique_ptr<CertVerifierJob> new_job =
         base::MakeUnique<CertVerifierJob>(params, net_log.net_log(), this);
-
-    if (!new_job->Start(verify_proc_, crl_set)) {
-      // TODO(wtc): log to the NetLog.
-      LOG(ERROR) << "CertVerifierJob couldn't be started.";
-      return ERR_INSUFFICIENT_RESOURCES;  // Just a guess.
-    }
+    new_job->Start(verify_proc_, crl_set);
 
     job = new_job.get();
     inflight_[job] = std::move(new_job);
 
     if (requests_ == 1)
       job->set_is_first_job(true);
   }
 
   std::unique_ptr<CertVerifierRequest> request =
       job->CreateRequest(callback, verify_result, net_log);
@@ skipping 35 matching lines @@
   // The JobSet is kept in sorted order so items can be found using binary
   // search.
   auto it = std::lower_bound(inflight_.begin(), inflight_.end(), key,
                              JobToRequestParamsComparator());
   if (it != inflight_.end() && !(key < it->first->key()))
     return it->first;
   return nullptr;
 }
 
 }  // namespace net