Add ClientCertStoreChromeOS which only returns the certs for a given user.

crypto/nss_util.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 "crypto/nss_util.h"
 #include "crypto/nss_util_internal.h"
 
 #include <nss.h>
 #include <pk11pub.h>
 #include <plarena.h>
@@ skipping 13 matching lines @@
 #include <map>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/cpu.h"
 #include "base/debug/alias.h"
 #include "base/debug/stack_trace.h"
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
-#include "base/files/scoped_temp_dir.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/native_library.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
@@ skipping 418 matching lines @@
     DCHECK(thread_checker_.CalledOnValidThread());
     DCHECK(chromeos_user_map_.find(username_hash) != chromeos_user_map_.end());
 
     if (test_slot_) {
       DVLOG(2) << "returning test_slot_ for " << username_hash;
       return ScopedPK11Slot(PK11_ReferenceSlot(test_slot_));
     }
 
     return chromeos_user_map_[username_hash]->GetPrivateSlot(callback);
   }
+
+  void CloseTestChromeOSUser(const std::string& username_hash) {
+    DCHECK(thread_checker_.CalledOnValidThread());
+    ChromeOSUserMap::iterator i = chromeos_user_map_.find(username_hash);
+    DCHECK(i != chromeos_user_map_.end());
+    delete i->second;
+    chromeos_user_map_.erase(i);
+  }
 #endif  // defined(OS_CHROMEOS)
 
 
   bool OpenTestNSSDB() {
     DCHECK(thread_checker_.CalledOnValidThread());
     // NSS is allowed to do IO on the current thread since dispatching
     // to a dedicated thread would still have the affect of blocking
     // the current thread, due to NSS's internal locking requirements
     base::ThreadRestrictions::ScopedAllowIO allow_io;
 
@@ skipping 489 matching lines @@
 }
 
 bool IsTPMTokenReady(const base::Closure& callback) {
   return g_nss_singleton.Get().IsTPMTokenReady(callback);
 }
 
 bool InitializeTPMToken(int token_slot_id) {
   return g_nss_singleton.Get().InitializeTPMToken(token_slot_id);
 }
 
+ScopedTestNSSChromeOSUser::ScopedTestNSSChromeOSUser(
+    const std::string& username_hash)
+    : username_hash_(username_hash), constructed_successfully_(false) {
+  if (!temp_dir_.CreateUniqueTempDir())
+    return;
+  constructed_successfully_ =
+      InitializeNSSForChromeOSUser(username_hash,
+                                   username_hash,
+                                   false /* is_primary_user */,
+                                   temp_dir_.path());
+}
+
+ScopedTestNSSChromeOSUser::~ScopedTestNSSChromeOSUser() {
+  if (constructed_successfully_)
+    g_nss_singleton.Get().CloseTestChromeOSUser(username_hash_);
+}
+
+void ScopedTestNSSChromeOSUser::FinishInit() {
+  InitializePrivateSoftwareSlotForChromeOSUser(username_hash_);
+}
+
 bool InitializeNSSForChromeOSUser(
     const std::string& email,
     const std::string& username_hash,
     bool is_primary_user,
     const base::FilePath& path) {
   return g_nss_singleton.Get().InitializeNSSForChromeOSUser(
       email, username_hash, is_primary_user, path);
 }
 void InitializeTPMForChromeOSUser(
     const std::string& username_hash,
@@ skipping 27 matching lines @@
 
 PK11SlotInfo* GetPublicNSSKeySlot() {
   return g_nss_singleton.Get().GetPublicNSSKeySlot();
 }
 
 PK11SlotInfo* GetPrivateNSSKeySlot() {
   return g_nss_singleton.Get().GetPrivateNSSKeySlot();
 }
 
 }  // namespace crypto