Add a unit test to check KeygenHandler's thread-safety

base/nss_util.cc

 // Copyright (c) 2008-2010 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 "base/nss_util.h"
 #include "base/nss_util_internal.h"
 
 #include <nss.h>
 #include <plarena.h>
 #include <prerror.h>
 #include <prinit.h>
 #include <prtime.h>
 #include <pk11pub.h>
 #include <secmod.h>
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
 
+#if defined(USE_NSS)
+#include "base/lock.h"
+#include "base/scoped_ptr.h"
+#endif // defined(USE_NSS)

[wtc, 2010/06/21 22:40:53]

Two spaces before the comment.

[davidben, 2010/06/22 02:54:56]

Done.

+
 // On some platforms, we use NSS for SSL only -- we don't use NSS for crypto
 // or certificate verification, and we don't use the NSS certificate and key
 // databases.
 #if defined(OS_MACOSX) || defined(OS_WIN)
 #define USE_NSS_FOR_SSL_ONLY 1
 #endif
 
 namespace {
 
 #if !defined(USE_NSS_FOR_SSL_ONLY)
@@ skipping 130 matching lines @@
     // If we haven't initialized the password for the NSS databases,
     // initialize an empty-string password so that we don't need to
     // log in.
     PK11SlotInfo* slot = PK11_GetInternalKeySlot();
     if (slot) {
       if (PK11_NeedUserInit(slot))
         PK11_InitPin(slot, NULL, NULL);
       PK11_FreeSlot(slot);
     }
 
+    // TODO(davidben): When https://bugzilla.mozilla.org/show_bug.cgi?id=564011
+    // is fixed, we will no longer need the lock. We should detect this and not
+    // initialize a Lock here.
+    write_lock_.reset(new Lock());
+
     root_ = InitDefaultRootCerts();
 #endif  // defined(USE_NSS_FOR_SSL_ONLY)
   }
 
   ~NSSInitSingleton() {
     if (real_db_slot_) {
       SECMOD_CloseUserDB(real_db_slot_);
       PK11_FreeSlot(real_db_slot_);
       real_db_slot_ = NULL;
     }
@@ skipping 31 matching lines @@
     }
   }
 #endif  // defined(OS_CHROMEOS)
 
   PK11SlotInfo* GetDefaultKeySlot() {
     if (real_db_slot_)
       return real_db_slot_;
     return PK11_GetInternalKeySlot();
   }
 
+#if defined(USE_NSS)
+  Lock* write_lock() {
+    return write_lock_.get();
+  }
+#endif // defined(USE_NSS)
+
  private:
   PK11SlotInfo* real_db_slot_;  // Overrides internal key slot if non-NULL.
   SECMODModule *root_;
   bool chromeos_user_logged_in_;
+#if defined(USE_NSS)
+  scoped_ptr<Lock> write_lock_;
+#endif // defined(USE_NSS)
 };
 
 }  // namespace
 
 namespace base {
 
 void EnsureNSPRInit() {
   Singleton<NSPRInitSingleton>::get();
 }
 
 void EnsureNSSInit() {
   Singleton<NSSInitSingleton>::get();
 }
 
+#if defined(USE_NSS)
+Lock* GetNSSWriteLock() {
+  return Singleton<NSSInitSingleton>::get()->write_lock();
+}
+
+AutoNSSWriteLock::AutoNSSWriteLock() : lock_(GetNSSWriteLock()) {
+  // May be NULL if the lock is not needed in our version of NSS.
+  if (lock_)
+    lock_->Acquire();
+}
+
+AutoNSSWriteLock::~AutoNSSWriteLock() {
+  if (lock_) {
+    lock_->AssertAcquired();
+    lock_->Release();
+  }
+}
+#endif // defined(USE_NSS)
+
 #if defined(OS_CHROMEOS)
 void OpenPersistentNSSDB() {
   Singleton<NSSInitSingleton>::get()->OpenPersistentNSSDB();
 }
 #endif
 
 // TODO(port): Implement this more simply.  We can convert by subtracting an
 // offset (the difference between NSPR's and base::Time's epochs).
 Time PRTimeToBaseTime(PRTime prtime) {
   PRExplodedTime prxtime;
@@ skipping 10 matching lines @@
   exploded.millisecond  = prxtime.tm_usec / 1000;
 
   return Time::FromUTCExploded(exploded);
 }
 
 PK11SlotInfo* GetDefaultNSSKeySlot() {
   return Singleton<NSSInitSingleton>::get()->GetDefaultKeySlot();
 }
 
 }  // namespace base