Use TaskScheduler instead of WorkerPool in client_cert_store_chromeos.cc.

chrome/browser/chromeos/net/client_cert_store_chromeos.cc

 // Copyright 2013 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/net/client_cert_store_chromeos.h"
 
 #include <cert.h>
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
-#include "base/threading/worker_pool.h"
+#include "base/task_scheduler/post_task.h"
 #include "chrome/browser/chromeos/certificate_provider/certificate_provider.h"
 #include "crypto/nss_crypto_module_delegate.h"
 #include "net/ssl/ssl_cert_request_info.h"
 
 namespace chromeos {
 
 namespace {
 
 class CertNotAllowedPredicate {
  public:
@@ skipping 48 matching lines @@
     const net::SSLCertRequestInfo* request,
     net::CertificateList* selected_certs,
     const base::Closure& callback,
     const net::CertificateList& additional_certs) {
   std::unique_ptr<crypto::CryptoModuleBlockingPasswordDelegate>
       password_delegate;
   if (!password_delegate_factory_.is_null()) {
     password_delegate.reset(
         password_delegate_factory_.Run(request->host_and_port));
   }
-  if (base::WorkerPool::PostTaskAndReply(
-          FROM_HERE,
-          base::Bind(&ClientCertStoreChromeOS::GetAndFilterCertsOnWorkerThread,
-                     base::Unretained(this), base::Passed(&password_delegate),
-                     request, additional_certs, selected_certs),
-          callback, true)) {
-    return;
-  }
-  // If the task could not be posted, behave as if there were no certificates
-  // which requires to clear |selected_certs|.
-  selected_certs->clear();
-  callback.Run();
+  base::PostTaskWithTraitsAndReply(
+      FROM_HERE, base::TaskTraits()
+                     .WithPriority(base::TaskPriority::BACKGROUND)

[mattm, 2016/11/29 21:48:46]

This should probably be USER_BLOCKING, or at least USER_VISIBLE.

When you load an HTTPS site, the server can request in the handshake that the
client supply a client certificate. Chrome will then show a list of matching
certificates and let the user choose one before proceeding with the connection.
This code is (part of) that responsible for fetching the list of certificates
which would be shown to the user. 

One thing to note though is that the task could also block arbitrarily long
depending on the user setup (smartcards, etc), so that's why it was marked as
task_is_slow=true in the WorkerPool call. Are potentially slow USER_BLOCKING or
USER_VISIBLE tasks a problem?

[fdoray, 2016/12/02 19:20:06]

I removed the explicit priority. The task's priority will now be inherited from
the task that posts it. Unless a post task call site is clearly
USER_VISIBLE/USER_BLOCKING (e.g. inside a OnKeyPressed() method), we prefer
relying on priority inheritance.
I added WithWait() for that
https://cs.chromium.org/chromium/src/base/task_scheduler/task_traits.h?sq=pac...

+                     .WithShutdownBehavior(
+                         base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),

[mattm, 2016/11/29 21:48:46]

CONTINUE_ON_SHUTDOWN is fine.

[fdoray, 2016/12/02 19:20:06]

Acknowledged.

+      base::Bind(&ClientCertStoreChromeOS::GetAndFilterCertsOnWorkerThread,
+                 base::Unretained(this), base::Passed(&password_delegate),
+                 request, additional_certs, selected_certs),
+      callback);
 }
 
 void ClientCertStoreChromeOS::GetAndFilterCertsOnWorkerThread(
     std::unique_ptr<crypto::CryptoModuleBlockingPasswordDelegate>
         password_delegate,
     const net::SSLCertRequestInfo* request,
     const net::CertificateList& additional_certs,
     net::CertificateList* selected_certs) {
   net::CertificateList unfiltered_certs;
   net::ClientCertStoreNSS::GetPlatformCertsOnWorkerThread(
       std::move(password_delegate), &unfiltered_certs);
 
   unfiltered_certs.erase(
       std::remove_if(unfiltered_certs.begin(), unfiltered_certs.end(),
                      CertNotAllowedPredicate(cert_filter_.get())),
       unfiltered_certs.end());
 
   unfiltered_certs.insert(unfiltered_certs.end(), additional_certs.begin(),
                           additional_certs.end());
 
   net::ClientCertStoreNSS::FilterCertsOnWorkerThread(unfiltered_certs, *request,
                                                      selected_certs);
 }
 
 }  // namespace chromeos