Replace c/b/nss_context by a KeyedService.

chromeos/network/onc/onc_certificate_importer_impl.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 "chromeos/network/onc/onc_certificate_importer_impl.h"
 
 #include <cert.h>
 #include <keyhi.h>
 #include <pk11pub.h>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/onc/onc_utils.h"
+#include "components/cert_database/public/cert_database_service_io_part.h"
 #include "components/onc/onc_constants.h"
 #include "crypto/scoped_nss_types.h"
 #include "net/base/crypto_module.h"
 #include "net/base/net_errors.h"
 #include "net/cert/nss_cert_database.h"
 #include "net/cert/x509_certificate.h"
 
 namespace chromeos {
 namespace onc {
 
 namespace {
 
 void CallBackOnOriginLoop(
     const scoped_refptr<base::SingleThreadTaskRunner>& origin_loop,
     const CertificateImporter::DoneCallback& callback,
     bool success,
     const net::CertificateList& onc_trusted_certificates) {
   origin_loop->PostTask(
       FROM_HERE, base::Bind(callback, success, onc_trusted_certificates));
 }
 
+void GetNSSCertDatabase(

[stevenjb, 2014/10/29 18:43:51]

This name is a bit confusing, maybe something like 'CallWithCertDatabase'?

[pneubeck (no reviews), 2014/11/05 14:53:36]

Added a comment to clarify. I think the naming scheme is rather common for
asynchronous results.
Done.

+    const base::WeakPtr<cert_database::CertDatabaseServiceIOPart>& cert_db_io,
+    const cert_database::CertDatabaseServiceIOPart::GetCertDBCallback&
+        callback) {
+  if (!cert_db_io) {
+    callback.Run(NULL /* no NSSCertDatabase */);
+    return;
+  }
+  net::NSSCertDatabase* nss_db = cert_db_io->GetNSSCertDatabase(callback);
+  if (nss_db)
+    callback.Run(nss_db);
+}
+
 }  // namespace
 
 CertificateImporterImpl::CertificateImporterImpl(
     const scoped_refptr<base::SequencedTaskRunner>& io_task_runner,
-    net::NSSCertDatabase* target_nssdb)
+    const base::WeakPtr<cert_database::CertDatabaseServiceIOPart>& cert_db_io)
     : io_task_runner_(io_task_runner),
-      target_nssdb_(target_nssdb),
+      cert_db_io_(cert_db_io),
       weak_factory_(this) {
-  CHECK(target_nssdb);
 }
 
 CertificateImporterImpl::~CertificateImporterImpl() {
 }
 
 void CertificateImporterImpl::ImportCertificates(
     const base::ListValue& certificates,
     ::onc::ONCSource source,
     const DoneCallback& done_callback) {
   VLOG(2) << "ONC file has " << certificates.GetSize() << " certificates";
   // |done_callback| must only be called as long as |this| still exists.
   // Thereforce, call back to |this|. This check of |this| must happen last and
   // on the origin thread.
   DoneCallback callback_to_this =
       base::Bind(&CertificateImporterImpl::RunDoneCallback,
                  weak_factory_.GetWeakPtr(),
                  done_callback);
 
   // |done_callback| must be called on the origin thread.
   DoneCallback callback_on_origin_loop =
       base::Bind(&CallBackOnOriginLoop,
                  base::ThreadTaskRunnerHandle::Get(),
                  callback_to_this);
 
-  // This is the actual function that imports the certificates.
-  base::Closure import_certs_callback =
-      base::Bind(&ParseAndStoreCertificates,
-                 source,
-                 callback_on_origin_loop,
-                 base::Owned(certificates.DeepCopy()),
-                 target_nssdb_);
+  // This is the actual function that imports the certificates. This must be
+  // executed when the NSSCertDatabase is available.
+  cert_database::CertDatabaseServiceIOPart::GetCertDBCallback
+      import_certs_callback = base::Bind(&ParseAndStoreCertificates,
+                                         source,
+                                         callback_on_origin_loop,
+                                         base::Owned(certificates.DeepCopy()));
 
-  // The NSSCertDatabase must be accessed on |io_task_runner_|
-  io_task_runner_->PostTask(FROM_HERE, import_certs_callback);
+  // The NSSCertDatabase is obtained from |cert_db_io_|, which must be accessed
+  // on |io_task_runner_|
+  io_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&GetNSSCertDatabase, cert_db_io_, import_certs_callback));
 }
 
 // static
 void CertificateImporterImpl::ParseAndStoreCertificates(
     ::onc::ONCSource source,
     const DoneCallback& done_callback,
     base::ListValue* certificates,
     net::NSSCertDatabase* nssdb) {
+  net::CertificateList onc_trusted_certificates;
+  if (!nssdb) {
+    done_callback.Run(false, onc_trusted_certificates);
+    return;
+  }
   // Web trust is only granted to certificates imported by the user.
   bool allow_trust_imports = source == ::onc::ONC_SOURCE_USER_IMPORT;
-  net::CertificateList onc_trusted_certificates;
   bool success = true;
   for (size_t i = 0; i < certificates->GetSize(); ++i) {
     const base::DictionaryValue* certificate = NULL;
     certificates->GetDictionary(i, &certificate);
     DCHECK(certificate != NULL);
 
     VLOG(2) << "Parsing certificate at index " << i << ": " << *certificate;
 
     if (!ParseAndStoreCertificate(allow_trust_imports,
                                   *certificate,
@@ skipping 289 matching lines @@
     PK11_SetPrivateKeyNickname(private_key, const_cast<char*>(guid.c_str()));
     SECKEY_DestroyPrivateKey(private_key);
   } else {
     LOG(WARNING) << "Unable to find private key for certificate.";
   }
   return true;
 }
 
 }  // namespace onc
 }  // namespace chromeos