Replace c/b/nss_context by a KeyedService.

chrome/browser/ui/crypto_module_delegate_nss.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 "chrome/browser/ui/crypto_module_delegate_nss.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
-#include "chrome/browser/net/nss_context.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 ChromeNSSCryptoModuleDelegate::ChromeNSSCryptoModuleDelegate(
     chrome::CryptoModulePasswordReason reason,
     const net::HostPortPair& server)
     : reason_(reason),
       server_(server),
       event_(false, false),
       cancelled_(false) {}
 
 ChromeNSSCryptoModuleDelegate::~ChromeNSSCryptoModuleDelegate() {}
 
 bool ChromeNSSCryptoModuleDelegate::InitializeSlot(
-    content::ResourceContext* context,
-    const base::Closure& initialization_complete_callback) {
+    const base::Closure& initialization_complete_callback,
+    CertDatabaseServiceIOPart* cert_db_io) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!slot_);
-  base::Callback<void(crypto::ScopedPK11Slot)> get_slot_callback;
-  if (!initialization_complete_callback.is_null())
-    get_slot_callback = base::Bind(&ChromeNSSCryptoModuleDelegate::DidGetSlot,
-                                   // Caller is responsible for keeping |this|
-                                   // alive until the callback is run.
-                                   base::Unretained(this),
-                                   initialization_complete_callback);
+  base::Callback<void(net::NSSCertDatabase*)> get_nss_cert_db_callback;
+  if (!initialization_complete_callback.is_null()) {
+    get_nss_cert_db_callback =
+        base::Bind(&ChromeNSSCryptoModuleDelegate::DidGetNSSCertDB,
+                   // Caller is responsible for keeping |this|
+                   // alive until the callback is run.
+                   base::Unretained(this),
+                   initialization_complete_callback);
+  }
 
-  slot_ = GetPrivateNSSKeySlotForResourceContext(context, get_slot_callback);
+  net::NSSCertDatabase* nss_cert_db =
+      cert_db_io->GetNSSCertDatabase(get_nss_cert_db_callback);
+  if (nss_cert_db)
+    slot_ = nss_cert_db->GetPrivateSlot();
   return slot_.get() != NULL;
 }
 
 // TODO(mattm): allow choosing which slot to generate and store the key.
 crypto::ScopedPK11Slot ChromeNSSCryptoModuleDelegate::RequestSlot() {
   return slot_.Pass();
 }
 
 std::string ChromeNSSCryptoModuleDelegate::RequestPassword(
     const std::string& slot_name,
@@ skipping 33 matching lines @@
 }
 
 void ChromeNSSCryptoModuleDelegate::GotPassword(const std::string& password) {
   if (!password.empty())
     password_ = password;
   else
     cancelled_ = true;
   event_.Signal();
 }
 
-void ChromeNSSCryptoModuleDelegate::DidGetSlot(const base::Closure& callback,
-                                               crypto::ScopedPK11Slot slot) {
+void ChromeNSSCryptoModuleDelegate::DidGetNSSCertDB(
+    const base::Closure& callback,
+    net::NSSCertDatabase* nss_cert_db) {
   DCHECK(!slot_);
-  slot_ = slot.Pass();
+  slot_ = nss_cert_db->GetPrivateSlot();
   callback.Run();
 }
 
 crypto::CryptoModuleBlockingPasswordDelegate*
 CreateCryptoModuleBlockingPasswordDelegate(
     chrome::CryptoModulePasswordReason reason,
     const net::HostPortPair& server) {
   // Returns a ChromeNSSCryptoModuleDelegate without calling InitializeSlot.
   // Since it is only being used as a CreateCryptoModuleBlockingDialogDelegate,
   // initializing the slot handle is unnecessary.
   return new ChromeNSSCryptoModuleDelegate(reason, server);
 }