Replace c/b/nss_context by a KeyedService.

chromeos/network/onc/onc_certificate_importer_impl_unittest.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 <certdb.h>
 #include <keyhi.h>
 #include <pk11pub.h>
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chromeos/network/onc/onc_test_utils.h"
+#include "components/cert_database/public/cert_database_service_io_part.h"
 #include "components/onc/onc_constants.h"
 #include "crypto/scoped_test_nss_db.h"
 #include "net/base/crypto_module.h"
 #include "net/cert/cert_type.h"
 #include "net/cert/nss_cert_database_chromeos.h"
 #include "net/cert/x509_certificate.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
 namespace onc {
@@ skipping 23 matching lines @@
     return net::SERVER_CERT;
   return net::OTHER_CERT;
 }
 #else
 net::CertType GetCertType(net::X509Certificate::OSCertHandle cert) {
   NOTIMPLEMENTED();
   return net::OTHER_CERT;
 }
 #endif  // USE_NSS
 
+class FakeCertDatabaseServiceIOPart : public CertDatabaseServiceIOPart {
+ public:
+  explicit FakeCertDatabaseServiceIOPart(scoped_ptr<net::NSSCertDatabase> db) {
+    DidCreateNSSCertDatabase(db.Pass());
+  }
+
+  virtual ~FakeCertDatabaseServiceIOPart() {}
+};
+
 }  // namespace
 
 class ONCCertificateImporterImplTest : public testing::Test {
  public:
   ONCCertificateImporterImplTest() {}
   virtual ~ONCCertificateImporterImplTest() {}
 
   virtual void SetUp() override {
     ASSERT_TRUE(public_nssdb_.is_open());
     ASSERT_TRUE(private_nssdb_.is_open());
 
     task_runner_ = new base::TestSimpleTaskRunner();
     thread_task_runner_handle_.reset(
         new base::ThreadTaskRunnerHandle(task_runner_));
 
-    test_nssdb_.reset(new net::NSSCertDatabaseChromeOS(
+    scoped_ptr<net::NSSCertDatabase> nss_db(new net::NSSCertDatabaseChromeOS(
         crypto::ScopedPK11Slot(PK11_ReferenceSlot(public_nssdb_.slot())),
         crypto::ScopedPK11Slot(PK11_ReferenceSlot(private_nssdb_.slot()))));
+    cert_db_io_.reset(new FakeCertDatabaseServiceIOPart(nss_db.Pass()));
 
     // Test db should be empty at start of test.
     EXPECT_TRUE(ListCertsInPublicSlot().empty());
     EXPECT_TRUE(ListCertsInPrivateSlot().empty());
   }
 
   virtual void TearDown() override {
     thread_task_runner_handle_.reset();
     task_runner_ = NULL;
   }
@@ skipping 10 matching lines @@
     scoped_ptr<base::DictionaryValue> onc =
         test_utils::ReadTestDictionary(filename);
     scoped_ptr<base::Value> certificates_value;
     base::ListValue* certificates = NULL;
     onc->RemoveWithoutPathExpansion(::onc::toplevel_config::kCertificates,
                                     &certificates_value);
     certificates_value.release()->GetAsList(&certificates);
     onc_certificates_.reset(certificates);
 
     web_trust_certificates_.clear();
-    CertificateImporterImpl importer(task_runner_, test_nssdb_.get());
+    CertificateImporterImpl importer(task_runner_, cert_db_io_->GetWeakPtr());
     importer.ImportCertificates(
         *certificates,
         ::onc::ONC_SOURCE_USER_IMPORT,  // allow web trust
         base::Bind(&ONCCertificateImporterImplTest::OnImportCompleted,
                    base::Unretained(this),
                    expected_success));
 
     task_runner_->RunUntilIdle();
 
     public_list_ = ListCertsInPublicSlot();
@@ skipping 24 matching lines @@
     certificate->GetStringWithoutPathExpansion(::onc::certificate::kGUID, guid);
   }
 
   // Certificates and the NSSCertDatabase depend on these test DBs. Destroy them
   // last.
   crypto::ScopedTestNSSDB public_nssdb_;
   crypto::ScopedTestNSSDB private_nssdb_;
 
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   scoped_ptr<base::ThreadTaskRunnerHandle> thread_task_runner_handle_;
-  scoped_ptr<net::NSSCertDatabaseChromeOS> test_nssdb_;
+  scoped_ptr<FakeCertDatabaseServiceIOPart> cert_db_io_;
   scoped_ptr<base::ListValue> onc_certificates_;
   // List of certs in the nssdb's public slot.
   net::CertificateList public_list_;
   // List of certs in the nssdb's "private" slot.
   net::CertificateList private_list_;
   net::CertificateList web_trust_certificates_;
 
  private:
   net::CertificateList ListCertsInPublicSlot() {
     return ListCertsInSlot(public_nssdb_.slot());
@@ skipping 174 matching lines @@
                   "certificate-client-update.onc"),
         CertParam(net::SERVER_CERT,
                   "certificate-server.onc",
                   "certificate-server-update.onc"),
         CertParam(net::CA_CERT,
                   "certificate-web-authority.onc",
                   "certificate-web-authority-update.onc")));
 
 }  // namespace onc
 }  // namespace chromeos