Add migration from CaCert NSS nicknames to PEM.

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/chromeos/chromeos_version.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/observer_list.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
-#include "base/threading/worker_pool.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "crypto/encryptor.h"
 #include "crypto/nss_util.h"
 #include "crypto/sha2.h"
 #include "crypto/symmetric_key.h"
 #include "net/cert/nss_cert_database.h"
 
 namespace chromeos {
 
@@ skipping 27 matching lines @@
 
   // Ensure we've opened the user's key/certificate database.
   crypto::OpenPersistentNSSDB();
   if (base::chromeos::IsRunningOnChromeOS())
     crypto::EnableTPMTokenForNSS();
 }
 
 }  // namespace
 
 static CertLoader* g_cert_loader = NULL;
+
 // static
-void CertLoader::Initialize() {
+void CertLoader::Initialize(
+    const scoped_refptr<base::TaskRunner>& task_runner) {
   CHECK(!g_cert_loader);
-  g_cert_loader = new CertLoader();
+  CHECK(task_runner);
+  g_cert_loader = new CertLoader(task_runner);
   g_cert_loader->Init();
 }
 
 // static
 void CertLoader::Shutdown() {
   CHECK(g_cert_loader);
   delete g_cert_loader;
   g_cert_loader = NULL;
 }
 
 // static
 CertLoader* CertLoader::Get() {
   CHECK(g_cert_loader)
       << "CertLoader::Get() called before Initialize()";
   return g_cert_loader;
 }
 
 // static
 bool CertLoader::IsInitialized() {
   return g_cert_loader;
 }
 
-CertLoader::CertLoader()
+CertLoader::CertLoader(const scoped_refptr<base::TaskRunner>& task_runner)
     : certificates_requested_(false),
       certificates_loaded_(false),
       certificates_update_required_(false),
       certificates_update_running_(false),
       tpm_token_state_(TPM_STATE_UNKNOWN),
       tpm_request_delay_(
           base::TimeDelta::FromMilliseconds(kInitialRequestDelayMs)),
+      worker_pool_task_runner_(task_runner),
       initialize_token_factory_(this),
       update_certificates_factory_(this) {
 }
 
 void CertLoader::Init() {
   net::CertDatabase::GetInstance()->AddObserver(this);
   if (LoginState::IsInitialized())
     LoginState::Get()->AddObserver(this);
 }
 
@@ skipping 213 matching lines @@
   VLOG(1) << "StartLoadCertificates: " << 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::WorkerPool::GetTaskRunner(true /* task_is_slow */)->
-      PostTaskAndReply(
-          FROM_HERE,
-          base::Bind(LoadNSSCertificates, cert_list),
-          base::Bind(&CertLoader::UpdateCertificates,
-                     update_certificates_factory_.GetWeakPtr(),
-                     base::Owned(cert_list)));
+  worker_pool_task_runner_->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(LoadNSSCertificates, cert_list),
+      base::Bind(&CertLoader::UpdateCertificates,
+                 update_certificates_factory_.GetWeakPtr(),
+                 base::Owned(cert_list)));
 }
 
 void CertLoader::UpdateCertificates(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);
 
@@ skipping 23 matching lines @@
   VLOG(1) << "OnCertRemoved";
   StartLoadCertificates();
 }
 
 void CertLoader::LoggedInStateChanged(LoginState::LoggedInState state) {
   VLOG(1) << "LoggedInStateChanged: " << state;
   MaybeRequestCertificates();
 }
 
 }  // namespace chromeos