Replace c/b/nss_context by a KeyedService.

chrome/browser/certificate_manager_model.cc

 // Copyright (c) 2012 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/certificate_manager_model.h"
 
 #include "base/bind.h"
 #include "base/i18n/time_formatting.h"
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/net/nss_context.h"
+#include "chrome/browser/net/cert_database_service_factory.h"
 #include "chrome/browser/ui/crypto_module_password_dialog_nss.h"
 #include "chrome/common/net/x509_certificate_model.h"
 #include "chrome/grit/generated_resources.h"
+#include "components/cert_database/cert_database_service.h"
+#include "components/cert_database/cert_database_service_io_part.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_context.h"
 #include "crypto/nss_util.h"
 #include "net/base/crypto_module.h"
 #include "net/base/net_errors.h"
 #include "net/cert/x509_certificate.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
 
 // CertificateManagerModel is created on the UI thread. It needs a
 // NSSCertDatabase handle (and on ChromeOS it needs to get the TPM status) which
 // needs to be done on the IO thread.
 //
 // The initialization flow is roughly:
 //
 //               UI thread                              IO Thread
 //
 //   CertificateManagerModel::Create
+//                  |
+//   CertDatabaseService::GetIOPart
 //                  \--------------------------------------v
 //                                CertificateManagerModel::GetCertDBOnIOThread
 //                                                         |
-//                                     GetNSSCertDatabaseForResourceContext
+//                                CertDatabaseServiceIOPart::GetNSSCertDatabase
 //                                                         |
 //                               CertificateManagerModel::DidGetCertDBOnIOThread
 //                                                         |
 //                                       crypto::IsTPMTokenEnabledForNSS
 //                  v--------------------------------------/
 // CertificateManagerModel::DidGetCertDBOnUIThread
 //                  |
 //     new CertificateManagerModel
 //                  |
 //               callback
 
 // static
 void CertificateManagerModel::Create(
     content::BrowserContext* browser_context,
     CertificateManagerModel::Observer* observer,
     const CreationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  cert_database::CertDatabaseService* cert_db_service =
+      cert_database::CertDatabaseServiceFactory::GetForBrowserContext(
+          browser_context);
+  base::WeakPtr<cert_database::CertDatabaseServiceIOPart> cert_db_service_io;
+  if (cert_db_service)
+    cert_db_service_io = cert_db_service->GetIOPart();
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&CertificateManagerModel::GetCertDBOnIOThread,
-                 browser_context->GetResourceContext(),
+                 cert_db_service_io,
                  observer,
                  callback));
 }
 
 CertificateManagerModel::CertificateManagerModel(
     net::NSSCertDatabase* nss_cert_database,
     bool is_user_db_available,
     bool is_tpm_available,
     Observer* observer)
     : cert_db_(nss_cert_database),
@@ skipping 149 matching lines @@
   callback.Run(model.Pass());
 }
 
 // static
 void CertificateManagerModel::DidGetCertDBOnIOThread(
     CertificateManagerModel::Observer* observer,
     const CreationCallback& callback,
     net::NSSCertDatabase* cert_db) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  bool is_user_db_available = cert_db->GetPublicSlot();
+  bool is_user_db_available = cert_db && cert_db->GetPublicSlot();
   bool is_tpm_available = false;
 #if defined(OS_CHROMEOS)
   is_tpm_available = crypto::IsTPMTokenEnabledForNSS();
 #endif
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&CertificateManagerModel::DidGetCertDBOnUIThread,
                  cert_db,
                  is_user_db_available,
                  is_tpm_available,
                  observer,
                  callback));
 }
 
 // static
 void CertificateManagerModel::GetCertDBOnIOThread(
-    content::ResourceContext* context,
+    base::WeakPtr<cert_database::CertDatabaseServiceIOPart> cert_db_service_io,
     CertificateManagerModel::Observer* observer,
     const CreationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  net::NSSCertDatabase* cert_db = GetNSSCertDatabaseForResourceContext(
-      context,
-      base::Bind(&CertificateManagerModel::DidGetCertDBOnIOThread,
-                 observer,
-                 callback));
-  if (cert_db)
-    DidGetCertDBOnIOThread(observer, callback, cert_db);
+  base::Callback<void(net::NSSCertDatabase*)> get_db_callback = base::Bind(
+      &CertificateManagerModel::DidGetCertDBOnIOThread, observer, callback);
+  if (cert_db_service_io) {
+    net::NSSCertDatabase* cert_db =
+        cert_db_service_io->GetNSSCertDatabase(get_db_callback);
+    if (cert_db)
+      get_db_callback.Run(cert_db);
+  } else {
+    // Either the process in shutting down or the database was not available at
+    // all. Continue, without cert database.
+    get_db_callback.Run(nullptr);
+  }
 }