--- a/content/media/nsMediaDecoder.cpp
+++ b/content/media/nsMediaDecoder.cpp
@@ -84,26 +84,26 @@ nsMediaDecoder::nsMediaDecoder() :
mShuttingDown(PR_FALSE)
{
MOZ_COUNT_CTOR(nsMediaDecoder);
}
nsMediaDecoder::~nsMediaDecoder()
{
if (mVideoUpdateLock) {
- PR_DestroyLock(mVideoUpdateLock);
+ nsAutoLock::DestroyLock(mVideoUpdateLock);
mVideoUpdateLock = nsnull;
}
MOZ_COUNT_DTOR(nsMediaDecoder);
}
PRBool nsMediaDecoder::Init(nsHTMLMediaElement* aElement)
{
mElement = aElement;
- mVideoUpdateLock = PR_NewLock();
+ mVideoUpdateLock = nsAutoLock::NewLock("nsMediaDecoder::mVideoUpdateLock");
return mVideoUpdateLock != nsnull;
}
void nsMediaDecoder::Shutdown()
{
StopProgress();
mElement = nsnull;
--- a/embedding/components/windowwatcher/src/nsWindowWatcher.cpp
+++ b/embedding/components/windowwatcher/src/nsWindowWatcher.cpp
@@ -344,23 +344,23 @@ nsWindowWatcher::nsWindowWatcher() :
nsWindowWatcher::~nsWindowWatcher()
{
// delete data
while (mOldestWindow)
RemoveWindow(mOldestWindow);
if (mListLock)
- PR_DestroyLock(mListLock);
+ nsAutoLock::DestroyLock(mListLock);
}
nsresult
nsWindowWatcher::Init()
{
- mListLock = PR_NewLock();
+ mListLock = nsAutoLock::NewLock("nsWindowWatcher::mListLock");
if (!mListLock)
return NS_ERROR_OUT_OF_MEMORY;
return NS_OK;
}
NS_IMETHODIMP
nsWindowWatcher::OpenWindow(nsIDOMWindow *aParent,
const char *aUrl,
--- a/extensions/java/xpcom/src/nsJavaXPCOMBindingUtils.cpp
+++ b/extensions/java/xpcom/src/nsJavaXPCOMBindingUtils.cpp
@@ -329,17 +329,17 @@ InitializeJavaGlobals(JNIEnv *env)
}
}
if (NS_FAILED(rv)) {
NS_WARNING("Failed to populate JavaKeywords hash");
goto init_error;
}
}
- gJavaXPCOMLock = PR_NewLock();
+ gJavaXPCOMLock = nsAutoLock::NewLock("gJavaXPCOMLock");
gJavaXPCOMInitialized = PR_TRUE;
return PR_TRUE;
init_error:
// If we encounter an error during initialization, then free any globals that
// were allocated, and return false.
FreeJavaGlobals(env);
return PR_FALSE;
@@ -435,17 +435,17 @@ FreeJavaGlobals(JNIEnv* env)
if (gJavaKeywords) {
delete gJavaKeywords;
gJavaKeywords = nsnull;
}
if (tempLock) {
PR_Unlock(tempLock);
- PR_DestroyLock(tempLock);
+ nsAutoLock::DestroyLock(tempLock);
}
}
/**************************************
* Java<->XPCOM object mappings
**************************************/
--- a/intl/strres/src/nsStringBundle.cpp
+++ b/intl/strres/src/nsStringBundle.cpp
@@ -76,17 +76,17 @@
#include "nsCRT.h"
static NS_DEFINE_CID(kErrorServiceCID, NS_ERRORSERVICE_CID);
static NS_DEFINE_CID(kPersistentPropertiesCID, NS_IPERSISTENTPROPERTIES_CID);
nsStringBundle::~nsStringBundle()
{
if (mMonitor)
- PR_DestroyMonitor(mMonitor);
+ nsAutoMonitor::DestroyMonitor(mMonitor);
}
nsStringBundle::nsStringBundle(const char* aURLSpec,
nsIStringBundleOverride* aOverrideStrings) :
mPropertiesURL(aURLSpec),
mOverrideStrings(aOverrideStrings),
mMonitor(0),
mAttemptedLoad(PR_FALSE),
--- a/js/src/xpconnect/src/xpcthreadcontext.cpp
+++ b/js/src/xpconnect/src/xpcthreadcontext.cpp
@@ -414,17 +414,17 @@ XPCPerThreadData::~XPCPerThreadData()
}
}
if (!gThreads)
doDestroyLock = PR_TRUE;
}
if(gLock && doDestroyLock)
{
- PR_DestroyLock(gLock);
+ nsAutoLock::DestroyLock(gLock);
gLock = nsnull;
}
}
static void
xpc_ThreadDataDtorCB(void* ptr)
{
XPCPerThreadData* data = (XPCPerThreadData*) ptr;
@@ -460,17 +460,17 @@ void XPCPerThreadData::MarkAutoRootsAfte
// static
XPCPerThreadData*
XPCPerThreadData::GetDataImpl(JSContext *cx)
{
XPCPerThreadData* data;
if(!gLock)
{
- gLock = PR_NewLock();
+ gLock = nsAutoLock::NewLock("XPCPerThreadData::gLock");
if(!gLock)
return nsnull;
}
if(gTLSIndex == BAD_TLS_INDEX)
{
nsAutoLock lock(gLock);
// check again now that we have the lock...
--- a/modules/libjar/nsJAR.cpp
+++ b/modules/libjar/nsJAR.cpp
@@ -167,17 +167,17 @@ nsrefcnt nsJAR::Release(void)
NS_IMETHODIMP
nsJAR::Open(nsIFile* zipFile)
{
NS_ENSURE_ARG_POINTER(zipFile);
if (mLock) return NS_ERROR_FAILURE; // Already open!
mZipFile = zipFile;
- mLock = PR_NewLock();
+ mLock = nsAutoLock::NewLock("nsJAR::mLock");
NS_ENSURE_TRUE(mLock, NS_ERROR_OUT_OF_MEMORY);
#ifdef MOZ_OMNIJAR
// The omnijar is special, it is opened early on and closed late
// this avoids reopening it
PRBool equals;
nsresult rv = zipFile->Equals(mozilla::OmnijarPath(), &equals);
if (NS_SUCCEEDED(rv) && equals) {
@@ -198,17 +198,17 @@ nsJAR::OpenInner(nsIZipReader *aZipReade
PRBool exist;
nsresult rv = aZipReader->HasEntry(nsDependentCString(aZipEntry), &exist);
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_TRUE(exist, NS_ERROR_FILE_NOT_FOUND);
rv = aZipReader->GetFile(getter_AddRefs(mZipFile));
NS_ENSURE_SUCCESS(rv, rv);
- mLock = PR_NewLock();
+ mLock = nsAutoLock::NewLock("nsJAR::mLock");
NS_ENSURE_TRUE(mLock, NS_ERROR_OUT_OF_MEMORY);
mOuterZipEntry.Assign(aZipEntry);
nsRefPtr<nsZipHandle> handle;
rv = nsZipHandle::Init(static_cast<nsJAR*>(aZipReader)->mZip.get(), aZipEntry,
getter_AddRefs(handle));
if (NS_FAILED(rv))
@@ -224,17 +224,17 @@ nsJAR::GetFile(nsIFile* *result)
NS_IF_ADDREF(*result);
return NS_OK;
}
NS_IMETHODIMP
nsJAR::Close()
{
if (mLock) {
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
mLock = nsnull;
}
mParsedManifest = PR_FALSE;
mManifestData.Reset();
mGlobalStatus = JAR_MANIFEST_NOT_PARSED;
mTotalItemsInManifest = 0;
mOuterZipEntry.Truncate(0);
@@ -1083,32 +1083,32 @@ nsZipReaderCache::Init(PRUint32 cacheSiz
if (os)
{
os->AddObserver(this, "memory-pressure", PR_TRUE);
os->AddObserver(this, "chrome-flush-caches", PR_TRUE);
os->AddObserver(this, "flush-cache-entry", PR_TRUE);
}
// ignore failure of the observer registration.
- mLock = PR_NewLock();
+ mLock = nsAutoLock::NewLock("nsZipReaderCache::mLock");
return mLock ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
static PRBool
DropZipReaderCache(nsHashKey *aKey, void *aData, void* closure)
{
nsJAR* zip = (nsJAR*)aData;
zip->SetZipReaderCache(nsnull);
return PR_TRUE;
}
nsZipReaderCache::~nsZipReaderCache()
{
if (mLock)
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
mZips.Enumerate(DropZipReaderCache, nsnull);
#ifdef ZIP_CACHE_HIT_RATE
printf("nsZipReaderCache size=%d hits=%d lookups=%d rate=%f%% flushes=%d missed %d\n",
mCacheSize, mZipCacheHits, mZipCacheLookups,
(float)mZipCacheHits / mZipCacheLookups,
mZipCacheFlushes, mZipSyncMisses);
#endif
--- a/netwerk/base/src/nsAsyncStreamCopier.cpp
+++ b/netwerk/base/src/nsAsyncStreamCopier.cpp
@@ -67,17 +67,17 @@ nsAsyncStreamCopier::nsAsyncStreamCopier
#endif
LOG(("Creating nsAsyncStreamCopier @%x\n", this));
}
nsAsyncStreamCopier::~nsAsyncStreamCopier()
{
LOG(("Destroying nsAsyncStreamCopier @%x\n", this));
if (mLock)
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
}
PRBool
nsAsyncStreamCopier::IsComplete(nsresult *status)
{
nsAutoLock lock(mLock);
if (status)
*status = mStatus;
@@ -225,17 +225,17 @@ nsAsyncStreamCopier::Init(nsIInputStream
PRBool sinkBuffered,
PRUint32 chunkSize,
PRBool closeSource,
PRBool closeSink)
{
NS_ASSERTION(sourceBuffered || sinkBuffered, "at least one stream must be buffered");
NS_ASSERTION(!mLock, "already initialized");
- mLock = PR_NewLock();
+ mLock = nsAutoLock::NewLock("nsAsyncStreamCopier::mLock");
if (!mLock)
return NS_ERROR_OUT_OF_MEMORY;
if (chunkSize == 0)
chunkSize = nsIOService::gDefaultSegmentSize;
mChunkSize = chunkSize;
mSource = source;
--- a/netwerk/base/src/nsIOThreadPool.cpp
+++ b/netwerk/base/src/nsIOThreadPool.cpp
@@ -106,17 +106,17 @@ nsIOThreadPool::Init()
if (!gIOThreadPoolLog)
gIOThreadPoolLog = PR_NewLogModule("nsIOThreadPool");
#endif
mNumThreads = 0;
mNumIdleThreads = 0;
mShutdown = PR_FALSE;
- mLock = PR_NewLock();
+ mLock = nsAutoLock::NewLock("nsIOThreadPool::mLock");
if (!mLock)
return NS_ERROR_OUT_OF_MEMORY;
mIdleThreadCV = PR_NewCondVar(mLock);
if (!mIdleThreadCV)
return NS_ERROR_OUT_OF_MEMORY;
mExitThreadCV = PR_NewCondVar(mLock);
@@ -141,17 +141,17 @@ nsIOThreadPool::~nsIOThreadPool()
NS_ASSERTION(mNumThreads == 0, "leaking thread(s)");
#endif
if (mIdleThreadCV)
PR_DestroyCondVar(mIdleThreadCV);
if (mExitThreadCV)
PR_DestroyCondVar(mExitThreadCV);
if (mLock)
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
}
void
nsIOThreadPool::Shutdown()
{
LOG(("nsIOThreadPool::Shutdown\n"));
// synchronize with background threads...
--- a/netwerk/base/src/nsServerSocket.cpp
+++ b/netwerk/base/src/nsServerSocket.cpp
@@ -87,17 +87,17 @@ nsServerSocket::nsServerSocket()
NS_IF_ADDREF(gSocketTransportService);
}
nsServerSocket::~nsServerSocket()
{
Close(); // just in case :)
if (mLock)
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
// release our reference to the STS
nsSocketTransportService *serv = gSocketTransportService;
NS_IF_RELEASE(serv);
}
void
nsServerSocket::OnMsgClose()
@@ -287,17 +287,17 @@ nsServerSocket::Init(PRInt32 aPort, PRBo
NS_IMETHODIMP
nsServerSocket::InitWithAddress(const PRNetAddr *aAddr, PRInt32 aBackLog)
{
NS_ENSURE_TRUE(mFD == nsnull, NS_ERROR_ALREADY_INITIALIZED);
if (!mLock)
{
- mLock = PR_NewLock();
+ mLock = nsAutoLock::NewLock("nsServerSocket::mLock");
if (!mLock)
return NS_ERROR_OUT_OF_MEMORY;
}
//
// configure listening socket...
//
--- a/netwerk/base/src/nsSocketTransport2.cpp
+++ b/netwerk/base/src/nsSocketTransport2.cpp
@@ -708,17 +708,17 @@ nsSocketTransport::nsSocketTransport()
, mProxyTransparent(PR_FALSE)
, mProxyTransparentResolvesHost(PR_FALSE)
, mConnectionFlags(0)
, mState(STATE_CLOSED)
, mAttached(PR_FALSE)
, mInputClosed(PR_TRUE)
, mOutputClosed(PR_TRUE)
, mResolving(PR_FALSE)
- , mLock(PR_NewLock())
+ , mLock(nsAutoLock::NewLock("nsSocketTransport::mLock"))
, mFD(nsnull)
, mFDref(0)
, mFDconnected(PR_FALSE)
, mInput(this)
, mOutput(this)
, mQoSBits(0x00)
{
SOCKET_LOG(("creating nsSocketTransport @%x\n", this));
@@ -737,17 +737,17 @@ nsSocketTransport::~nsSocketTransport()
if (mTypes) {
PRUint32 i;
for (i=0; i<mTypeCount; ++i)
PL_strfree(mTypes[i]);
free(mTypes);
}
if (mLock)
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
nsSocketTransportService *serv = gSocketTransportService;
NS_RELEASE(serv); // nulls argument
}
nsresult
nsSocketTransport::Init(const char **types, PRUint32 typeCount,
const nsACString &host, PRUint16 port,
--- a/netwerk/base/src/nsSocketTransportService2.cpp
+++ b/netwerk/base/src/nsSocketTransportService2.cpp
@@ -67,17 +67,17 @@ PRThread *gSocketThread
//-----------------------------------------------------------------------------
// ctor/dtor (called on the main/UI thread by the service manager)
nsSocketTransportService::nsSocketTransportService()
: mThread(nsnull)
, mThreadEvent(nsnull)
, mAutodialEnabled(PR_FALSE)
- , mLock(PR_NewLock())
+ , mLock(nsAutoLock::NewLock("nsSocketTransportService::mLock"))
, mInitialized(PR_FALSE)
, mShuttingDown(PR_FALSE)
, mActiveCount(0)
, mIdleCount(0)
, mSendBufferSize(0)
{
#if defined(PR_LOGGING)
gSocketTransportLog = PR_NewLogModule("nsSocketTransport");
@@ -90,17 +90,17 @@ nsSocketTransportService::nsSocketTransp
}
nsSocketTransportService::~nsSocketTransportService()
{
NS_ASSERTION(NS_IsMainThread(), "wrong thread");
NS_ASSERTION(!mInitialized, "not shutdown properly");
if (mLock)
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
if (mThreadEvent)
PR_DestroyPollableEvent(mThreadEvent);
gSocketTransportService = nsnull;
}
//-----------------------------------------------------------------------------
--- a/netwerk/base/src/nsTransportUtils.cpp
+++ b/netwerk/base/src/nsTransportUtils.cpp
@@ -52,27 +52,27 @@ public:
NS_DECL_ISUPPORTS
NS_DECL_NSITRANSPORTEVENTSINK
nsTransportEventSinkProxy(nsITransportEventSink *sink,
nsIEventTarget *target,
PRBool coalesceAll)
: mSink(sink)
, mTarget(target)
- , mLock(PR_NewLock())
+ , mLock(nsAutoLock::NewLock("nsTransportEventSinkProxy::mLock"))
, mLastEvent(nsnull)
, mCoalesceAll(coalesceAll)
{
NS_ADDREF(mSink);
}
virtual ~nsTransportEventSinkProxy()
{
if (mLock)
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
// our reference to mSink could be the last, so be sure to release
// it on the target thread. otherwise, we could get into trouble.
NS_ProxyRelease(mTarget, mSink);
}
nsITransportEventSink *mSink;
nsCOMPtr<nsIEventTarget> mTarget;
--- a/netwerk/dns/nsDNSService2.cpp
+++ b/netwerk/dns/nsDNSService2.cpp
@@ -308,17 +308,17 @@ nsDNSSyncRequest::OnLookupComplete(nsHos
nsDNSService::nsDNSService()
: mLock(nsnull)
{
}
nsDNSService::~nsDNSService()
{
if (mLock)
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
}
NS_IMPL_THREADSAFE_ISUPPORTS3(nsDNSService, nsIDNSService, nsPIDNSService,
nsIObserver)
NS_IMETHODIMP
nsDNSService::Init()
{
@@ -353,17 +353,17 @@ nsDNSService::Init()
prefs->GetCharPref(kPrefIPv4OnlyDomains, getter_Copies(ipv4OnlyDomains));
prefs->GetBoolPref(kPrefDisablePrefetch, &disablePrefetch);
// If a manual proxy is in use, disable prefetch implicitly
prefs->GetIntPref("network.proxy.type", &proxyType);
}
if (firstTime) {
- mLock = PR_NewLock();
+ mLock = nsAutoLock::NewLock("nsDNSService::mLock");
if (!mLock)
return NS_ERROR_OUT_OF_MEMORY;
// register as prefs observer
if (prefs) {
prefs->AddObserver(kPrefDnsCacheEntries, this, PR_FALSE);
prefs->AddObserver(kPrefDnsCacheExpiration, this, PR_FALSE);
prefs->AddObserver(kPrefEnableIDN, this, PR_FALSE);
--- a/netwerk/dns/nsHostResolver.cpp
+++ b/netwerk/dns/nsHostResolver.cpp
@@ -350,27 +350,27 @@ nsHostResolver::nsHostResolver(PRUint32
}
nsHostResolver::~nsHostResolver()
{
if (mIdleThreadCV)
PR_DestroyCondVar(mIdleThreadCV);
if (mLock)
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
PL_DHashTableFinish(&mDB);
}
nsresult
nsHostResolver::Init()
{
NS_TIME_FUNCTION;
- mLock = PR_NewLock();
+ mLock = nsAutoLock::NewLock("nsHostResolver::mLock");
if (!mLock)
return NS_ERROR_OUT_OF_MEMORY;
mIdleThreadCV = PR_NewCondVar(mLock);
if (!mIdleThreadCV)
return NS_ERROR_OUT_OF_MEMORY;
PL_DHashTableInit(&mDB, &gHostDB_ops, nsnull, sizeof(nsHostDBEnt), 0);
--- a/netwerk/protocol/http/nsHttp.cpp
+++ b/netwerk/protocol/http/nsHttp.cpp
@@ -124,17 +124,17 @@ static const PLDHashTableOps ops = {
// We put the atoms in a hash table for speedy lookup.. see ResolveAtom.
nsresult
nsHttp::CreateAtomTable()
{
NS_ASSERTION(!sAtomTable.ops, "atom table already initialized");
if (!sLock) {
- sLock = PR_NewLock();
+ sLock = nsAutoLock::NewLock("nsHttp::sLock");
if (!sLock)
return NS_ERROR_OUT_OF_MEMORY;
}
// The capacity for this table is initialized to a value greater than the
// number of known atoms (NUM_HTTP_ATOMS) because we expect to encounter a
// few random headers right off the bat.
if (!PL_DHashTableInit(&sAtomTable, &ops, nsnull, sizeof(PLDHashEntryStub),
@@ -174,17 +174,17 @@ nsHttp::DestroyAtomTable()
while (sHeapAtoms) {
HttpHeapAtom *next = sHeapAtoms->next;
free(sHeapAtoms);
sHeapAtoms = next;
}
if (sLock) {
- PR_DestroyLock(sLock);
+ nsAutoLock::DestroyLock(sLock);
sLock = nsnull;
}
}
// this function may be called from multiple threads
nsHttpAtom
nsHttp::ResolveAtom(const char *str)
{
--- a/netwerk/protocol/http/nsHttpActivityDistributor.cpp
+++ b/netwerk/protocol/http/nsHttpActivityDistributor.cpp
@@ -93,17 +93,17 @@ NS_IMPL_THREADSAFE_ISUPPORTS2(nsHttpActi
nsHttpActivityDistributor::nsHttpActivityDistributor()
: mLock(nsnull)
{
}
nsHttpActivityDistributor::~nsHttpActivityDistributor()
{
if (mLock)
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
}
NS_IMETHODIMP
nsHttpActivityDistributor::ObserveActivity(nsISupports *aHttpChannel,
PRUint32 aActivityType,
PRUint32 aActivitySubtype,
PRTime aTimestamp,
PRUint64 aExtraSizeData,
@@ -156,14 +156,14 @@ nsHttpActivityDistributor::RemoveObserve
return NS_OK;
}
nsresult
nsHttpActivityDistributor::Init()
{
NS_ENSURE_TRUE(!mLock, NS_ERROR_ALREADY_INITIALIZED);
- mLock = PR_NewLock();
+ mLock = nsAutoLock::NewLock("nsHttpActivityDistributor::mLock");
if (!mLock)
return NS_ERROR_OUT_OF_MEMORY;
return NS_OK;
}
--- a/netwerk/test/TestStreamTransport.cpp
+++ b/netwerk/test/TestStreamTransport.cpp
@@ -85,17 +85,17 @@ public:
: mLock(nsnull)
, mInputCondition(NS_OK)
{
}
virtual ~MyCopier()
{
if (mLock)
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
if (mInput)
mInput->Close();
if (mOutput)
mOutput->Close();
}
// called on any thread
NS_IMETHOD OnInputStreamReady(nsIAsyncInputStream *inStr)
@@ -146,17 +146,17 @@ public:
Close_Locked();
break;
}
}
}
nsresult AsyncCopy(nsITransport *srcTrans, nsITransport *destTrans)
{
- mLock = PR_NewLock();
+ mLock = nsAutoLock::NewLock("MyCopier::mLock");
if (!mLock)
return NS_ERROR_OUT_OF_MEMORY;
nsresult rv;
nsCOMPtr<nsIInputStream> inStr;
rv = srcTrans->OpenInputStream(0, 0, 0, getter_AddRefs(inStr));
if (NS_FAILED(rv)) return rv;
--- a/security/manager/ssl/src/nsNSSCallbacks.cpp
+++ b/security/manager/ssl/src/nsNSSCallbacks.cpp
@@ -563,41 +563,41 @@ nsHTTPListener::nsHTTPListener()
mResponsibleForDoneSignal(PR_FALSE),
mLoadGroup(nsnull),
mLoadGroupOwnerThread(nsnull)
{
}
nsresult nsHTTPListener::InitLocks()
{
- mLock = PR_NewLock();
+ mLock = nsAutoLock::NewLock("nsHttpListener::mLock");
if (!mLock)
return NS_ERROR_OUT_OF_MEMORY;
mCondition = PR_NewCondVar(mLock);
if (!mCondition)
{
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
mLock = nsnull;
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
nsHTTPListener::~nsHTTPListener()
{
if (mResponsibleForDoneSignal)
send_done_signal();
if (mCondition)
PR_DestroyCondVar(mCondition);
if (mLock)
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
if (mLoader) {
nsCOMPtr<nsIThread> mainThread(do_GetMainThread());
NS_ProxyRelease(mainThread, mLoader);
}
}
NS_IMPL_THREADSAFE_ISUPPORTS1(nsHTTPListener, nsIStreamLoaderObserver)
--- a/security/manager/ssl/src/nsNSSCertCache.cpp
+++ b/security/manager/ssl/src/nsNSSCertCache.cpp
@@ -42,17 +42,17 @@
#include "nsIInterfaceRequestor.h"
#include "nsNSSHelper.h"
NS_IMPL_THREADSAFE_ISUPPORTS1(nsNSSCertCache, nsINSSCertCache)
nsNSSCertCache::nsNSSCertCache()
:mCertList(nsnull)
{
- mutex = PR_NewLock();
+ mutex = nsAutoLock::NewLock("nsNSSCertCache::mutex");
}
nsNSSCertCache::~nsNSSCertCache()
{
nsNSSShutDownPreventionLock locker;
if (isAlreadyShutDown())
return;
@@ -66,17 +66,17 @@ void nsNSSCertCache::virtualDestroyNSSRe
}
void nsNSSCertCache::destructorSafeDestroyNSSReference()
{
if (isAlreadyShutDown())
return;
if (mutex) {
- PR_DestroyLock(mutex);
+ nsAutoLock::DestroyLock(mutex);
mutex = nsnull;
}
}
NS_IMETHODIMP
nsNSSCertCache::CacheAllCerts()
{
nsNSSShutDownPreventionLock locker;
--- a/security/manager/ssl/src/nsNSSComponent.cpp
+++ b/security/manager/ssl/src/nsNSSComponent.cpp
@@ -366,17 +366,17 @@ PRBool EnsureNSSInitialized(EnsureNSSOpe
return PR_FALSE;
}
}
nsNSSComponent::nsNSSComponent()
:mNSSInitialized(PR_FALSE), mThreadList(nsnull),
mSSLThread(NULL), mCertVerificationThread(NULL)
{
- mutex = PR_NewLock();
+ mutex = nsAutoLock::NewLock("nsNSSComponent::mutex");
#ifdef PR_LOGGING
if (!gPIPNSSLog)
gPIPNSSLog = PR_NewLogModule("pipnss");
#endif
PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("nsNSSComponent::ctor\n"));
mUpdateTimerInitialized = PR_FALSE;
crlDownloadTimerOn = PR_FALSE;
@@ -433,17 +433,17 @@ nsNSSComponent::~nsNSSComponent()
// All cleanup code requiring services needs to happen in xpcom_shutdown
ShutdownNSS();
nsSSLIOLayerHelpers::Cleanup();
--mInstanceCount;
delete mShutdownObjectList;
if (mutex) {
- PR_DestroyLock(mutex);
+ nsAutoLock::DestroyLock(mutex);
mutex = nsnull;
}
// We are being freed, drop the haveLoaded flag to re-enable
// potential nss initialization later.
EnsureNSSInitialized(nssShutdown);
PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("nsNSSComponent::dtor finished\n"));
--- a/security/manager/ssl/src/nsNSSIOLayer.cpp
+++ b/security/manager/ssl/src/nsNSSIOLayer.cpp
@@ -931,17 +931,17 @@ void nsSSLIOLayerHelpers::Cleanup()
delete mRenegoUnrestrictedSites;
mRenegoUnrestrictedSites = nsnull;
}
if (mSharedPollableEvent)
PR_DestroyPollableEvent(mSharedPollableEvent);
if (mutex) {
- PR_DestroyLock(mutex);
+ nsAutoLock::DestroyLock(mutex);
mutex = nsnull;
}
if (mHostsWithCertErrors) {
delete mHostsWithCertErrors;
mHostsWithCertErrors = nsnull;
}
}
@@ -2270,17 +2270,17 @@ nsresult nsSSLIOLayerHelpers::Init()
nsSSLIOLayerMethods.connect = nsSSLIOLayerConnect;
nsSSLIOLayerMethods.close = nsSSLIOLayerClose;
nsSSLIOLayerMethods.write = nsSSLIOLayerWrite;
nsSSLIOLayerMethods.read = nsSSLIOLayerRead;
nsSSLIOLayerMethods.poll = nsSSLIOLayerPoll;
}
- mutex = PR_NewLock();
+ mutex = nsAutoLock::NewLock("nsSSLIOLayerHelpers::mutex");
if (!mutex)
return NS_ERROR_OUT_OF_MEMORY;
mSharedPollableEvent = PR_NewPollableEvent();
// if we can not get a pollable event, we'll have to do busy waiting
mTLSIntolerantSites = new nsCStringHashSet();
--- a/security/manager/ssl/src/nsPSMBackgroundThread.cpp
+++ b/security/manager/ssl/src/nsPSMBackgroundThread.cpp
@@ -45,17 +45,17 @@ void PR_CALLBACK nsPSMBackgroundThread::
}
nsPSMBackgroundThread::nsPSMBackgroundThread()
: mThreadHandle(nsnull),
mMutex(nsnull),
mCond(nsnull),
mExitRequested(PR_FALSE)
{
- mMutex = PR_NewLock();
+ mMutex = nsAutoLock::NewLock("nsPSMBackgroundThread::mMutex");
mCond = PR_NewCondVar(mMutex);
}
nsresult nsPSMBackgroundThread::startThread()
{
if (!mMutex || !mCond)
return NS_ERROR_OUT_OF_MEMORY;
@@ -71,17 +71,17 @@ nsresult nsPSMBackgroundThread::startThr
}
nsPSMBackgroundThread::~nsPSMBackgroundThread()
{
if (mCond)
PR_DestroyCondVar(mCond);
if (mMutex)
- PR_DestroyLock(mMutex);
+ nsAutoLock::DestroyLock(mMutex);
}
void nsPSMBackgroundThread::requestExit()
{
if (!mThreadHandle)
return;
{
--- a/toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
+++ b/toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
@@ -1347,20 +1347,20 @@ nsUrlClassifierDBServiceWorker::nsUrlCla
nsUrlClassifierDBServiceWorker::~nsUrlClassifierDBServiceWorker()
{
NS_ASSERTION(!mConnection,
"Db connection not closed, leaking memory! Call CloseDb "
"to close the connection.");
if (mCleanHostKeysLock)
- PR_DestroyLock(mCleanHostKeysLock);
+ nsAutoLock::DestroyLock(mCleanHostKeysLock);
if (mPendingLookupLock)
- PR_DestroyLock(mPendingLookupLock);
+ nsAutoLock::DestroyLock(mPendingLookupLock);
}
nsresult
nsUrlClassifierDBServiceWorker::Init(PRInt32 gethashNoise)
{
mGethashNoise = gethashNoise;
// Compute database filename
@@ -1375,27 +1375,29 @@ nsUrlClassifierDBServiceWorker::Init(PRI
getter_AddRefs(mDBFile));
}
if (NS_FAILED(rv)) return NS_ERROR_NOT_AVAILABLE;
rv = mDBFile->Append(NS_LITERAL_STRING(DATABASE_FILENAME));
NS_ENSURE_SUCCESS(rv, rv);
- mCleanHostKeysLock = PR_NewLock();
+ mCleanHostKeysLock =
+ nsAutoLock::NewLock("nsUrlClassifierDBServiceWorker::mCleanHostKeysLock");
if (!mCleanHostKeysLock)
return NS_ERROR_OUT_OF_MEMORY;
if (!mCleanHostKeys.Init(CLEAN_HOST_KEYS_SIZE))
return NS_ERROR_OUT_OF_MEMORY;
if (!mCleanFragments.Init(CLEAN_FRAGMENTS_SIZE))
return NS_ERROR_OUT_OF_MEMORY;
- mPendingLookupLock = PR_NewLock();
+ mPendingLookupLock =
+ nsAutoLock::NewLock("nsUrlClassifierDBServiceWorker::mPendingLookupLock");
if (!mPendingLookupLock)
return NS_ERROR_OUT_OF_MEMORY;
ResetUpdate();
mTableFreshness.Init();
return NS_OK;
--- a/xpcom/base/nsConsoleService.cpp
+++ b/xpcom/base/nsConsoleService.cpp
@@ -84,31 +84,31 @@ nsConsoleService::~nsConsoleService()
mListeners.Count());
}
#endif
if (mMessages)
nsMemory::Free(mMessages);
if (mLock)
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
}
nsresult
nsConsoleService::Init()
{
mMessages = (nsIConsoleMessage **)
nsMemory::Alloc(mBufferSize * sizeof(nsIConsoleMessage *));
if (!mMessages)
return NS_ERROR_OUT_OF_MEMORY;
// Array elements should be 0 initially for circular buffer algorithm.
memset(mMessages, 0, mBufferSize * sizeof(nsIConsoleMessage *));
- mLock = PR_NewLock();
+ mLock = nsAutoLock::NewLock("nsConsoleService::mLock");
if (!mLock)
return NS_ERROR_OUT_OF_MEMORY;
return NS_OK;
}
static PRBool snapshot_enum_func(nsHashKey *key, void *data, void* closure)
{
--- a/xpcom/base/nsUUIDGenerator.cpp
+++ b/xpcom/base/nsUUIDGenerator.cpp
@@ -57,24 +57,24 @@ NS_IMPL_THREADSAFE_ISUPPORTS1(nsUUIDGene
nsUUIDGenerator::nsUUIDGenerator()
: mLock(nsnull)
{
}
nsUUIDGenerator::~nsUUIDGenerator()
{
if (mLock) {
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
}
}
nsresult
nsUUIDGenerator::Init()
{
- mLock = PR_NewLock();
+ mLock = nsAutoLock::NewLock("nsUUIDGenerator::mLock");
NS_ENSURE_TRUE(mLock, NS_ERROR_OUT_OF_MEMORY);
// We're a service, so we're guaranteed that Init() is not going
// to be reentered while we're inside Init().
#if !defined(XP_WIN) && !defined(XP_MACOSX) && !defined(ANDROID)
/* initialize random number generator using NSPR random noise */
--- a/xpcom/ds/nsRecyclingAllocator.cpp
+++ b/xpcom/ds/nsRecyclingAllocator.cpp
@@ -73,17 +73,17 @@ nsRecyclingAllocator::nsRecycleTimerCall
nsRecyclingAllocator::nsRecyclingAllocator(PRUint32 nbucket, PRUint32 recycleAfter, const char *id) :
mMaxBlocks(nbucket), mFreeListCount(0), mFreeList(nsnull),
mRecycleTimer(nsnull), mRecycleAfter(recycleAfter), mTouched(PR_FALSE)
#ifdef DEBUG
, mId(id), mNAllocated(0)
#endif
{
- mLock = PR_NewLock();
+ mLock = nsAutoLock::NewLock("nsRecyclingAllocatior::mLock");
NS_ASSERTION(mLock, "Recycling allocator cannot get lock");
}
nsresult
nsRecyclingAllocator::Init(PRUint32 nbucket, PRUint32 recycleAfter, const char *id)
{
nsAutoLock lock(mLock);
@@ -100,17 +100,17 @@ nsRecyclingAllocator::Init(PRUint32 nbuc
}
nsRecyclingAllocator::~nsRecyclingAllocator()
{
ClearFreeList();
if (mLock)
{
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
mLock = nsnull;
}
}
// Allocation and free routines
void*
nsRecyclingAllocator::Malloc(PRSize bytes, PRBool zeroit)
{
--- a/xpcom/io/nsFastLoadService.cpp
+++ b/xpcom/io/nsFastLoadService.cpp
@@ -71,31 +71,31 @@ nsFastLoadService::~nsFastLoadService()
if (mInputStream)
mInputStream->Close();
if (mOutputStream)
mOutputStream->Close();
if (mFastLoadPtrMap)
PL_DHashTableDestroy(mFastLoadPtrMap);
if (mLock)
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
}
nsresult
nsFastLoadService::Create(nsISupports *aOuter, REFNSIID aIID, void **aResult)
{
*aResult = nsnull;
if (aOuter)
return NS_ERROR_NO_AGGREGATION;
nsFastLoadService* fastLoadService = new nsFastLoadService();
if (!fastLoadService)
return NS_ERROR_OUT_OF_MEMORY;
- fastLoadService->mLock = PR_NewLock();
+ fastLoadService->mLock = nsAutoLock::NewLock("nsFastLoadService::mLock");
if (!fastLoadService->mLock) {
delete fastLoadService;
return NS_ERROR_OUT_OF_MEMORY;
}
NS_ADDREF(fastLoadService);
nsresult rv = fastLoadService->QueryInterface(aIID, aResult);
NS_RELEASE(fastLoadService);
--- a/xpcom/io/nsInputStreamTee.cpp
+++ b/xpcom/io/nsInputStreamTee.cpp
@@ -63,17 +63,17 @@ public:
NS_DECL_NSIINPUTSTREAM
NS_DECL_NSIINPUTSTREAMTEE
nsInputStreamTee();
bool SinkIsValid();
void InvalidateSink();
private:
- ~nsInputStreamTee() { if (mLock) PR_DestroyLock(mLock); }
+ ~nsInputStreamTee() { if (mLock) nsAutoLock::DestroyLock(mLock); }
nsresult TeeSegment(const char *buf, PRUint32 count);
static NS_METHOD WriteSegmentFun(nsIInputStream *, void *, const char *,
PRUint32, PRUint32, PRUint32 *);
private:
nsCOMPtr<nsIInputStream> mSource;
@@ -319,17 +319,17 @@ nsInputStreamTee::GetSink(nsIOutputStrea
}
NS_IMETHODIMP
nsInputStreamTee::SetEventTarget(nsIEventTarget *anEventTarget)
{
mEventTarget = anEventTarget;
if (mEventTarget) {
// Only need synchronization if this is an async tee
- mLock = PR_NewLock();
+ mLock = nsAutoLock::NewLock("nsInputStreamTee::mLock");
if (!mLock) {
NS_ERROR("Failed to allocate lock for nsInputStreamTee");
return NS_ERROR_OUT_OF_MEMORY;
}
}
return NS_OK;
}
--- a/xpcom/io/nsLocalFileWin.cpp
+++ b/xpcom/io/nsLocalFileWin.cpp
@@ -170,17 +170,17 @@ ShortcutResolver::ShortcutResolver()
mLock = nsnull;
mPersistFile = nsnull;
mShellLink = nsnull;
}
ShortcutResolver::~ShortcutResolver()
{
if (mLock)
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
// Release the pointer to the IPersistFile interface.
if (mPersistFile)
mPersistFile->Release();
// Release the pointer to the IShellLink interface.
if (mShellLink)
mShellLink->Release();
@@ -188,17 +188,17 @@ ShortcutResolver::~ShortcutResolver()
CoUninitialize();
}
nsresult
ShortcutResolver::Init()
{
CoInitialize(NULL); // FIX: we should probably move somewhere higher up during startup
- mLock = PR_NewLock();
+ mLock = nsAutoLock::NewLock("ShortcutResolver::mLock");
if (!mLock)
return NS_ERROR_FAILURE;
HRESULT hres;
hres = CoCreateInstance(CLSID_ShellLink,
NULL,
CLSCTX_INPROC_SERVER,
IID_IShellLinkW,
--- a/xpcom/io/nsStreamUtils.cpp
+++ b/xpcom/io/nsStreamUtils.cpp
@@ -257,17 +257,17 @@ public:
, mCancelStatus(NS_OK)
{
}
// virtual since subclasses call superclass Release()
virtual ~nsAStreamCopier()
{
if (mLock)
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
}
// kick off the async copy...
nsresult Start(nsIInputStream *source,
nsIOutputStream *sink,
nsIEventTarget *target,
nsAsyncCopyCallbackFun callback,
void *closure,
@@ -279,17 +279,17 @@ public:
mSink = sink;
mTarget = target;
mCallback = callback;
mClosure = closure;
mChunkSize = chunksize;
mCloseSource = closeSource;
mCloseSink = closeSink;
- mLock = PR_NewLock();
+ mLock = nsAutoLock::NewLock("nsAStreamCopier::mLock");
if (!mLock)
return NS_ERROR_OUT_OF_MEMORY;
mAsyncSource = do_QueryInterface(mSource);
mAsyncSink = do_QueryInterface(mSink);
return PostContinuationEvent();
}
--- a/xpcom/proxy/src/nsProxyObjectManager.cpp
+++ b/xpcom/proxy/src/nsProxyObjectManager.cpp
@@ -110,26 +110,27 @@ NS_IMETHODIMP_(nsrefcnt)
nsProxyObjectManager::Release()
{
return 1;
}
nsProxyObjectManager::nsProxyObjectManager()
: mProxyObjectMap(256, PR_FALSE)
{
- mProxyCreationLock = PR_NewLock();
+ mProxyCreationLock =
+ nsAutoLock::NewLock("nsProxyObjectManager::mProxyCreationLock");
mProxyClassMap.Init(256);
}
nsProxyObjectManager::~nsProxyObjectManager()
{
mProxyClassMap.Clear();
if (mProxyCreationLock)
- PR_DestroyLock(mProxyCreationLock);
+ nsAutoLock::DestroyLock(mProxyCreationLock);
nsProxyObjectManager::gInstance = nsnull;
}
PRBool
nsProxyObjectManager::IsManagerShutdown()
{
return gInstance == nsnull;
--- a/xpcom/reflect/xptinfo/src/xptiInterfaceInfoManager.cpp
+++ b/xpcom/reflect/xptinfo/src/xptiInterfaceInfoManager.cpp
@@ -75,33 +75,34 @@ xptiInterfaceInfoManager::FreeInterfaceI
NS_IF_RELEASE(gInterfaceInfoManager);
}
xptiInterfaceInfoManager::xptiInterfaceInfoManager()
: mWorkingSet(),
mResolveLock(PR_NewLock()),
mAutoRegLock(PR_NewLock()),
mInfoMonitor(nsAutoMonitor::NewMonitor("xptiInfoMonitor")),
- mAdditionalManagersLock(PR_NewLock())
+ mAdditionalManagersLock(nsAutoLock::NewLock(
+ "xptiInterfaceInfoManager::mAdditionalManagersLock"))
{
}
xptiInterfaceInfoManager::~xptiInterfaceInfoManager()
{
// We only do this on shutdown of the service.
mWorkingSet.InvalidateInterfaceInfos();
if (mResolveLock)
PR_DestroyLock(mResolveLock);
if (mAutoRegLock)
PR_DestroyLock(mAutoRegLock);
if (mInfoMonitor)
nsAutoMonitor::DestroyMonitor(mInfoMonitor);
if (mAdditionalManagersLock)
- PR_DestroyLock(mAdditionalManagersLock);
+ nsAutoLock::DestroyLock(mAdditionalManagersLock);
gInterfaceInfoManager = nsnull;
#ifdef DEBUG
gCallCount = 0;
#endif
}
namespace {
--- a/xpcom/threads/TimerThread.cpp
+++ b/xpcom/threads/TimerThread.cpp
@@ -67,28 +67,28 @@ TimerThread::TimerThread() :
{
}
TimerThread::~TimerThread()
{
if (mCondVar)
PR_DestroyCondVar(mCondVar);
if (mLock)
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
mThread = nsnull;
NS_ASSERTION(mTimers.IsEmpty(), "Timers remain in TimerThread::~TimerThread");
}
nsresult
TimerThread::InitLocks()
{
NS_ASSERTION(!mLock, "InitLocks called twice?");
- mLock = PR_NewLock();
+ mLock = nsAutoLock::NewLock("TimerThread::mLock");
if (!mLock)
return NS_ERROR_OUT_OF_MEMORY;
mCondVar = PR_NewCondVar(mLock);
if (!mCondVar)
return NS_ERROR_OUT_OF_MEMORY;
return NS_OK;
--- a/xpcom/threads/nsEnvironment.cpp
+++ b/xpcom/threads/nsEnvironment.cpp
@@ -60,33 +60,33 @@ nsEnvironment::Create(nsISupports *aOute
return NS_ERROR_NO_AGGREGATION;
}
nsEnvironment* obj = new nsEnvironment();
if (!obj) {
return NS_ERROR_OUT_OF_MEMORY;
}
- obj->mLock = PR_NewLock();
+ obj->mLock = nsAutoLock::NewLock("nsEnvironment::mLock");
if (!obj->mLock) {
delete obj;
return NS_ERROR_OUT_OF_MEMORY;
}
rv = obj->QueryInterface(aIID, aResult);
if (NS_FAILED(rv)) {
delete obj;
}
return rv;
}
nsEnvironment::~nsEnvironment()
{
if (mLock)
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
}
NS_IMETHODIMP
nsEnvironment::Exists(const nsAString& aName, PRBool *aOutValue)
{
nsCAutoString nativeName;
nsresult rv = NS_CopyUnicodeToNative(aName, nativeName);
NS_ENSURE_SUCCESS(rv, rv);
--- a/xpcom/threads/nsProcessCommon.cpp
+++ b/xpcom/threads/nsProcessCommon.cpp
@@ -100,32 +100,32 @@ cpu_type_t pref_cpu_types[2] = {
// nsIProcess implementation
//-------------------------------------------------------------------//
NS_IMPL_THREADSAFE_ISUPPORTS2(nsProcess, nsIProcess,
nsIObserver)
//Constructor
nsProcess::nsProcess()
: mThread(nsnull)
- , mLock(PR_NewLock())
+ , mLock(nsAutoLock::NewLock("nsProcess::mLock"))
, mShutdown(PR_FALSE)
, mPid(-1)
, mObserver(nsnull)
, mWeakObserver(nsnull)
, mExitValue(-1)
#if !defined(XP_MACOSX)
, mProcess(nsnull)
#endif
{
}
//Destructor
nsProcess::~nsProcess()
{
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
}
NS_IMETHODIMP
nsProcess::Init(nsIFile* executable)
{
if (mExecutable)
return NS_ERROR_ALREADY_INITIALIZED;
--- a/xpcom/threads/nsThread.cpp
+++ b/xpcom/threads/nsThread.cpp
@@ -308,31 +308,31 @@ nsThread::ThreadFunc(void *arg)
self->SetObserver(nsnull);
NS_RELEASE(self);
}
//-----------------------------------------------------------------------------
nsThread::nsThread()
- : mLock(PR_NewLock())
+ : mLock(nsAutoLock::NewLock("nsThread::mLock"))
, mEvents(&mEventsRoot)
, mPriority(PRIORITY_NORMAL)
, mThread(nsnull)
, mRunningEvent(0)
, mShutdownContext(nsnull)
, mShutdownRequired(PR_FALSE)
, mEventsAreDoomed(PR_FALSE)
{
}
nsThread::~nsThread()
{
if (mLock)
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
}
nsresult
nsThread::Init()
{
NS_ENSURE_TRUE(mLock, NS_ERROR_OUT_OF_MEMORY);
// spawn thread and wait until it is fully setup
--- a/xpcom/threads/nsThreadManager.cpp
+++ b/xpcom/threads/nsThreadManager.cpp
@@ -83,17 +83,17 @@ NS_IMPL_CLASSINFO(nsThreadManager, NULL,
NS_IMPL_QUERY_INTERFACE1_CI(nsThreadManager, nsIThreadManager)
NS_IMPL_CI_INTERFACE_GETTER1(nsThreadManager, nsIThreadManager)
//-----------------------------------------------------------------------------
nsresult
nsThreadManager::Init()
{
- mLock = PR_NewLock();
+ mLock = nsAutoLock::NewLock("nsThreadManager::mLock");
if (!mLock)
return NS_ERROR_OUT_OF_MEMORY;
if (!mThreadsByPRThread.Init())
return NS_ERROR_OUT_OF_MEMORY;
if (PR_NewThreadPrivateIndex(&mCurThreadIndex, ReleaseObject) == PR_FAILURE)
return NS_ERROR_FAILURE;
@@ -180,17 +180,17 @@ nsThreadManager::Shutdown()
// Release main thread object.
mMainThread = nsnull;
// Remove the TLS entry for the main thread.
PR_SetThreadPrivate(mCurThreadIndex, nsnull);
// We don't need this lock anymore.
- PR_DestroyLock(mLock);
+ nsAutoLock::DestroyLock(mLock);
mLock = nsnull;
}
void
nsThreadManager::RegisterCurrentThread(nsThread *thread)
{
NS_ASSERTION(thread->GetPRThread() == PR_GetCurrentThread(), "bad thread");
--- a/xpfe/appshell/src/nsWindowMediator.cpp
+++ b/xpfe/appshell/src/nsWindowMediator.cpp
@@ -94,22 +94,22 @@ nsWindowMediator::nsWindowMediator() :
}
nsWindowMediator::~nsWindowMediator()
{
while (mOldestWindow)
UnregisterWindow(mOldestWindow);
if (mListLock)
- PR_DestroyLock(mListLock);
+ nsAutoLock::DestroyLock(mListLock);
}
nsresult nsWindowMediator::Init()
{
- mListLock = PR_NewLock();
+ mListLock = nsAutoLock::NewLock("nsWindowMediator::mListLock");
if (!mListLock)
return NS_ERROR_OUT_OF_MEMORY;
nsresult rv;
nsCOMPtr<nsIObserverService> obsSvc =
do_GetService("@mozilla.org/observer-service;1", &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = obsSvc->AddObserver(this, "xpcom-shutdown", PR_TRUE);