Replace c/b/nss_context by a KeyedService.

chrome/browser/chromeos/platform_keys/platform_keys_nss.cc

 // Copyright 2014 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/chromeos/platform_keys/platform_keys.h"
 
 #include <cryptohi.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api.h"
-#include "chrome/browser/net/nss_context.h"
+#include "chrome/browser/net/cert_database_service_factory.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 "crypto/rsa_private_key.h"
 #include "net/base/crypto_module.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_database.h"
 #include "net/cert/nss_cert_database.h"
 #include "net/cert/x509_certificate.h"
 
 using content::BrowserContext;
@@ skipping 65 matching lines @@
     if (!state->slot_) {
       LOG(ERROR) << "Slot for token id '" << token_id << "' not available.";
       state->OnError(FROM_HERE, kErrorInternal);
       return;
     }
   }
 
   callback.Run(cert_db);
 }
 
-// Retrieves the NSSCertDatabase from |context| and, if |token_id| is not empty,
-// the slot for |token_id|.
+// Retrieves the NSSCertDatabase from |db_io_part| and, if |token_id| is not
+// empty, the slot for |token_id|.
 // Must be called on the IO thread.
-void GetCertDatabaseOnIOThread(const std::string& token_id,
-                               const GetCertDBCallback& callback,
-                               content::ResourceContext* context,
-                               NSSOperationState* state) {
+void GetCertDatabaseOnIOThread(
+    const std::string& token_id,
+    const GetCertDBCallback& callback,
+    const base::WeakPtr<cert_database::CertDatabaseServiceIOPart>& db_io_part,
+    NSSOperationState* state) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  net::NSSCertDatabase* cert_db = GetNSSCertDatabaseForResourceContext(
-      context, base::Bind(&DidGetCertDBOnIOThread, token_id, callback, state));
+  DCHECK(state);
+  if (!db_io_part) {
+    LOG(ERROR) << "CertDatabase shutdown.";
+    state->OnError(FROM_HERE, kErrorInternal);
+    return;
+  }
+  net::NSSCertDatabase* cert_db = db_io_part->GetNSSCertDatabase(
+      base::Bind(&DidGetCertDBOnIOThread, token_id, callback, state));
 
   if (cert_db)
     DidGetCertDBOnIOThread(token_id, callback, state, cert_db);
 }
 
 // Asynchronously fetches the NSSCertDatabase for |browser_context| and, if
 // |token_id| is not empty, the slot for |token_id|. Stores the slot in |state|
 // and passes the database to |callback|. Will run |callback| on the IO thread.
 void GetCertDatabase(const std::string& token_id,
                      const GetCertDBCallback& callback,
                      BrowserContext* browser_context,
                      NSSOperationState* state) {
+  DCHECK(state);
+  // TODO(pneubeck): Pass in the CertDatabaseService instead of the
+  //   BrowserContext.
+  cert_database::CertDatabaseService* cert_db_service =
+      cert_database::CertDatabaseServiceFactory::GetForBrowserContext(
+          browser_context);
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&GetCertDatabaseOnIOThread,
                                      token_id,
                                      callback,
-                                     browser_context->GetResourceContext(),
+                                     cert_db_service->GetIOPart(),
                                      state));
 }
 
 class GenerateRSAKeyState : public NSSOperationState {
  public:
   GenerateRSAKeyState(unsigned int modulus_length_bits,
                       const subtle::GenerateKeyCallback& callback);
   virtual ~GenerateRSAKeyState() {}
 
   virtual void OnError(const tracked_objects::Location& from,
@@ skipping 512 matching lines @@
   NSSOperationState* state_ptr = state.get();
   GetCertDatabase(std::string() /* don't get any specific slot */,
                   base::Bind(&GetTokensWithDB, base::Passed(&state)),
                   browser_context,
                   state_ptr);
 }
 
 }  // namespace platform_keys
 
 }  // namespace chromeos