Remove usage of singleton software_slot_ in nss on ChromeOS

chrome/browser/chromeos/ownership/owner_settings_service.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/ownership/owner_settings_service.h"
 
 #include <string>
 
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/login/users/user.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_factory.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "crypto/nss_util.h"
@@ skipping 75 matching lines @@
                                                username_hash,
                                                callback));
   if (!rv) {
     // IO thread doesn't exists in unit tests, but it's safe to use NSS from
     // BlockingPool in unit tests.
     LoadPrivateKeyByPublicKey(
         owner_key_util, public_key, username_hash, callback);
   }
 }
 
-bool IsPrivateKeyExistAsyncHelper(
+bool DoesPrivateKeyExistAsyncHelper(
     const scoped_refptr<OwnerKeyUtil>& owner_key_util) {
   std::vector<uint8> public_key;
   if (!owner_key_util->ImportPublicKey(&public_key))
     return false;
   scoped_ptr<crypto::RSAPrivateKey> key(
       crypto::RSAPrivateKey::FindFromPublicKeyInfo(public_key));
   bool is_owner = key.get() != NULL;
   return is_owner;
 }
 
+// Checks whether NSS slots with private key are mounted or
+// not. Responds via |callback|.
+void DoesPrivateKeyExistAsync(
+    const OwnerSettingsService::IsOwnerCallback& callback) {
+  scoped_refptr<OwnerKeyUtil> owner_key_util;
+  if (g_owner_key_util_for_testing)
+    owner_key_util = *g_owner_key_util_for_testing;
+  else
+    owner_key_util = OwnerKeyUtil::Create();
+  scoped_refptr<base::TaskRunner> task_runner =
+      content::BrowserThread::GetBlockingPool()
+          ->GetTaskRunnerWithShutdownBehavior(
+              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
+  base::PostTaskAndReplyWithResult(
+      task_runner.get(),
+      FROM_HERE,
+      base::Bind(&DoesPrivateKeyExistAsyncHelper, owner_key_util),
+      callback);
+}
+
 }  // namespace
 
 OwnerSettingsService::OwnerSettingsService(Profile* profile)
     : profile_(profile),
       owner_key_util_(OwnerKeyUtil::Create()),
       waiting_for_profile_creation_(true),
       waiting_for_tpm_token_(true),
       weak_factory_(this) {
   if (TPMTokenLoader::IsInitialized()) {
     waiting_for_tpm_token_ = !TPMTokenLoader::Get()->IsTPMTokenReady();
@@ skipping 64 matching lines @@
 void OwnerSettingsService::OnTPMTokenReady() {
   DCHECK(thread_checker_.CalledOnValidThread());
   waiting_for_tpm_token_ = false;
 
   // TPMTokenLoader initializes the TPM and NSS database which is necessary to
   // determine ownership. Force a reload once we know these are initialized.
   ReloadPrivateKey();
 }
 
 // static
-void OwnerSettingsService::IsPrivateKeyExistAsync(
+void OwnerSettingsService::IsOwnerForSafeModeAsync(
+    const std::string& user_id,
+    const std::string& user_hash,
     const IsOwnerCallback& callback) {
-  scoped_refptr<OwnerKeyUtil> owner_key_util;
-  if (g_owner_key_util_for_testing)
-    owner_key_util = *g_owner_key_util_for_testing;
-  else
-    owner_key_util = OwnerKeyUtil::Create();
-  scoped_refptr<base::TaskRunner> task_runner =
-      content::BrowserThread::GetBlockingPool()
-          ->GetTaskRunnerWithShutdownBehavior(
-              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
-  base::PostTaskAndReplyWithResult(
-      task_runner.get(),
+  CHECK(chromeos::LoginState::Get()->IsInSafeMode());
+
+  // Make sure NSS is initialized and NSS DB is loaded for the user before
+  // searching for the owner key.
+  BrowserThread::PostTaskAndReply(
+      BrowserThread::IO,
       FROM_HERE,
-      base::Bind(&IsPrivateKeyExistAsyncHelper, owner_key_util),
-      callback);
+      base::Bind(base::IgnoreResult(&crypto::InitializeNSSForChromeOSUser),
+                 user_id,
+                 user_hash,
+                 ProfileHelper::GetProfilePathByUserIdHash(user_hash)),
+      base::Bind(&DoesPrivateKeyExistAsync, callback));
 }
 
 // static
 void OwnerSettingsService::SetOwnerKeyUtilForTesting(
     const scoped_refptr<OwnerKeyUtil>& owner_key_util) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (g_owner_key_util_for_testing) {
     delete g_owner_key_util_for_testing;
     g_owner_key_util_for_testing = NULL;
   }
@@ skipping 56 matching lines @@
 DeviceSettingsService* OwnerSettingsService::GetDeviceSettingsService() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (g_device_settings_service_for_testing)
     return g_device_settings_service_for_testing;
   if (DeviceSettingsService::IsInitialized())
     return DeviceSettingsService::Get();
   return NULL;
 }
 
 }  // namespace chromeos