Make NSSCertDatabase::ListCerts work async on a worker thread.

chromeos/cert_loader.cc

 // Copyright (c) 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 "chromeos/cert_loader.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
-#include "base/sequenced_task_runner.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
 #include "base/threading/worker_pool.h"
 #include "crypto/nss_util.h"
 #include "net/cert/nss_cert_database.h"
 #include "net/cert/nss_cert_database_chromeos.h"
 #include "net/cert/x509_certificate.h"
 
 namespace chromeos {
 
-namespace {
-
-// Loads certificates from |cert_database| into |cert_list|.
-void LoadNSSCertificates(net::NSSCertDatabase* cert_database,
-                         net::CertificateList* cert_list) {
-  cert_database->ListCerts(cert_list);
-}
-
-}  // namespace
-
 static CertLoader* g_cert_loader = NULL;
 
 // static
 void CertLoader::Initialize() {
   CHECK(!g_cert_loader);
   g_cert_loader = new CertLoader();
 }
 
 // static
 void CertLoader::Shutdown() {
@@ skipping 12 matching lines @@
 bool CertLoader::IsInitialized() {
   return g_cert_loader;
 }
 
 CertLoader::CertLoader()
     : certificates_loaded_(false),
       certificates_update_required_(false),
       certificates_update_running_(false),
       database_(NULL),
       force_hardware_backed_for_test_(false),
+      cert_list_(new net::CertificateList),
       weak_factory_(this) {
 }
 
 CertLoader::~CertLoader() {
   net::CertDatabase::GetInstance()->RemoveObserver(this);
 }
 
 void CertLoader::StartWithNSSDB(net::NSSCertDatabase* database) {
   CHECK(!database_);
   database_ = database;
 
   // Start observing cert database for changes.
   // Observing net::CertDatabase is preferred over observing |database_|
   // directly, as |database_| observers receive only events generated directly
   // by |database_|, so they may miss a few relevant ones.
   // TODO(tbarzic): Once singleton NSSCertDatabase is removed, investigate if
   // it would be OK to observe |database_| directly; or change NSSCertDatabase
   // to send notification on all relevant changes.
   net::CertDatabase::GetInstance()->AddObserver(this);
 
   LoadCertificates();
 }
 
-void CertLoader::SetSlowTaskRunnerForTest(
-    const scoped_refptr<base::TaskRunner>& task_runner) {
-  slow_task_runner_for_test_ = task_runner;
-}
-
 void CertLoader::AddObserver(CertLoader::Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void CertLoader::RemoveObserver(CertLoader::Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 int CertLoader::TPMTokenSlotID() const {
   if (!database_)
@@ skipping 48 matching lines @@
 
 void CertLoader::LoadCertificates() {
   CHECK(thread_checker_.CalledOnValidThread());
   VLOG(1) << "LoadCertificates: " << certificates_update_running_;
 
   if (certificates_update_running_) {
     certificates_update_required_ = true;
     return;
   }
 
-  net::CertificateList* cert_list = new net::CertificateList;
   certificates_update_running_ = true;
   certificates_update_required_ = false;
 
-  base::TaskRunner* task_runner = slow_task_runner_for_test_.get();
-  if (!task_runner)
-    task_runner = base::WorkerPool::GetTaskRunner(true /* task is slow */);
-  task_runner->PostTaskAndReply(
-      FROM_HERE,
-      base::Bind(LoadNSSCertificates,
-                 // Create a copy of the database so it can be used on the
-                 // worker pool.
-                 // TODO(tbarzic): Make net::NSSCertDatabase::ListCerts async
-                 //     and change it to do the certificate listing on worker
-                 //     pool.
-                 base::Owned(new net::NSSCertDatabaseChromeOS(
-                     database_->GetPublicSlot(),
-                     database_->GetPrivateSlot())),
-                 cert_list),
-      base::Bind(&CertLoader::UpdateCertificates,
-                 weak_factory_.GetWeakPtr(),
-                 base::Owned(cert_list)));
+  database_->ListCerts(
+      base::Bind(&CertLoader::UpdateCertificates, weak_factory_.GetWeakPtr()));
 }
 
-void CertLoader::UpdateCertificates(net::CertificateList* cert_list) {
+void CertLoader::UpdateCertificates(
+    scoped_ptr<net::CertificateList> cert_list) {
   CHECK(thread_checker_.CalledOnValidThread());
   DCHECK(certificates_update_running_);
   VLOG(1) << "UpdateCertificates: " << cert_list->size();
 
   // Ignore any existing certificates.
-  cert_list_.swap(*cert_list);
+  cert_list_ = cert_list.Pass();
 
   bool initial_load = !certificates_loaded_;
   certificates_loaded_ = true;
   NotifyCertificatesLoaded(initial_load);
 
   certificates_update_running_ = false;
   if (certificates_update_required_)
     LoadCertificates();
 }
 
 void CertLoader::NotifyCertificatesLoaded(bool initial_load) {
   FOR_EACH_OBSERVER(Observer, observers_,
-                    OnCertificatesLoaded(cert_list_, initial_load));
+                    OnCertificatesLoaded(*cert_list_, initial_load));
 }
 
 void CertLoader::OnCACertChanged(const net::X509Certificate* cert) {
   // This is triggered when a CA certificate is modified.
   VLOG(1) << "OnCACertChanged";
   LoadCertificates();
 }
 
 void CertLoader::OnCertAdded(const net::X509Certificate* cert) {
   // This is triggered when a client certificate is added.
   VLOG(1) << "OnCertAdded";
   LoadCertificates();
 }
 
 void CertLoader::OnCertRemoved(const net::X509Certificate* cert) {
   VLOG(1) << "OnCertRemoved";
   LoadCertificates();
 }
 
 }  // namespace chromeos