Rollup of bug 645263 and bug 646259: Switch to mozilla:: sync primitives. r=cjones,dbaron,doublec,ehsan src=bsmedberg
authorChris Jones <jones.chris.g@gmail.com> and Kyle Huey <khuey@kylehuey.com>
Thu, 31 Mar 2011 23:29:02 -0500
changeset 64576 1a89509e25e4256577f2fb729a8b922be533a9fb
parent 64575 26463a06d0caf1355b5cdc729d93f22e04ccc053
child 64577 373dd35f5f33bcb2e1b7e17ab6fe6828c09172be
push idunknown
push userunknown
push dateunknown
reviewerscjones, dbaron, doublec, ehsan
bugs645263, 646259
milestone2.2a1pre
Rollup of bug 645263 and bug 646259: Switch to mozilla:: sync primitives. r=cjones,dbaron,doublec,ehsan src=bsmedberg Bug 645263, part 0: Count sync primitive ctor/dtors. r=dbaron Bug 645263, part 1: Migrate content/media to mozilla:: sync primitives. r=doublec Bug 645263, part 2: Migrate modules/plugin to mozilla:: sync primitives. sr=bsmedberg Bug 645263, part 3: Migrate nsComponentManagerImpl to mozilla:: sync primitives. sr=bsmedberg Bug 645263, part 4: Migrate everything else to mozilla:: sync primitives. r=dbaron Bug 645263, part 5: Remove nsAutoLock.*. sr=bsmedberg Bug 645263, part 6: Make editor test be nicer to deadlock detector. r=ehsan Bug 645263, part 7: Disable tracemalloc backtraces for xpcshell tests. r=dbaron Bug 646259: Fix nsCacheService to use a CondVar for notifying. r=cjones
content/media/nsBuiltinDecoderReader.h
content/media/nsMediaCache.cpp
content/media/nsMediaCache.h
content/media/nsMediaDecoder.cpp
content/media/nsMediaDecoder.h
content/media/nsMediaStream.cpp
content/media/nsMediaStream.h
dom/src/threads/nsDOMThreadService.cpp
dom/src/threads/nsDOMThreadService.h
dom/src/threads/nsDOMWorker.cpp
dom/src/threads/nsDOMWorker.h
dom/src/threads/nsDOMWorkerPool.cpp
dom/src/threads/nsDOMWorkerPool.h
dom/src/threads/nsDOMWorkerScriptLoader.cpp
dom/src/threads/nsDOMWorkerScriptLoader.h
dom/src/threads/nsDOMWorkerXHR.cpp
dom/src/threads/nsDOMWorkerXHR.h
dom/src/threads/nsDOMWorkerXHRProxy.cpp
editor/txmgr/tests/TestTXMgr.cpp
embedding/components/windowwatcher/src/nsWindowWatcher.cpp
embedding/components/windowwatcher/src/nsWindowWatcher.h
gfx/src/nsRegion.cpp
intl/strres/src/nsStringBundle.cpp
intl/strres/src/nsStringBundle.h
intl/uconv/src/nsUNIXCharset.cpp
js/src/xpconnect/src/xpcjsruntime.cpp
js/src/xpconnect/src/xpcprivate.h
js/src/xpconnect/src/xpcthreadcontext.cpp
modules/libjar/nsJAR.cpp
modules/libjar/nsJAR.h
modules/plugin/base/src/nsNPAPIPlugin.cpp
modules/plugin/base/src/nsNPAPIPlugin.h
modules/plugin/base/src/nsNPAPIPluginInstance.cpp
netwerk/base/src/nsAsyncStreamCopier.cpp
netwerk/base/src/nsAsyncStreamCopier.h
netwerk/base/src/nsPACMan.cpp
netwerk/base/src/nsProtocolProxyService.cpp
netwerk/base/src/nsServerSocket.cpp
netwerk/base/src/nsServerSocket.h
netwerk/base/src/nsSocketTransport2.cpp
netwerk/base/src/nsSocketTransport2.h
netwerk/base/src/nsSocketTransportService2.cpp
netwerk/base/src/nsSocketTransportService2.h
netwerk/base/src/nsStreamTransportService.cpp
netwerk/base/src/nsTransportUtils.cpp
netwerk/build/nsNetModule.cpp
netwerk/cache/nsCacheRequest.h
netwerk/cache/nsCacheService.cpp
netwerk/cache/nsCacheService.h
netwerk/cache/nsDiskCacheDevice.cpp
netwerk/dns/nsDNSService2.cpp
netwerk/dns/nsDNSService2.h
netwerk/dns/nsHostResolver.cpp
netwerk/dns/nsHostResolver.h
netwerk/protocol/ftp/nsFTPChannel.h
netwerk/protocol/ftp/nsFtpConnectionThread.h
netwerk/protocol/ftp/nsFtpControlConnection.h
netwerk/protocol/http/nsHttp.cpp
netwerk/protocol/http/nsHttpActivityDistributor.cpp
netwerk/protocol/http/nsHttpActivityDistributor.h
netwerk/protocol/http/nsHttpConnection.cpp
netwerk/protocol/http/nsHttpConnection.h
netwerk/protocol/http/nsHttpConnectionMgr.cpp
netwerk/protocol/http/nsHttpConnectionMgr.h
netwerk/protocol/http/nsHttpHandler.cpp
netwerk/protocol/http/nsHttpPipeline.cpp
netwerk/protocol/http/nsHttpTransaction.cpp
netwerk/protocol/res/nsResProtocolHandler.cpp
netwerk/wifi/nsWifiMonitor.cpp
netwerk/wifi/nsWifiMonitor.h
netwerk/wifi/nsWifiScannerMac.cpp
netwerk/wifi/nsWifiScannerUnix.cpp
netwerk/wifi/nsWifiScannerWin.cpp
parser/htmlparser/src/nsParser.cpp
security/manager/boot/src/nsSecureBrowserUIImpl.cpp
security/manager/boot/src/nsSecureBrowserUIImpl.h
security/manager/ssl/src/nsCertOverrideService.cpp
security/manager/ssl/src/nsCertOverrideService.h
security/manager/ssl/src/nsCertVerificationThread.cpp
security/manager/ssl/src/nsClientAuthRemember.cpp
security/manager/ssl/src/nsClientAuthRemember.h
security/manager/ssl/src/nsKeygenThread.cpp
security/manager/ssl/src/nsKeygenThread.h
security/manager/ssl/src/nsNSSCallbacks.cpp
security/manager/ssl/src/nsNSSCallbacks.h
security/manager/ssl/src/nsNSSCertCache.cpp
security/manager/ssl/src/nsNSSCertCache.h
security/manager/ssl/src/nsNSSCertificate.cpp
security/manager/ssl/src/nsNSSComponent.cpp
security/manager/ssl/src/nsNSSComponent.h
security/manager/ssl/src/nsNSSIOLayer.cpp
security/manager/ssl/src/nsNSSIOLayer.h
security/manager/ssl/src/nsNSSShutDown.cpp
security/manager/ssl/src/nsNSSShutDown.h
security/manager/ssl/src/nsPSMBackgroundThread.cpp
security/manager/ssl/src/nsPSMBackgroundThread.h
security/manager/ssl/src/nsProtectedAuthThread.cpp
security/manager/ssl/src/nsProtectedAuthThread.h
security/manager/ssl/src/nsRecentBadCerts.cpp
security/manager/ssl/src/nsRecentBadCerts.h
security/manager/ssl/src/nsSSLThread.cpp
storage/src/mozStorageConnection.cpp
testing/xpcshell/runxpcshelltests.py
toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
tools/trace-malloc/lib/nsWinTraceMalloc.cpp
widget/src/android/nsAppShell.cpp
widget/src/android/nsAppShell.h
xpcom/base/nsConsoleService.cpp
xpcom/base/nsConsoleService.h
xpcom/base/nsExceptionService.cpp
xpcom/base/nsExceptionService.h
xpcom/base/nsMemoryImpl.cpp
xpcom/base/nsTraceRefcntImpl.cpp
xpcom/base/nsUUIDGenerator.cpp
xpcom/base/nsUUIDGenerator.h
xpcom/build/XPCOM.h
xpcom/build/nsXPComInit.cpp
xpcom/components/nsComponentManager.cpp
xpcom/components/nsComponentManager.h
xpcom/ds/TimeStamp.cpp
xpcom/ds/nsRecyclingAllocator.cpp
xpcom/ds/nsRecyclingAllocator.h
xpcom/glue/BlockingResourceBase.h
xpcom/glue/CondVar.h
xpcom/glue/Makefile.in
xpcom/glue/Monitor.h
xpcom/glue/Mutex.h
xpcom/glue/nsAutoLock.cpp
xpcom/glue/nsAutoLock.h
xpcom/glue/objs.mk
xpcom/io/nsFastLoadService.cpp
xpcom/io/nsFastLoadService.h
xpcom/io/nsInputStreamTee.cpp
xpcom/io/nsLocalFileWin.cpp
xpcom/io/nsNativeCharsetUtils.cpp
xpcom/io/nsPipe3.cpp
xpcom/io/nsStreamUtils.cpp
xpcom/proxy/src/nsProxyEvent.cpp
xpcom/proxy/src/nsProxyEventClass.cpp
xpcom/proxy/src/nsProxyEventObject.cpp
xpcom/proxy/src/nsProxyEventPrivate.h
xpcom/proxy/src/nsProxyObjectManager.cpp
xpcom/proxy/tests/proxy-create-threadsafety.cpp
xpcom/reflect/xptinfo/src/xptiInterfaceInfo.cpp
xpcom/reflect/xptinfo/src/xptiInterfaceInfoManager.cpp
xpcom/reflect/xptinfo/src/xptiWorkingSet.cpp
xpcom/reflect/xptinfo/src/xptiprivate.h
xpcom/threads/TimerThread.cpp
xpcom/threads/TimerThread.h
xpcom/threads/nsEnvironment.cpp
xpcom/threads/nsEnvironment.h
xpcom/threads/nsEventQueue.cpp
xpcom/threads/nsEventQueue.h
xpcom/threads/nsProcess.h
xpcom/threads/nsProcessCommon.cpp
xpcom/threads/nsThread.cpp
xpcom/threads/nsThread.h
xpcom/threads/nsThreadManager.cpp
xpcom/threads/nsThreadManager.h
xpcom/threads/nsThreadPool.cpp
xpcom/threads/nsTimerImpl.cpp
xpfe/appshell/src/nsWebShellWindow.cpp
xpfe/appshell/src/nsWebShellWindow.h
xpfe/appshell/src/nsWindowMediator.cpp
xpfe/appshell/src/nsWindowMediator.h
--- a/content/media/nsBuiltinDecoderReader.h
+++ b/content/media/nsBuiltinDecoderReader.h
@@ -37,17 +37,16 @@
  *
  * ***** END LICENSE BLOCK ***** */
 #if !defined(nsBuiltinDecoderReader_h_)
 #define nsBuiltinDecoderReader_h_
 
 #include <nsDeque.h>
 #include "Layers.h"
 #include "ImageLayers.h"
-#include "nsAutoLock.h"
 #include "nsClassHashtable.h"
 #include "mozilla/TimeStamp.h"
 #include "nsSize.h"
 #include "nsRect.h"
 #include "mozilla/Monitor.h"
 
 class nsBuiltinDecoderStateMachine;
 
--- a/content/media/nsMediaCache.cpp
+++ b/content/media/nsMediaCache.cpp
@@ -31,31 +31,33 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
+#include "mozilla/Monitor.h"
 #include "mozilla/XPCOM.h"
 
 #include "nsMediaCache.h"
-#include "nsAutoLock.h"
 #include "nsContentUtils.h"
 #include "nsDirectoryServiceUtils.h"
 #include "nsDirectoryServiceDefs.h"
 #include "nsNetUtil.h"
 #include "prio.h"
 #include "nsThreadUtils.h"
 #include "nsMediaStream.h"
 #include "nsMathUtils.h"
 #include "prlog.h"
 #include "nsIPrivateBrowsingService.h"
 
+using namespace mozilla;
+
 #ifdef PR_LOGGING
 PRLogModuleInfo* gMediaCacheLog;
 #define LOG(type, msg) PR_LOG(gMediaCacheLog, type, msg)
 #else
 #define LOG(type, msg)
 #endif
 
 // Readahead blocks for non-seekable streams will be limited to this
@@ -72,19 +74,16 @@ static const PRUint32 REPLAY_DELAY = 30;
 
 // When looking for a reusable block, scan forward this many blocks
 // from the desired "best" block location to look for free blocks,
 // before we resort to scanning the whole cache. The idea is to try to
 // store runs of stream blocks close-to-consecutively in the cache if we
 // can.
 static const PRUint32 FREE_BLOCK_SCAN_LIMIT = 16;
 
-using mozilla::TimeStamp;
-using mozilla::TimeDuration;
-
 #ifdef DEBUG
 // Turn this on to do very expensive cache state validation
 // #define DEBUG_VERIFY_CACHE
 #endif
 
 // There is at most one media cache (although that could quite easily be
 // relaxed if we wanted to manage multiple caches with independent
 // size limits).
@@ -130,34 +129,31 @@ class nsMediaCache {
 public:
   friend class nsMediaCacheStream::BlockList;
   typedef nsMediaCacheStream::BlockList BlockList;
   enum {
     BLOCK_SIZE = nsMediaCacheStream::BLOCK_SIZE
   };
 
   nsMediaCache() : mNextResourceID(1),
-    mMonitor(nsAutoMonitor::NewMonitor("media.cache")),
+    mMonitor("nsMediaCache.mMonitor"),
     mFD(nsnull), mFDCurrentPos(0), mUpdateQueued(PR_FALSE)
 #ifdef DEBUG
     , mInUpdate(PR_FALSE)
 #endif
   {
     MOZ_COUNT_CTOR(nsMediaCache);
   }
   ~nsMediaCache() {
     NS_ASSERTION(mStreams.IsEmpty(), "Stream(s) still open!");
     Truncate();
     NS_ASSERTION(mIndex.Length() == 0, "Blocks leaked?");
     if (mFD) {
       PR_Close(mFD);
     }
-    if (mMonitor) {
-      nsAutoMonitor::DestroyMonitor(mMonitor);
-    }
     MOZ_COUNT_DTOR(nsMediaCache);
   }
 
   // Main thread only. Creates the backing cache file. If this fails,
   // then the cache is still in a semi-valid state; mFD will be null,
   // so all I/O on the cache file will fail.
   nsresult Init();
   // Shut down the global cache if it's no longer needed. We shut down
@@ -226,17 +222,17 @@ public:
 
 #ifdef DEBUG_VERIFY_CACHE
   // Verify invariants, especially block list invariants
   void Verify();
 #else
   void Verify() {}
 #endif
 
-  PRMonitor* Monitor() { return mMonitor; }
+  Monitor& GetMonitor() { return mMonitor; }
 
   /**
    * An iterator that makes it easy to iterate through all streams that
    * have a given resource ID and are not closed.
    */
   class ResourceStreamIterator {
   public:
     ResourceStreamIterator(PRInt64 aResourceID) :
@@ -349,17 +345,17 @@ protected:
   // resource IDs to streams.
   PRInt64                       mNextResourceID;
   // This member is main-thread only. It contains all the streams.
   nsTArray<nsMediaCacheStream*> mStreams;
 
   // The monitor protects all the data members here. Also, off-main-thread
   // readers that need to block will Wait() on this monitor. When new
   // data becomes available in the cache, we NotifyAll() on this monitor.
-  PRMonitor*      mMonitor;
+  Monitor         mMonitor;
   // The Blocks describing the cache entries.
   nsTArray<Block> mIndex;
   // The file descriptor of the cache file. The file will be deleted
   // by the operating system when this is closed.
   PRFileDesc*     mFD;
   // The current file offset in the cache file.
   PRInt64         mFDCurrentPos;
   // The list of free blocks; they are not ordered.
@@ -544,21 +540,16 @@ nsMediaCacheStream::BlockList::NotifyBlo
 }
 
 nsresult
 nsMediaCache::Init()
 {
   NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
   NS_ASSERTION(!mFD, "Cache file already open?");
 
-  if (!mMonitor) {
-    // the constructor failed
-    return NS_ERROR_OUT_OF_MEMORY;
-  }
-
   nsCOMPtr<nsIFile> tmp;
   nsresult rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(tmp));
   NS_ENSURE_SUCCESS(rv,rv);
 
   nsCOMPtr<nsILocalFile> tmpFile = do_QueryInterface(tmp);
   NS_ENSURE_TRUE(tmpFile != nsnull, NS_ERROR_FAILURE);
 
   // We put the media cache file in
@@ -612,17 +603,17 @@ nsMediaCache::Flush()
     return;
 
   gMediaCache->FlushInternal();
 }
 
 void
 nsMediaCache::FlushInternal()
 {
-  nsAutoMonitor mon(mMonitor);
+  MonitorAutoEnter mon(mMonitor);
 
   for (PRUint32 blockIndex = 0; blockIndex < mIndex.Length(); ++blockIndex) {
     FreeBlock(blockIndex);
   }
 
   // Truncate file, close it, and reopen
   Truncate();
   NS_ASSERTION(mIndex.Length() == 0, "Blocks leaked?");
@@ -667,17 +658,17 @@ InitMediaCache()
     gMediaCache = nsnull;
   }
 }
 
 nsresult
 nsMediaCache::ReadCacheFile(PRInt64 aOffset, void* aData, PRInt32 aLength,
                             PRInt32* aBytes)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
 
   if (!mFD)
     return NS_ERROR_FAILURE;
 
   if (mFDCurrentPos != aOffset) {
     PROffset64 offset = PR_Seek64(mFD, aOffset, PR_SEEK_SET);
     if (offset != aOffset)
       return NS_ERROR_FAILURE;
@@ -689,17 +680,17 @@ nsMediaCache::ReadCacheFile(PRInt64 aOff
   mFDCurrentPos += amount;
   *aBytes = amount;
   return NS_OK;
 }
 
 nsresult
 nsMediaCache::ReadCacheFileAllBytes(PRInt64 aOffset, void* aData, PRInt32 aLength)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
 
   PRInt64 offset = aOffset;
   PRInt32 count = aLength;
   // Cast to char* so we can do byte-wise pointer arithmetic
   char* data = static_cast<char*>(aData);
   while (count > 0) {
     PRInt32 bytes;
     nsresult rv = ReadCacheFile(offset, data, count, &bytes);
@@ -712,17 +703,17 @@ nsMediaCache::ReadCacheFileAllBytes(PRIn
     offset += bytes;
   }
   return NS_OK;
 }
 
 nsresult
 nsMediaCache::WriteCacheFile(PRInt64 aOffset, const void* aData, PRInt32 aLength)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
 
   if (!mFD)
     return NS_ERROR_FAILURE;
 
   if (mFDCurrentPos != aOffset) {
     PROffset64 offset = PR_Seek64(mFD, aOffset, PR_SEEK_SET);
     if (offset != aOffset)
       return NS_ERROR_FAILURE;
@@ -753,17 +744,17 @@ static PRInt32 GetMaxBlocks()
   maxBlocks = PR_MAX(maxBlocks, 1);
   return PRInt32(PR_MIN(maxBlocks, PR_INT32_MAX));
 }
 
 PRInt32
 nsMediaCache::FindBlockForIncomingData(TimeStamp aNow,
                                        nsMediaCacheStream* aStream)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
 
   PRInt32 blockIndex = FindReusableBlock(aNow, aStream,
       aStream->mChannelOffset/BLOCK_SIZE, PR_INT32_MAX);
 
   if (blockIndex < 0 || !IsBlockFree(blockIndex)) {
     // The block returned is already allocated.
     // Don't reuse it if a) there's room to expand the cache or
     // b) the data we're going to store in the free block is not higher
@@ -796,17 +787,17 @@ nsMediaCache::BlockIsReusable(PRInt32 aB
   return PR_TRUE;
 }
 
 void
 nsMediaCache::AppendMostReusableBlock(BlockList* aBlockList,
                                       nsTArray<PRUint32>* aResult,
                                       PRInt32 aBlockIndexLimit)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
 
   PRInt32 blockIndex = aBlockList->GetLastBlock();
   if (blockIndex < 0)
     return;
   do {
     // Don't consider blocks for pinned streams, or blocks that are
     // beyond the specified limit, or a block that contains a stream's
     // current read position (such a block contains both played data
@@ -820,17 +811,17 @@ nsMediaCache::AppendMostReusableBlock(Bl
 }
 
 PRInt32
 nsMediaCache::FindReusableBlock(TimeStamp aNow,
                                 nsMediaCacheStream* aForStream,
                                 PRInt32 aForStreamBlock,
                                 PRInt32 aMaxSearchBlockIndex)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
 
   PRUint32 length = PR_MIN(PRUint32(aMaxSearchBlockIndex), mIndex.Length());
 
   if (aForStream && aForStreamBlock > 0 &&
       PRUint32(aForStreamBlock) <= aForStream->mBlocks.Length()) {
     PRInt32 prevCacheBlock = aForStream->mBlocks[aForStreamBlock - 1];
     if (prevCacheBlock >= 0) {
       PRUint32 freeBlockScanEnd =
@@ -914,17 +905,17 @@ nsMediaCache::GetBlockOwner(PRInt32 aBlo
       return &block->mOwners[i];
   }
   return nsnull;
 }
 
 void
 nsMediaCache::SwapBlocks(PRInt32 aBlockIndex1, PRInt32 aBlockIndex2)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
 
   Block* block1 = &mIndex[aBlockIndex1];
   Block* block2 = &mIndex[aBlockIndex2];
 
   block1->mOwners.SwapElements(block2->mOwners);
 
   // Now all references to block1 have to be replaced with block2 and
   // vice versa.
@@ -994,17 +985,17 @@ nsMediaCache::AddBlockOwnerAsReadahead(P
   aStream->mBlocks[aStreamBlockIndex] = aBlockIndex;
   bo->mClass = READAHEAD_BLOCK;
   InsertReadaheadBlock(bo, aBlockIndex);
 }
 
 void
 nsMediaCache::FreeBlock(PRInt32 aBlock)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
 
   Block* block = &mIndex[aBlock];
   if (block->mOwners.IsEmpty()) {
     // already free
     return;
   }
 
   LOG(PR_LOG_DEBUG, ("Released block %d", aBlock));
@@ -1017,17 +1008,17 @@ nsMediaCache::FreeBlock(PRInt32 aBlock)
   block->mOwners.Clear();
   mFreeBlocks.AddFirstBlock(aBlock);
   Verify();
 }
 
 TimeDuration
 nsMediaCache::PredictNextUse(TimeStamp aNow, PRInt32 aBlock)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
   NS_ASSERTION(!IsBlockFree(aBlock), "aBlock is free");
 
   Block* block = &mIndex[aBlock];
   // Blocks can be belong to multiple streams. The predicted next use
   // time is the earliest time predicted by any of the streams.
   TimeDuration result;
   for (PRUint32 i = 0; i < block->mOwners.Length(); ++i) {
     BlockOwner* bo = &block->mOwners[i];
@@ -1067,17 +1058,17 @@ nsMediaCache::PredictNextUse(TimeStamp a
     }
   }
   return result;
 }
 
 TimeDuration
 nsMediaCache::PredictNextUseForIncomingData(nsMediaCacheStream* aStream)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
 
   PRInt64 bytesAhead = aStream->mChannelOffset - aStream->mStreamOffset;
   if (bytesAhead <= -BLOCK_SIZE) {
     // Hmm, no idea when data behind us will be used. Guess 24 hours.
     return TimeDuration::FromSeconds(24*60*60);
   }
   if (bytesAhead <= 0)
     return TimeDuration(0);
@@ -1095,17 +1086,17 @@ nsMediaCache::Update()
 
   // The action to use for each stream. We store these so we can make
   // decisions while holding the cache lock but implement those decisions
   // without holding the cache lock, since we need to call out to
   // stream, decoder and element code.
   nsAutoTArray<StreamAction,10> actions;
 
   {
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
     mUpdateQueued = PR_FALSE;
 #ifdef DEBUG
     mInUpdate = PR_TRUE;
 #endif
 
     PRInt32 maxBlocks = GetMaxBlocks();
     TimeStamp now = TimeStamp::Now();
 
@@ -1377,18 +1368,18 @@ nsMediaCache::Update()
     default:
       break;
     }
 
     if (NS_FAILED(rv)) {
       // Close the streams that failed due to error. This will cause all
       // client Read and Seek operations on those streams to fail. Blocked
       // Reads will also be woken up.
-      nsAutoMonitor mon(mMonitor);
-      stream->CloseInternal(&mon);
+      MonitorAutoEnter mon(mMonitor);
+      stream->CloseInternal(mon);
     }
   }
 }
 
 class UpdateEvent : public nsRunnable
 {
 public:
   NS_IMETHOD Run()
@@ -1398,34 +1389,34 @@ public:
     }
     return NS_OK;
   }
 };
 
 void
 nsMediaCache::QueueUpdate()
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
 
   // Queuing an update while we're in an update raises a high risk of
   // triggering endless events
   NS_ASSERTION(!mInUpdate,
                "Queuing an update while we're in an update");
   if (mUpdateQueued)
     return;
   mUpdateQueued = PR_TRUE;
   nsCOMPtr<nsIRunnable> event = new UpdateEvent();
   NS_DispatchToMainThread(event);
 }
 
 #ifdef DEBUG_VERIFY_CACHE
 void
 nsMediaCache::Verify()
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
 
   mFreeBlocks.Verify();
   for (PRUint32 i = 0; i < mStreams.Length(); ++i) {
     nsMediaCacheStream* stream = mStreams[i];
     stream->mReadaheadBlocks.Verify();
     stream->mPlayedBlocks.Verify();
     stream->mMetadataBlocks.Verify();
 
@@ -1447,17 +1438,17 @@ nsMediaCache::Verify()
   }
 }
 #endif
 
 void
 nsMediaCache::InsertReadaheadBlock(BlockOwner* aBlockOwner,
                                    PRInt32 aBlockIndex)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
 
   // Find the last block whose stream block is before aBlockIndex's
   // stream block, and insert after it
   nsMediaCacheStream* stream = aBlockOwner->mStream;
   PRInt32 readaheadIndex = stream->mReadaheadBlocks.GetLastBlock();
   while (readaheadIndex >= 0) {
     BlockOwner* bo = GetBlockOwner(readaheadIndex, stream);
     NS_ASSERTION(bo, "stream must own its blocks");
@@ -1473,17 +1464,17 @@ nsMediaCache::InsertReadaheadBlock(Block
   stream->mReadaheadBlocks.AddFirstBlock(aBlockIndex);
   Verify();
 }
 
 void
 nsMediaCache::AllocateAndWriteBlock(nsMediaCacheStream* aStream, const void* aData,
                                     nsMediaCacheStream::ReadMode aMode)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
 
   PRInt32 streamBlockIndex = aStream->mChannelOffset/BLOCK_SIZE;
 
   // Remove all cached copies of this block
   ResourceStreamIterator iter(aStream->mResourceID);
   while (nsMediaCacheStream* stream = iter.Next()) {
     while (streamBlockIndex >= PRInt32(stream->mBlocks.Length())) {
       stream->mBlocks.AppendElement(-1);
@@ -1551,39 +1542,39 @@ nsMediaCache::AllocateAndWriteBlock(nsMe
   QueueUpdate();
 }
 
 void
 nsMediaCache::OpenStream(nsMediaCacheStream* aStream)
 {
   NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
 
-  nsAutoMonitor mon(mMonitor);
+  MonitorAutoEnter mon(mMonitor);
   LOG(PR_LOG_DEBUG, ("Stream %p opened", aStream));
   mStreams.AppendElement(aStream);
   aStream->mResourceID = mNextResourceID++;
 
   // Queue an update since a new stream has been opened.
   gMediaCache->QueueUpdate();
 }
 
 void
 nsMediaCache::ReleaseStream(nsMediaCacheStream* aStream)
 {
   NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
 
-  nsAutoMonitor mon(mMonitor);
+  MonitorAutoEnter mon(mMonitor);
   LOG(PR_LOG_DEBUG, ("Stream %p closed", aStream));
   mStreams.RemoveElement(aStream);
 }
 
 void
 nsMediaCache::ReleaseStreamBlocks(nsMediaCacheStream* aStream)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
 
   // XXX scanning the entire stream doesn't seem great, if not much of it
   // is cached, but the only easy alternative is to scan the entire cache
   // which isn't better
   PRUint32 length = aStream->mBlocks.Length();
   for (PRUint32 i = 0; i < length; ++i) {
     PRInt32 blockIndex = aStream->mBlocks[i];
     if (blockIndex >= 0) {
@@ -1613,17 +1604,17 @@ nsMediaCache::Truncate()
   }
 }
 
 void
 nsMediaCache::NoteBlockUsage(nsMediaCacheStream* aStream, PRInt32 aBlockIndex,
                              nsMediaCacheStream::ReadMode aMode,
                              TimeStamp aNow)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
 
   if (aBlockIndex < 0) {
     // this block is not in the cache yet
     return;
   }
 
   BlockOwner* bo = GetBlockOwner(aBlockIndex, aStream);
   if (!bo) {
@@ -1645,17 +1636,17 @@ nsMediaCache::NoteBlockUsage(nsMediaCach
   GetListForBlock(bo)->AddFirstBlock(aBlockIndex);
   bo->mLastUseTime = aNow;
   Verify();
 }
 
 void
 nsMediaCache::NoteSeek(nsMediaCacheStream* aStream, PRInt64 aOldOffset)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
 
   if (aOldOffset < aStream->mStreamOffset) {
     // We seeked forward. Convert blocks from readahead to played.
     // Any readahead block that intersects the seeked-over range must
     // be converted.
     PRInt32 blockIndex = aOldOffset/BLOCK_SIZE;
     PRInt32 endIndex =
       PR_MIN((aStream->mStreamOffset + BLOCK_SIZE - 1)/BLOCK_SIZE,
@@ -1701,26 +1692,26 @@ nsMediaCache::NoteSeek(nsMediaCacheStrea
   }
 }
 
 void
 nsMediaCacheStream::NotifyDataLength(PRInt64 aLength)
 {
   NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
 
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
   mStreamLength = aLength;
 }
 
 void
 nsMediaCacheStream::NotifyDataStarted(PRInt64 aOffset)
 {
   NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
 
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
   NS_WARN_IF_FALSE(aOffset == mChannelOffset,
                    "Server is giving us unexpected offset");
   mChannelOffset = aOffset;
   if (mStreamLength >= 0) {
     // If we started reading at a certain offset, then for sure
     // the stream is at least that long.
     mStreamLength = PR_MAX(mStreamLength, mChannelOffset);
   }
@@ -1761,17 +1752,17 @@ nsMediaCacheStream::UpdatePrincipal(nsIP
 }
 
 void
 nsMediaCacheStream::NotifyDataReceived(PRInt64 aSize, const char* aData,
     nsIPrincipal* aPrincipal)
 {
   NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
 
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
   PRInt64 size = aSize;
   const char* data = aData;
 
   LOG(PR_LOG_DEBUG, ("Stream %p DataReceived at %lld count=%lld",
       this, (long long)mChannelOffset, (long long)aSize));
 
   // We process the data one block (or part of a block) at a time
   while (size > 0) {
@@ -1830,17 +1821,17 @@ nsMediaCacheStream::NotifyDataReceived(P
   mon.NotifyAll();
 }
 
 void
 nsMediaCacheStream::NotifyDataEnded(nsresult aStatus)
 {
   NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
 
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
 
   PRInt32 blockOffset = PRInt32(mChannelOffset%BLOCK_SIZE);
   if (blockOffset > 0) {
     // Write back the partial block
     memset(reinterpret_cast<char*>(mPartialBlockBuffer) + blockOffset, 0,
            BLOCK_SIZE - blockOffset);
     gMediaCache->AllocateAndWriteBlock(this, mPartialBlockBuffer,
         mMetadataInPartialBlockBuffer ? MODE_METADATA : MODE_PLAYBACK);
@@ -1868,113 +1859,113 @@ nsMediaCacheStream::~nsMediaCacheStream(
     gMediaCache->ReleaseStream(this);
     nsMediaCache::MaybeShutdown();
   }
 }
 
 void
 nsMediaCacheStream::SetSeekable(PRBool aIsSeekable)
 {
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
   NS_ASSERTION(mIsSeekable || aIsSeekable ||
                mChannelOffset == 0, "channel offset must be zero when we become non-seekable");
   mIsSeekable = aIsSeekable;
   // Queue an Update since we may change our strategy for dealing
   // with this stream
   gMediaCache->QueueUpdate();
 }
 
 PRBool
 nsMediaCacheStream::IsSeekable()
 {
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
   return mIsSeekable;
 }
 
 void
 nsMediaCacheStream::Close()
 {
   NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
 
-  nsAutoMonitor mon(gMediaCache->Monitor());
-  CloseInternal(&mon);
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  CloseInternal(mon);
   // Queue an Update since we may have created more free space. Don't do
   // it from CloseInternal since that gets called by Update() itself
   // sometimes, and we try to not to queue updates from Update().
   gMediaCache->QueueUpdate();
 }
 
 void
-nsMediaCacheStream::CloseInternal(nsAutoMonitor* aMonitor)
+nsMediaCacheStream::CloseInternal(MonitorAutoEnter& aMonitor)
 {
   NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
 
   if (mClosed)
     return;
   mClosed = PR_TRUE;
   gMediaCache->ReleaseStreamBlocks(this);
   // Wake up any blocked readers
-  aMonitor->NotifyAll();
+  aMonitor.NotifyAll();
 }
 
 void
 nsMediaCacheStream::Pin()
 {
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
   ++mPinCount;
   // Queue an Update since we may no longer want to read more into the
   // cache, if this stream's block have become non-evictable
   gMediaCache->QueueUpdate();
 }
 
 void
 nsMediaCacheStream::Unpin()
 {
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
   NS_ASSERTION(mPinCount > 0, "Unbalanced Unpin");
   --mPinCount;
   // Queue an Update since we may be able to read more into the
   // cache, if this stream's block have become evictable
   gMediaCache->QueueUpdate();
 }
 
 PRInt64
 nsMediaCacheStream::GetLength()
 {
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
   return mStreamLength;
 }
 
 PRInt64
 nsMediaCacheStream::GetNextCachedData(PRInt64 aOffset)
 {
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
   return GetNextCachedDataInternal(aOffset);
 }
 
 PRInt64
 nsMediaCacheStream::GetCachedDataEnd(PRInt64 aOffset)
 {
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
   return GetCachedDataEndInternal(aOffset);
 }
 
 PRBool
 nsMediaCacheStream::IsDataCachedToEndOfStream(PRInt64 aOffset)
 {
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
   if (mStreamLength < 0)
     return PR_FALSE;
   return GetCachedDataEndInternal(aOffset) >= mStreamLength;
 }
 
 PRInt64
 nsMediaCacheStream::GetCachedDataEndInternal(PRInt64 aOffset)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(gMediaCache->Monitor());
+  gMediaCache->GetMonitor().AssertCurrentThreadIn();
   PRUint32 startBlockIndex = aOffset/BLOCK_SIZE;
   PRUint32 blockIndex = startBlockIndex;
   while (blockIndex < mBlocks.Length() && mBlocks[blockIndex] != -1) {
     ++blockIndex;
   }
   PRInt64 result = blockIndex*BLOCK_SIZE;
   if (blockIndex == mChannelOffset/BLOCK_SIZE) {
     // The block containing mChannelOffset may be partially read but not
@@ -1987,17 +1978,17 @@ nsMediaCacheStream::GetCachedDataEndInte
     result = PR_MIN(result, mStreamLength);
   }
   return PR_MAX(result, aOffset);
 }
 
 PRInt64
 nsMediaCacheStream::GetNextCachedDataInternal(PRInt64 aOffset)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(gMediaCache->Monitor());
+  gMediaCache->GetMonitor().AssertCurrentThreadIn();
   if (aOffset == mStreamLength)
     return -1;
 
   PRUint32 startBlockIndex = aOffset/BLOCK_SIZE;
   PRUint32 channelBlockIndex = mChannelOffset/BLOCK_SIZE;
 
   if (startBlockIndex == channelBlockIndex &&
       aOffset < mChannelOffset) {
@@ -2034,40 +2025,40 @@ nsMediaCacheStream::GetNextCachedDataInt
 
   NS_NOTREACHED("Should return in loop");
   return -1;
 }
 
 void
 nsMediaCacheStream::SetReadMode(ReadMode aMode)
 {
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
   if (aMode == mCurrentMode)
     return;
   mCurrentMode = aMode;
   gMediaCache->QueueUpdate();
 }
 
 void
 nsMediaCacheStream::SetPlaybackRate(PRUint32 aBytesPerSecond)
 {
   NS_ASSERTION(aBytesPerSecond > 0, "Zero playback rate not allowed");
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
   if (aBytesPerSecond == mPlaybackBytesPerSecond)
     return;
   mPlaybackBytesPerSecond = aBytesPerSecond;
   gMediaCache->QueueUpdate();
 }
 
 nsresult
 nsMediaCacheStream::Seek(PRInt32 aWhence, PRInt64 aOffset)
 {
   NS_ASSERTION(!NS_IsMainThread(), "Don't call on main thread");
 
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
   if (mClosed)
     return NS_ERROR_FAILURE;
 
   PRInt64 oldOffset = mStreamOffset;
   switch (aWhence) {
   case PR_SEEK_END:
     if (mStreamLength < 0)
       return NS_ERROR_FAILURE;
@@ -2091,26 +2082,26 @@ nsMediaCacheStream::Seek(PRInt32 aWhence
   return NS_OK;
 }
 
 PRInt64
 nsMediaCacheStream::Tell()
 {
   NS_ASSERTION(!NS_IsMainThread(), "Don't call on main thread");
 
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
   return mStreamOffset;
 }
 
 nsresult
 nsMediaCacheStream::Read(char* aBuffer, PRUint32 aCount, PRUint32* aBytes)
 {
   NS_ASSERTION(!NS_IsMainThread(), "Don't call on main thread");
 
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
   if (mClosed)
     return NS_ERROR_FAILURE;
 
   PRUint32 count = 0;
   // Read one block (or part of a block) at a time
   while (count < aCount) {
     PRUint32 streamBlock = PRUint32(mStreamOffset/BLOCK_SIZE);
     PRUint32 offsetInStreamBlock =
@@ -2185,17 +2176,17 @@ nsMediaCacheStream::Read(char* aBuffer, 
   return NS_OK;
 }
 
 nsresult
 nsMediaCacheStream::ReadFromCache(char* aBuffer,
                                   PRInt64 aOffset,
                                   PRInt64 aCount)
 {
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
   if (mClosed)
     return NS_ERROR_FAILURE;
 
   // Read one block (or part of a block) at a time
   PRUint32 count = 0;
   PRInt64 streamOffset = aOffset;
   while (count < aCount) {
     PRUint32 streamBlock = PRUint32(streamOffset/BLOCK_SIZE);
@@ -2263,17 +2254,17 @@ nsMediaCacheStream::InitAsClone(nsMediaC
     return NS_OK;
 
   nsresult rv = Init();
   if (NS_FAILED(rv))
     return rv;
   mResourceID = aOriginal->mResourceID;
 
   // Grab cache blocks from aOriginal as readahead blocks for our stream
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
 
   mPrincipal = aOriginal->mPrincipal;
   mStreamLength = aOriginal->mStreamLength;
   mIsSeekable = aOriginal->mIsSeekable;
 
   // Cloned streams are initially suspended, since there is no channel open
   // initially for a clone.
   mCacheSuspended = PR_TRUE;
@@ -2293,17 +2284,17 @@ nsMediaCacheStream::InitAsClone(nsMediaC
 
   return NS_OK;
 }
 
 nsresult nsMediaCacheStream::GetCachedRanges(nsTArray<nsByteRange>& aRanges)
 {
   // Take the monitor, so that the cached data ranges can't grow while we're
   // trying to loop over them.
-  nsAutoMonitor mon(gMediaCache->Monitor());
+  MonitorAutoEnter mon(gMediaCache->GetMonitor());
 
   // We must be pinned while running this, otherwise the cached data ranges may
   // shrink while we're trying to loop over them.
   NS_ASSERTION(mPinCount > 0, "Must be pinned");
 
   PRInt64 startOffset = GetNextCachedData(0);
   while (startOffset >= 0) {
     PRInt64 endOffset = GetCachedDataEnd(startOffset);
--- a/content/media/nsMediaCache.h
+++ b/content/media/nsMediaCache.h
@@ -35,21 +35,23 @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef nsMediaCache_h_
 #define nsMediaCache_h_
 
 #include "nsTArray.h"
-#include "nsAutoLock.h"
 #include "nsIPrincipal.h"
 #include "nsCOMPtr.h"
 
 class nsByteRange;
+namespace mozilla {
+class MonitorAutoEnter;
+}
 
 /**
  * Media applications want fast, "on demand" random access to media data,
  * for pausing, seeking, etc. But we are primarily interested
  * in transporting media data using HTTP over the Internet, which has
  * high latency to open a connection, requires a new connection for every
  * seek, may not even support seeking on some connections (especially
  * live streams), and uses a push model --- data comes from the server
@@ -204,16 +206,18 @@ class nsMediaChannelStream;
 
 /**
  * If the cache fails to initialize then Init will fail, so nonstatic
  * methods of this class can assume gMediaCache is non-null.
  * 
  * This class can be directly embedded as a value.
  */
 class nsMediaCacheStream {
+  typedef mozilla::MonitorAutoEnter MonitorAutoEnter;
+
 public:
   enum {
     // This needs to be a power of two
     BLOCK_SIZE = 32768
   };
   enum ReadMode {
     MODE_METADATA,
     MODE_PLAYBACK
@@ -424,17 +428,17 @@ private:
   // This method assumes that the cache monitor is held and can be called on
   // any thread.
   PRInt64 GetNextCachedDataInternal(PRInt64 aOffset);
   // A helper function to do the work of closing the stream. Assumes
   // that the cache monitor is held. Main thread only.
   // aMonitor is the nsAutoMonitor wrapper holding the cache monitor.
   // This is used to NotifyAll to wake up threads that might be
   // blocked on reading from this stream.
-  void CloseInternal(nsAutoMonitor* aMonitor);
+  void CloseInternal(MonitorAutoEnter& aMonitor);
   // Update mPrincipal given that data has been received from aPrincipal
   void UpdatePrincipal(nsIPrincipal* aPrincipal);
 
   // These fields are main-thread-only.
   nsMediaChannelStream*  mClient;
   nsCOMPtr<nsIPrincipal> mPrincipal;
   // This is a unique ID representing the resource we're loading.
   // All streams with the same mResourceID are loading the same
--- a/content/media/nsMediaDecoder.cpp
+++ b/content/media/nsMediaDecoder.cpp
@@ -42,26 +42,27 @@
 #include "prlog.h"
 #include "prmem.h"
 #include "nsIFrame.h"
 #include "nsIDocument.h"
 #include "nsThreadUtils.h"
 #include "nsIDOMHTMLMediaElement.h"
 #include "nsNetUtil.h"
 #include "nsHTMLMediaElement.h"
-#include "nsAutoLock.h"
 #include "nsIRenderingContext.h"
 #include "gfxContext.h"
 #include "nsPresContext.h"
 #include "nsDOMError.h"
 #include "nsDisplayList.h"
 #ifdef MOZ_SVG
 #include "nsSVGEffects.h"
 #endif
 
+using namespace mozilla;
+
 // Number of milliseconds between progress events as defined by spec
 #define PROGRESS_MS 350
 
 // Number of milliseconds of no data before a stall event is fired as defined by spec
 #define STALL_MS 3000
 
 // Number of estimated seconds worth of data we need to have buffered 
 // ahead of the current playback position before we allow the media decoder
@@ -70,42 +71,36 @@
 // nsMediaDecoder::CanPlayThrough() calculation more stable in the case of
 // fluctuating bitrates.
 #define CAN_PLAY_THROUGH_MARGIN 10
 
 nsMediaDecoder::nsMediaDecoder() :
   mElement(0),
   mRGBWidth(-1),
   mRGBHeight(-1),
-  mVideoUpdateLock(nsnull),
+  mVideoUpdateLock("nsMediaDecoder.mVideoUpdateLock"),
   mPixelAspectRatio(1.0),
   mFrameBufferLength(0),
   mPinnedForSeek(PR_FALSE),
   mSizeChanged(PR_FALSE),
   mImageContainerSizeChanged(PR_FALSE),
   mShuttingDown(PR_FALSE)
 {
   MOZ_COUNT_CTOR(nsMediaDecoder);
 }
 
 nsMediaDecoder::~nsMediaDecoder()
 {
-  if (mVideoUpdateLock) {
-    nsAutoLock::DestroyLock(mVideoUpdateLock);
-    mVideoUpdateLock = nsnull;
-  }
   MOZ_COUNT_DTOR(nsMediaDecoder);
 }
 
 PRBool nsMediaDecoder::Init(nsHTMLMediaElement* aElement)
 {
   mElement = aElement;
-  mVideoUpdateLock = nsAutoLock::NewLock("nsMediaDecoder::mVideoUpdateLock");
-
-  return mVideoUpdateLock != nsnull;
+  return PR_TRUE;
 }
 
 void nsMediaDecoder::Shutdown()
 {
   StopProgress();
   mElement = nsnull;
 }
 
@@ -137,17 +132,17 @@ void nsMediaDecoder::Invalidate()
 {
   if (!mElement)
     return;
 
   nsIFrame* frame = mElement->GetPrimaryFrame();
   PRBool invalidateFrame = PR_FALSE;
 
   {
-    nsAutoLock lock(mVideoUpdateLock);
+    MutexAutoLock lock(mVideoUpdateLock);
 
     // Get mImageContainerSizeChanged while holding the lock.
     invalidateFrame = mImageContainerSizeChanged;
     mImageContainerSizeChanged = PR_FALSE;
 
     if (mSizeChanged) {
       nsIntSize scaledSize(mRGBWidth, mRGBHeight);
       // Apply the aspect ratio to produce the intrinsic size we report
@@ -253,17 +248,17 @@ void nsMediaDecoder::FireTimeUpdate()
   mElement->FireTimeUpdate(PR_TRUE);
 }
 
 void nsMediaDecoder::SetVideoData(const gfxIntSize& aSize,
                                   float aPixelAspectRatio,
                                   Image* aImage,
                                   TimeStamp aTarget)
 {
-  nsAutoLock lock(mVideoUpdateLock);
+  MutexAutoLock lock(mVideoUpdateLock);
 
   if (mRGBWidth != aSize.width || mRGBHeight != aSize.height ||
       mPixelAspectRatio != aPixelAspectRatio) {
     mRGBWidth = aSize.width;
     mRGBHeight = aSize.height;
     mPixelAspectRatio = aPixelAspectRatio;
     mSizeChanged = PR_TRUE;
   }
@@ -282,17 +277,17 @@ void nsMediaDecoder::SetVideoData(const 
     }
   }
 
   mPaintTarget = aTarget;
 }
 
 double nsMediaDecoder::GetFrameDelay()
 {
-  nsAutoLock lock(mVideoUpdateLock);
+  MutexAutoLock lock(mVideoUpdateLock);
   return mPaintDelay.ToSeconds();
 }
 
 void nsMediaDecoder::PinForSeek()
 {
   nsMediaStream* stream = GetCurrentStream();
   if (!stream || mPinnedForSeek) {
     return;
--- a/content/media/nsMediaDecoder.h
+++ b/content/media/nsMediaDecoder.h
@@ -43,16 +43,17 @@
 #include "nsIPrincipal.h"
 #include "nsSize.h"
 #include "prlog.h"
 #include "gfxContext.h"
 #include "gfxRect.h"
 #include "nsITimer.h"
 #include "ImageLayers.h"
 #include "mozilla/Monitor.h"
+#include "mozilla/Mutex.h"
 
 class nsHTMLMediaElement;
 class nsMediaStream;
 class nsIStreamListener;
 class nsTimeRanges;
 
 // The size to use for audio data frames in MozAudioAvailable events.
 // This value is per channel, and is chosen to give ~43 fps of events,
@@ -84,16 +85,17 @@ private:
 class nsMediaDecoder : public nsIObserver
 {
 public:
   typedef mozilla::TimeStamp TimeStamp;
   typedef mozilla::TimeDuration TimeDuration;
   typedef mozilla::layers::ImageContainer ImageContainer;
   typedef mozilla::layers::Image Image;
   typedef mozilla::Monitor Monitor;
+  typedef mozilla::Mutex Mutex;
 
   nsMediaDecoder();
   virtual ~nsMediaDecoder();
 
   // Create a new decoder of the same type as this one.
   virtual nsMediaDecoder* Clone() = 0;
 
   // Perform any initialization required for the decoder.
@@ -436,17 +438,17 @@ protected:
   // is used in the decoder backend threads and the main thread
   // to ensure that repainting the video does not use these
   // values while they are out of sync (width changed but
   // not height yet, etc).
   // Backends that are updating the height, width or writing
   // to the RGB buffer must obtain this lock first to ensure that
   // the video element does not use video data or sizes that are
   // in the midst of being changed.
-  PRLock* mVideoUpdateLock;
+  Mutex mVideoUpdateLock;
 
   // Pixel aspect ratio (ratio of the pixel width to pixel height)
   float mPixelAspectRatio;
 
   // The framebuffer size to use for audioavailable events.
   PRUint32 mFrameBufferLength;
 
   // PR_TRUE when our media stream has been pinned. We pin the stream
--- a/content/media/nsMediaStream.cpp
+++ b/content/media/nsMediaStream.cpp
@@ -30,21 +30,21 @@
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
+#include "mozilla/Mutex.h"
 #include "nsDebug.h"
 #include "nsMediaStream.h"
 #include "nsMediaDecoder.h"
 #include "nsNetUtil.h"
-#include "nsAutoLock.h"
 #include "nsThreadUtils.h"
 #include "nsIFile.h"
 #include "nsIFileChannel.h"
 #include "nsIHttpChannel.h"
 #include "nsISeekableStream.h"
 #include "nsIInputStream.h"
 #include "nsIOutputStream.h"
 #include "nsIRequestObserver.h"
@@ -56,38 +56,35 @@
 #include "nsDOMError.h"
 #include "nsICachingChannel.h"
 #include "nsURILoader.h"
 #include "nsIAsyncVerifyRedirectCallback.h"
 
 #define HTTP_OK_CODE 200
 #define HTTP_PARTIAL_RESPONSE_CODE 206
 
-using mozilla::TimeStamp;
+using namespace mozilla;
 
 nsMediaChannelStream::nsMediaChannelStream(nsMediaDecoder* aDecoder,
     nsIChannel* aChannel, nsIURI* aURI)
   : nsMediaStream(aDecoder, aChannel, aURI),
     mOffset(0), mSuspendCount(0),
     mReopenOnError(PR_FALSE), mIgnoreClose(PR_FALSE),
     mCacheStream(this),
-    mLock(nsAutoLock::NewLock("media.channel.stream")),
+    mLock("nsMediaChannelStream.mLock"),
     mCacheSuspendCount(0)
 {
 }
 
 nsMediaChannelStream::~nsMediaChannelStream()
 {
   if (mListener) {
     // Kill its reference to us since we're going away
     mListener->Revoke();
   }
-  if (mLock) {
-    nsAutoLock::DestroyLock(mLock);
-  }
 }
 
 // nsMediaChannelStream::Listener just observes the channel and
 // forwards notifications to the nsMediaChannelStream. We use multiple
 // listener objects so that when we open a new stream for a seek we can
 // disconnect the old listener from the nsMediaChannelStream and hook up
 // a new listener, so notifications from the old channel are discarded
 // and don't confuse us.
@@ -266,17 +263,17 @@ nsMediaChannelStream::OnStartRequest(nsI
     PRBool fromCache = PR_FALSE;
     rv = cc->IsFromCache(&fromCache);
     if (NS_SUCCEEDED(rv) && !fromCache) {
       cc->SetCacheAsFile(PR_TRUE);
     }
   }
 
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     mChannelStatistics.Start(TimeStamp::Now());
   }
 
   mReopenOnError = PR_FALSE;
   mIgnoreClose = PR_FALSE;
   if (mSuspendCount > 0) {
     // Re-suspend the channel if it needs to be suspended
     mChannel->Suspend();
@@ -292,17 +289,17 @@ nsMediaChannelStream::OnStartRequest(nsI
 nsresult
 nsMediaChannelStream::OnStopRequest(nsIRequest* aRequest, nsresult aStatus)
 {
   NS_ASSERTION(mChannel.get() == aRequest, "Wrong channel!");
   NS_ASSERTION(mSuspendCount == 0,
                "How can OnStopRequest fire while we're suspended?");
 
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     mChannelStatistics.Stop(TimeStamp::Now());
   }
 
   // Note that aStatus might have succeeded --- this might be a normal close
   // --- even in situations where the server cut us off because we were
   // suspended. So we need to "reopen on error" in that case too. The only
   // cases where we don't need to reopen are when *we* closed the stream.
   // But don't reopen if we need to seek and we don't think we can... that would
@@ -378,17 +375,17 @@ nsMediaChannelStream::CopySegmentToCache
 nsresult
 nsMediaChannelStream::OnDataAvailable(nsIRequest* aRequest,
                                       nsIInputStream* aStream,
                                       PRUint32 aCount)
 {
   NS_ASSERTION(mChannel.get() == aRequest, "Wrong channel!");
 
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     mChannelStatistics.AddBytes(aCount);
   }
 
   CopySegmentClosure closure;
   nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
   if (secMan && mChannel) {
     secMan->GetChannelPrincipal(mChannel, getter_AddRefs(closure.mPrincipal));
   }
@@ -407,18 +404,16 @@ nsMediaChannelStream::OnDataAvailable(ns
 
   return NS_OK;
 }
 
 nsresult nsMediaChannelStream::Open(nsIStreamListener **aStreamListener)
 {
   NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
 
-  if (!mLock)
-    return NS_ERROR_OUT_OF_MEMORY;
   nsresult rv = mCacheStream.Init();
   if (NS_FAILED(rv))
     return rv;
   NS_ASSERTION(mOffset == 0, "Who set mOffset already?");
 
   if (!mChannel) {
     // When we're a clone, the decoder might ask us to Open even though
     // we haven't established an mChannel (because we might not need one)
@@ -544,17 +539,17 @@ nsMediaStream* nsMediaChannelStream::Clo
   return stream;
 }
 
 void nsMediaChannelStream::CloseChannel()
 {
   NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
 
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     mChannelStatistics.Stop(TimeStamp::Now());
   }
 
   if (mListener) {
     mListener->Revoke();
     mListener = nsnull;
   }
 
@@ -623,17 +618,17 @@ void nsMediaChannelStream::Suspend(PRBoo
   if (mChannel) {
     if (aCloseImmediately && mCacheStream.IsSeekable()) {
       // Kill off our channel right now, but don't tell anyone about it.
       mIgnoreClose = PR_TRUE;
       CloseChannel();
       element->DownloadSuspended();
     } else if (mSuspendCount == 0) {
       {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
         mChannelStatistics.Stop(TimeStamp::Now());
       }
       mChannel->Suspend();
       element->DownloadSuspended();
     }
   }
 
   ++mSuspendCount;
@@ -651,17 +646,17 @@ void nsMediaChannelStream::Resume()
   }
 
   NS_ASSERTION(mSuspendCount > 0, "Resume without previous Suspend!");
   --mSuspendCount;
   if (mSuspendCount == 0) {
     if (mChannel) {
       // Just wake up our existing channel
       {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
         mChannelStatistics.Start(TimeStamp::Now());
       }
       // if an error occurs after Resume, assume it's because the server
       // timed out the connection and we should reopen it.
       mReopenOnError = PR_TRUE;
       mChannel->Resume();
       element->DownloadResumed();
     } else {
@@ -757,17 +752,17 @@ nsMediaChannelStream::CacheClientSeek(PR
 
   CloseChannel();
 
   if (aResume) {
     NS_ASSERTION(mSuspendCount > 0, "Too many resumes!");
     // No need to mess with the channel, since we're making a new one
     --mSuspendCount;
     {
-      nsAutoLock lock(mLock);
+      MutexAutoLock lock(mLock);
       NS_ASSERTION(mCacheSuspendCount > 0, "CacheClientSeek(aResume=true) without previous CacheClientSuspend!");
       --mCacheSuspendCount;
     }
   }
 
   nsresult rv = RecreateChannel();
   if (NS_FAILED(rv))
     return rv;
@@ -775,31 +770,31 @@ nsMediaChannelStream::CacheClientSeek(PR
   mOffset = aOffset;
   return OpenChannel(nsnull);
 }
 
 nsresult
 nsMediaChannelStream::CacheClientSuspend()
 {
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     ++mCacheSuspendCount;
   }
   Suspend(PR_FALSE);
 
   mDecoder->NotifySuspendedStatusChanged();
   return NS_OK;
 }
 
 nsresult
 nsMediaChannelStream::CacheClientResume()
 {
   Resume();
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     NS_ASSERTION(mCacheSuspendCount > 0, "CacheClientResume without previous CacheClientSuspend!");
     --mCacheSuspendCount;
   }
 
   mDecoder->NotifySuspendedStatusChanged();
   return NS_OK;
 }
 
@@ -819,24 +814,24 @@ PRBool
 nsMediaChannelStream::IsDataCachedToEndOfStream(PRInt64 aOffset)
 {
   return mCacheStream.IsDataCachedToEndOfStream(aOffset);
 }
 
 PRBool
 nsMediaChannelStream::IsSuspendedByCache()
 {
-  nsAutoLock lock(mLock);
+  MutexAutoLock lock(mLock);
   return mCacheSuspendCount > 0;
 }
 
 PRBool
 nsMediaChannelStream::IsSuspended()
 {
-  nsAutoLock lock(mLock);
+  MutexAutoLock lock(mLock);
   return mSuspendCount > 0;
 }
 
 void
 nsMediaChannelStream::SetReadMode(nsMediaCacheStream::ReadMode aMode)
 {
   mCacheStream.SetReadMode(aMode);
 }
@@ -857,39 +852,36 @@ void
 nsMediaChannelStream::Unpin()
 {
   mCacheStream.Unpin();
 }
 
 double
 nsMediaChannelStream::GetDownloadRate(PRPackedBool* aIsReliable)
 {
-  nsAutoLock lock(mLock);
+  MutexAutoLock lock(mLock);
   return mChannelStatistics.GetRate(TimeStamp::Now(), aIsReliable);
 }
 
 PRInt64
 nsMediaChannelStream::GetLength()
 {
   return mCacheStream.GetLength();
 }
 
 class nsMediaFileStream : public nsMediaStream
 {
 public:
   nsMediaFileStream(nsMediaDecoder* aDecoder, nsIChannel* aChannel, nsIURI* aURI) :
     nsMediaStream(aDecoder, aChannel, aURI), mSize(-1),
-    mLock(nsAutoLock::NewLock("media.file.stream"))
+    mLock("nsMediaFileStream.mLock")
   {
   }
   ~nsMediaFileStream()
   {
-    if (mLock) {
-      nsAutoLock::DestroyLock(mLock);
-    }
   }
 
   // Main thread
   virtual nsresult Open(nsIStreamListener** aStreamListener);
   virtual nsresult Close();
   virtual void     Suspend(PRBool aCloseImmediately) {}
   virtual void     Resume() {}
   virtual already_AddRefed<nsIPrincipal> GetCurrentPrincipal();
@@ -930,17 +922,17 @@ private:
   // The file size, or -1 if not known. Immutable after Open().
   PRInt64 mSize;
 
   // This lock handles synchronisation between calls to Close() and
   // the Read, Seek, etc calls. Close must not be called while a
   // Read or Seek is in progress since it resets various internal
   // values to null.
   // This lock protects mSeekable and mInput.
-  PRLock* mLock;
+  Mutex mLock;
 
   // Seekable stream interface to file. This can be used from any
   // thread.
   nsCOMPtr<nsISeekableStream> mSeekable;
 
   // Input stream for the media data. This can be used from any
   // thread.
   nsCOMPtr<nsIInputStream>  mInput;
@@ -1036,17 +1028,17 @@ nsresult nsMediaFileStream::Open(nsIStre
   NS_DispatchToMainThread(event, NS_DISPATCH_NORMAL);
   return NS_OK;
 }
 
 nsresult nsMediaFileStream::Close()
 {
   NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
 
-  nsAutoLock lock(mLock);
+  MutexAutoLock lock(mLock);
   if (mChannel) {
     mChannel->Cancel(NS_ERROR_PARSED_DATA_CACHED);
     mChannel = nsnull;
     mInput = nsnull;
     mSeekable = nsnull;
   }
 
   return NS_OK;
@@ -1082,17 +1074,17 @@ nsMediaStream* nsMediaFileStream::CloneD
   if (NS_FAILED(rv))
     return nsnull;
 
   return new nsMediaFileStream(aDecoder, channel, mURI);
 }
 
 nsresult nsMediaFileStream::ReadFromCache(char* aBuffer, PRInt64 aOffset, PRUint32 aCount)
 {
-  nsAutoLock lock(mLock);
+  MutexAutoLock lock(mLock);
   if (!mInput || !mSeekable)
     return NS_ERROR_FAILURE;
   PRInt64 offset = 0;
   nsresult res = mSeekable->Tell(&offset);
   NS_ENSURE_SUCCESS(res,res);
   res = mSeekable->Seek(nsISeekableStream::NS_SEEK_SET, aOffset);
   NS_ENSURE_SUCCESS(res,res);
   PRUint32 bytesRead = 0;
@@ -1111,37 +1103,37 @@ nsresult nsMediaFileStream::ReadFromCach
   NS_ENSURE_SUCCESS(res,res);
 
   // Else we succeed if the reset-seek succeeds.
   return seekres;
 }
 
 nsresult nsMediaFileStream::Read(char* aBuffer, PRUint32 aCount, PRUint32* aBytes)
 {
-  nsAutoLock lock(mLock);
+  MutexAutoLock lock(mLock);
   if (!mInput)
     return NS_ERROR_FAILURE;
   return mInput->Read(aBuffer, aCount, aBytes);
 }
 
 nsresult nsMediaFileStream::Seek(PRInt32 aWhence, PRInt64 aOffset)
 {
   NS_ASSERTION(!NS_IsMainThread(), "Don't call on main thread");
 
-  nsAutoLock lock(mLock);
+  MutexAutoLock lock(mLock);
   if (!mSeekable)
     return NS_ERROR_FAILURE;
   return mSeekable->Seek(aWhence, aOffset);
 }
 
 PRInt64 nsMediaFileStream::Tell()
 {
   NS_ASSERTION(!NS_IsMainThread(), "Don't call on main thread");
 
-  nsAutoLock lock(mLock);
+  MutexAutoLock lock(mLock);
   if (!mSeekable)
     return 0;
 
   PRInt64 offset = 0;
   mSeekable->Tell(&offset);
   return offset;
 }
 
--- a/content/media/nsMediaStream.h
+++ b/content/media/nsMediaStream.h
@@ -33,24 +33,24 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #if !defined(nsMediaStream_h_)
 #define nsMediaStream_h_
 
+#include "mozilla/Mutex.h"
 #include "mozilla/XPCOM.h"
 #include "nsIChannel.h"
 #include "nsIPrincipal.h"
 #include "nsIURI.h"
 #include "nsIStreamListener.h"
 #include "nsIChannelEventSink.h"
 #include "nsIInterfaceRequestor.h"
-#include "prlock.h"
 #include "nsMediaCache.h"
 
 // For HTTP seeking, if number of bytes needing to be
 // seeked forward is less than this value then a read is
 // done rather than a byte range request.
 #define SEEK_VS_READ_THRESHOLD (32*1024)
 
 #define HTTP_REQUESTED_RANGE_NOT_SATISFIABLE_CODE 416
@@ -339,16 +339,18 @@ protected:
  * Much of its functionality is actually delegated to nsMediaCache via
  * an underlying nsMediaCacheStream.
  *
  * All synchronization is performed by nsMediaCacheStream; all off-main-
  * thread operations are delegated directly to that object.
  */
 class nsMediaChannelStream : public nsMediaStream
 {
+  typedef mozilla::Mutex Mutex;
+
 public:
   nsMediaChannelStream(nsMediaDecoder* aDecoder, nsIChannel* aChannel, nsIURI* aURI);
   ~nsMediaChannelStream();
 
   // These are called on the main thread by nsMediaCache. These must
   // not block or grab locks, because the media cache is holding its lock.
   // Notify that data is available from the cache. This can happen even
   // if this stream didn't read any data, since another stream might have
@@ -463,14 +465,14 @@ protected:
   // When this flag is set, we should not report the next close of the
   // channel.
   PRPackedBool       mIgnoreClose;
 
   // Any thread access
   nsMediaCacheStream mCacheStream;
 
   // This lock protects mChannelStatistics and mCacheSuspendCount
-  PRLock* mLock;
+  Mutex               mLock;
   nsChannelStatistics mChannelStatistics;
   PRUint32            mCacheSuspendCount;
 };
 
 #endif
--- a/dom/src/threads/nsDOMThreadService.cpp
+++ b/dom/src/threads/nsDOMThreadService.cpp
@@ -54,17 +54,16 @@
 #include "nsIScriptGlobalObject.h"
 #include "nsIServiceManager.h"
 #include "nsISupportsPriority.h"
 #include "nsIThreadPool.h"
 #include "nsIXPConnect.h"
 #include "nsPIDOMWindow.h"
 
 // Other includes
-#include "nsAutoLock.h"
 #include "nsAutoPtr.h"
 #include "nsContentUtils.h"
 #include "nsDeque.h"
 #include "nsGlobalWindow.h"
 #include "nsIClassInfoImpl.h"
 #include "nsStringBuffer.h"
 #include "nsThreadUtils.h"
 #include "nsXPCOM.h"
@@ -77,16 +76,18 @@
 #include "nsDOMWorker.h"
 #include "nsDOMWorkerEvents.h"
 #include "nsDOMWorkerMacros.h"
 #include "nsDOMWorkerMessageHandler.h"
 #include "nsDOMWorkerPool.h"
 #include "nsDOMWorkerSecurityManager.h"
 #include "nsDOMWorkerTimeout.h"
 
+using namespace mozilla;
+
 #ifdef PR_LOGGING
 PRLogModuleInfo *gDOMThreadsLog = nsnull;
 #endif
 #define LOG(_args) PR_LOG(gDOMThreadsLog, PR_LOG_DEBUG, _args)
 
 // The maximum number of threads in the internal thread pool
 #define THREADPOOL_MAX_THREADS 3
 
@@ -367,17 +368,17 @@ public:
     ClearQueue();
   }
 
   void PutRunnable(nsIRunnable* aRunnable,
                    PRIntervalTime aTimeoutInterval,
                    PRBool aClearQueue) {
     NS_ASSERTION(aRunnable, "Null pointer!");
 
-    PR_ASSERT_CURRENT_THREAD_IN_MONITOR(gDOMThreadService->mMonitor);
+    gDOMThreadService->mMonitor.AssertCurrentThreadIn();
 
     if (NS_LIKELY(!aTimeoutInterval)) {
       NS_ADDREF(aRunnable);
       mRunnables.Push(aRunnable);
     }
     else {
       NS_ASSERTION(!mCloseRunnable, "More than one close runnable?!");
       if (aClearQueue) {
@@ -460,17 +461,17 @@ public:
           // replaced outside of a request.
           JSAutoRequest ar2(cx);
 
           // This is usually due to a parse error in the worker script...
           JS_SetGlobalObject(cx, NULL);
           JS_SetContextPrivate(cx, NULL);
         }
 
-        nsAutoMonitor mon(gDOMThreadService->mMonitor);
+        MonitorAutoEnter mon(gDOMThreadService->mMonitor);
         killWorkerWhenDone = mKillWorkerWhenDone;
         gDOMThreadService->WorkerComplete(this);
         mon.NotifyAll();
       }
     }
 
     if (killWorkerWhenDone) {
       nsCOMPtr<nsIRunnable> runnable = new nsDOMWorkerKillRunnable(mWorker);
@@ -490,17 +491,17 @@ protected:
       // Loop until all the runnables are dead.
     }
   }
 
   void RunQueue(JSContext* aCx, PRBool* aCloseRunnableSet) {
     while (1) {
       nsCOMPtr<nsIRunnable> runnable;
       {
-        nsAutoMonitor mon(gDOMThreadService->mMonitor);
+        MonitorAutoEnter mon(gDOMThreadService->mMonitor);
 
         runnable = dont_AddRef((nsIRunnable*)mRunnables.PopFront());
 
         if (!runnable && mCloseRunnable) {
           PRIntervalTime expirationTime;
           if (mCloseTimeoutInterval == PR_INTERVAL_NO_TIMEOUT) {
             expirationTime = mCloseTimeoutInterval;
           }
@@ -567,17 +568,17 @@ DOMWorkerOperationCallback(JSContext* aC
     PRBool extraThreadAllowed =
       NS_SUCCEEDED(gDOMThreadService->ChangeThreadPoolMaxThreads(1));
 
     // Flush JIT caches now before suspending to avoid holding memory that we
     // are not going to use.
     JS_FlushCaches(aCx);
 
     for (;;) {
-      nsAutoMonitor mon(worker->Pool()->Monitor());
+      MonitorAutoEnter mon(worker->Pool()->GetMonitor());
 
       // There's a small chance that the worker was canceled after our check
       // above in which case we shouldn't wait here. We're guaranteed not to
       // race here because the pool reenters its monitor after canceling each
       // worker in order to notify its condition variable.
       canceled = worker->IsCanceled();
       if (!canceled && worker->IsSuspended()) {
         mon.Wait();
@@ -723,17 +724,17 @@ DOMWorkerErrorReporter(JSContext* aCx,
   }
 }
 
 /*******************************************************************************
  * nsDOMThreadService
  */
 
 nsDOMThreadService::nsDOMThreadService()
-: mMonitor(nsnull),
+: mMonitor("nsDOMThreadServer.mMonitor"),
   mNavigatorStringsLoaded(PR_FALSE)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 #ifdef PR_LOGGING
   if (!gDOMThreadsLog) {
     gDOMThreadsLog = PR_NewLogModule("nsDOMThreads");
   }
 #endif
@@ -742,20 +743,16 @@ nsDOMThreadService::nsDOMThreadService()
 
 nsDOMThreadService::~nsDOMThreadService()
 {
   LOG(("DOM Thread service destroyed"));
 
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 
   Cleanup();
-
-  if (mMonitor) {
-    nsAutoMonitor::DestroyMonitor(mMonitor);
-  }
 }
 
 NS_IMPL_THREADSAFE_ISUPPORTS3(nsDOMThreadService, nsIEventTarget,
                                                   nsIObserver,
                                                   nsIThreadPoolListener)
 
 nsresult
 nsDOMThreadService::Init()
@@ -782,19 +779,16 @@ nsDOMThreadService::Init()
   NS_ENSURE_SUCCESS(rv, rv);
 
   rv = mThreadPool->SetThreadLimit(THREADPOOL_MAX_THREADS);
   NS_ENSURE_SUCCESS(rv, rv);
 
   rv = mThreadPool->SetIdleThreadLimit(THREADPOOL_IDLE_THREADS);
   NS_ENSURE_SUCCESS(rv, rv);
 
-  mMonitor = nsAutoMonitor::NewMonitor("nsDOMThreadService::mMonitor");
-  NS_ENSURE_TRUE(mMonitor, NS_ERROR_OUT_OF_MEMORY);
-
   PRBool success = mWorkersInProgress.Init();
   NS_ENSURE_TRUE(success, NS_ERROR_OUT_OF_MEMORY);
 
   success = mPools.Init();
   NS_ENSURE_TRUE(success, NS_ERROR_OUT_OF_MEMORY);
 
   success = mThreadsafeContractIDs.Init();
   NS_ENSURE_TRUE(success, NS_ERROR_OUT_OF_MEMORY);
@@ -885,17 +879,17 @@ nsDOMThreadService::Cleanup()
   // This will either be called at 'xpcom-shutdown' or earlier if the call to
   // Init fails somehow. We can therefore assume that all services will still
   // be available here.
 
   // Cancel all workers that weren't tied to a window.
   CancelWorkersForGlobal(nsnull);
 
   {
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
 
     NS_ASSERTION(!mPools.Count(), "Live workers left!");
     mPools.Clear();
 
     NS_ASSERTION(!mSuspendedWorkers.Length(), "Suspended workers left!");
     mSuspendedWorkers.Clear();
   }
 
@@ -950,17 +944,17 @@ nsDOMThreadService::Dispatch(nsDOMWorker
   if (aWorker->IsClosing() && !aTimeoutInterval) {
     LOG(("Will not dispatch runnable [0x%p] for closing worker [0x%p]",
          static_cast<void*>(aRunnable), static_cast<void*>(aWorker)));
     return NS_ERROR_NOT_AVAILABLE;
   }
 
   nsRefPtr<nsDOMWorkerRunnable> workerRunnable;
   {
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
 
     if (mWorkersInProgress.Get(aWorker, getter_AddRefs(workerRunnable))) {
       workerRunnable->PutRunnable(aRunnable, aTimeoutInterval, aClearQueue);
       return NS_OK;
     }
 
     workerRunnable = new nsDOMWorkerRunnable(aWorker);
     NS_ENSURE_TRUE(workerRunnable, NS_ERROR_OUT_OF_MEMORY);
@@ -973,17 +967,17 @@ nsDOMThreadService::Dispatch(nsDOMWorker
 
   nsresult rv = mThreadPool->Dispatch(workerRunnable, NS_DISPATCH_NORMAL);
 
   // XXX This is a mess and it could probably be removed once we have an
   // infallible malloc implementation.
   if (NS_FAILED(rv)) {
     NS_WARNING("Failed to dispatch runnable to thread pool!");
 
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
 
     // We exited the monitor after inserting the runnable into the table so make
     // sure we're removing the right one!
     nsRefPtr<nsDOMWorkerRunnable> tableRunnable;
     if (mWorkersInProgress.Get(aWorker, getter_AddRefs(tableRunnable)) &&
         workerRunnable == tableRunnable) {
       mWorkersInProgress.Remove(aWorker);
 
@@ -1001,45 +995,45 @@ void
 nsDOMThreadService::SetWorkerTimeout(nsDOMWorker* aWorker,
                                      PRIntervalTime aTimeoutInterval)
 {
   NS_ASSERTION(aWorker, "Null pointer!");
   NS_ASSERTION(aTimeoutInterval, "No timeout specified!");
 
   NS_ASSERTION(mThreadPool, "Dispatch called after 'xpcom-shutdown'!");
 
-  nsAutoMonitor mon(mMonitor);
+  MonitorAutoEnter mon(mMonitor);
 
   nsRefPtr<nsDOMWorkerRunnable> workerRunnable;
   if (mWorkersInProgress.Get(aWorker, getter_AddRefs(workerRunnable))) {
     workerRunnable->SetCloseRunnableTimeout(aTimeoutInterval);
   }
 }
 
 void
 nsDOMThreadService::WorkerComplete(nsDOMWorkerRunnable* aRunnable)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
 
 #ifdef DEBUG
   nsRefPtr<nsDOMWorker>& debugWorker = aRunnable->mWorker;
 
   nsRefPtr<nsDOMWorkerRunnable> runnable;
   NS_ASSERTION(mWorkersInProgress.Get(debugWorker, getter_AddRefs(runnable)) &&
                runnable == aRunnable,
                "Removing a worker that isn't in our hashtable?!");
 #endif
 
   mWorkersInProgress.Remove(aRunnable->mWorker);
 }
 
 PRBool
 nsDOMThreadService::QueueSuspendedWorker(nsDOMWorkerRunnable* aRunnable)
 {
-  nsAutoMonitor mon(mMonitor);
+  MonitorAutoEnter mon(mMonitor);
 
 #ifdef DEBUG
     {
       // Make sure that the runnable is in mWorkersInProgress.
       nsRefPtr<nsDOMWorkerRunnable> current;
       mWorkersInProgress.Get(aRunnable->mWorker, getter_AddRefs(current));
       NS_ASSERTION(current == aRunnable, "Something crazy wrong here!");
     }
@@ -1086,49 +1080,49 @@ nsDOMThreadService::CreateJSContext()
 
   return cx.forget();
 }
 
 already_AddRefed<nsDOMWorkerPool>
 nsDOMThreadService::GetPoolForGlobal(nsIScriptGlobalObject* aGlobalObject,
                                      PRBool aRemove)
 {
-  nsAutoMonitor mon(mMonitor);
+  MonitorAutoEnter mon(mMonitor);
 
   nsRefPtr<nsDOMWorkerPool> pool;
   mPools.Get(aGlobalObject, getter_AddRefs(pool));
 
   if (aRemove) {
     mPools.Remove(aGlobalObject);
   }
 
   return pool.forget();
 }
 
 void
 nsDOMThreadService::TriggerOperationCallbackForPool(nsDOMWorkerPool* aPool)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
 
   // See if we need to trigger the operation callback on any currently running
   // contexts.
   PRUint32 contextCount = mJSContexts.Length();
   for (PRUint32 index = 0; index < contextCount; index++) {
     JSContext*& cx = mJSContexts[index];
     nsDOMWorker* worker = (nsDOMWorker*)JS_GetContextPrivate(cx);
     if (worker && worker->Pool() == aPool) {
       JS_TriggerOperationCallback(cx);
     }
   }
 }
 
 void
 nsDOMThreadService::RescheduleSuspendedWorkerForPool(nsDOMWorkerPool* aPool)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
 
   PRUint32 count = mSuspendedWorkers.Length();
   if (!count) {
     // Nothing to do here.
     return;
   }
 
   nsTArray<nsDOMWorkerRunnable*> others(count);
@@ -1162,59 +1156,59 @@ nsDOMThreadService::RescheduleSuspendedW
 
 void
 nsDOMThreadService::CancelWorkersForGlobal(nsIScriptGlobalObject* aGlobalObject)
 {
   nsRefPtr<nsDOMWorkerPool> pool = GetPoolForGlobal(aGlobalObject, PR_TRUE);
   if (pool) {
     pool->Cancel();
 
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
 
     TriggerOperationCallbackForPool(pool);
     RescheduleSuspendedWorkerForPool(pool);
   }
 }
 
 void
 nsDOMThreadService::SuspendWorkersForGlobal(nsIScriptGlobalObject* aGlobalObject)
 {
   NS_ASSERTION(aGlobalObject, "Null pointer!");
 
   nsRefPtr<nsDOMWorkerPool> pool = GetPoolForGlobal(aGlobalObject, PR_FALSE);
   if (pool) {
     pool->Suspend();
 
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
     TriggerOperationCallbackForPool(pool);
   }
 }
 
 void
 nsDOMThreadService::ResumeWorkersForGlobal(nsIScriptGlobalObject* aGlobalObject)
 {
   NS_ASSERTION(aGlobalObject, "Null pointer!");
 
   nsRefPtr<nsDOMWorkerPool> pool = GetPoolForGlobal(aGlobalObject, PR_FALSE);
   if (pool) {
     pool->Resume();
 
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
 
     TriggerOperationCallbackForPool(pool);
     RescheduleSuspendedWorkerForPool(pool);
   }
 }
 
 void
 nsDOMThreadService::NoteEmptyPool(nsDOMWorkerPool* aPool)
 {
   NS_ASSERTION(aPool, "Null pointer!");
 
-  nsAutoMonitor mon(mMonitor);
+  MonitorAutoEnter mon(mMonitor);
   mPools.Remove(aPool->ScriptGlobalObject());
 }
 
 void
 nsDOMThreadService::TimeoutReady(nsDOMWorkerTimeout* aTimeout)
 {
   nsRefPtr<nsDOMWorkerTimeoutRunnable> runnable =
     new nsDOMWorkerTimeoutRunnable(aTimeout);
@@ -1223,17 +1217,17 @@ nsDOMThreadService::TimeoutReady(nsDOMWo
   Dispatch(aTimeout->GetWorker(), runnable);
 }
 
 nsresult
 nsDOMThreadService::ChangeThreadPoolMaxThreads(PRInt16 aDelta)
 {
   NS_ENSURE_ARG(aDelta == 1 || aDelta == -1);
 
-  nsAutoMonitor mon(mMonitor);
+  MonitorAutoEnter mon(mMonitor);
 
   PRUint32 currentThreadCount;
   nsresult rv = mThreadPool->GetThreadLimit(&currentThreadCount);
   NS_ENSURE_SUCCESS(rv, rv);
 
   PRInt32 newThreadCount = (PRInt32)currentThreadCount + (PRInt32)aDelta;
   NS_ASSERTION(newThreadCount >= THREADPOOL_MAX_THREADS,
                "Can't go below initial thread count!");
@@ -1261,17 +1255,17 @@ nsDOMThreadService::ChangeThreadPoolMaxT
 }
 
 void
 nsDOMThreadService::NoteThreadsafeContractId(const nsACString& aContractId,
                                              PRBool aIsThreadsafe)
 {
   NS_ASSERTION(!aContractId.IsEmpty(), "Empty contract id!");
 
-  nsAutoMonitor mon(mMonitor);
+  MonitorAutoEnter mon(mMonitor);
 
 #ifdef DEBUG
   {
     PRBool isThreadsafe;
     if (mThreadsafeContractIDs.Get(aContractId, &isThreadsafe)) {
       NS_ASSERTION(aIsThreadsafe == isThreadsafe, "Inconsistent threadsafety!");
     }
   }
@@ -1282,17 +1276,17 @@ nsDOMThreadService::NoteThreadsafeContra
   }
 }
 
 ThreadsafeStatus
 nsDOMThreadService::GetContractIdThreadsafeStatus(const nsACString& aContractId)
 {
   NS_ASSERTION(!aContractId.IsEmpty(), "Empty contract id!");
 
-  nsAutoMonitor mon(mMonitor);
+  MonitorAutoEnter mon(mMonitor);
 
   PRBool isThreadsafe;
   if (mThreadsafeContractIDs.Get(aContractId, &isThreadsafe)) {
     return isThreadsafe ? Threadsafe : NotThreadsafe;
   }
 
   return Unknown;
 }
@@ -1393,17 +1387,17 @@ nsDOMThreadService::OnThreadCreated()
 
     PRStatus status = PR_SetThreadPrivate(gJSContextIndex, cx);
     if (status != PR_SUCCESS) {
       NS_WARNING("Failed to set context on thread!");
       nsContentUtils::XPConnect()->ReleaseJSContext(cx, PR_TRUE);
       return NS_ERROR_FAILURE;
     }
 
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
 
 #ifdef DEBUG
     JSContext** newContext =
 #endif
     mJSContexts.AppendElement(cx);
 
     // We ensure the capacity of this array in Init.
     NS_ASSERTION(newContext, "Should never fail!");
@@ -1422,17 +1416,17 @@ nsDOMThreadService::OnThreadShuttingDown
   LOG(("Thread shutting down"));
 
   NS_ASSERTION(gJSContextIndex != BAD_TLS_INDEX, "No context index!");
 
   JSContext* cx = (JSContext*)PR_GetThreadPrivate(gJSContextIndex);
   NS_WARN_IF_FALSE(cx, "Thread died with no context?");
   if (cx) {
     {
-      nsAutoMonitor mon(mMonitor);
+      MonitorAutoEnter mon(mMonitor);
       mJSContexts.RemoveElement(cx);
     }
 
     JSContext* pushedCx;
     gThreadJSContextStack->Pop(&pushedCx);
     NS_ASSERTION(pushedCx == cx, "Popped the wrong context!");
 
     gThreadJSContextStack->SetSafeJSContext(nsnull);
@@ -1468,17 +1462,17 @@ nsDOMThreadService::RegisterWorker(nsDOM
     nsCOMPtr<nsIScriptGlobalObject> newGlobal(do_QueryInterface(innerWindow));
     NS_ENSURE_TRUE(newGlobal, NS_ERROR_NO_INTERFACE);
 
     aGlobalObject = newGlobal;
   }
 
   nsRefPtr<nsDOMWorkerPool> pool;
   {
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
 
     if (!mThreadPool) {
       // Shutting down!
       return NS_ERROR_ILLEGAL_DURING_SHUTDOWN;
     }
 
     mPools.Get(aGlobalObject, getter_AddRefs(pool));
   }
@@ -1517,17 +1511,17 @@ nsDOMThreadService::RegisterWorker(nsDOM
     }
 
     pool = new nsDOMWorkerPool(aGlobalObject, document);
     NS_ENSURE_TRUE(pool, NS_ERROR_OUT_OF_MEMORY);
 
     rv = pool->Init();
     NS_ENSURE_SUCCESS(rv, rv);
 
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
 
     PRBool success = mPools.Put(aGlobalObject, pool);
     NS_ENSURE_TRUE(success, NS_ERROR_OUT_OF_MEMORY);
   }
 
   rv = pool->NoteWorker(aWorker);
   NS_ENSURE_SUCCESS(rv, rv);
 
--- a/dom/src/threads/nsDOMThreadService.h
+++ b/dom/src/threads/nsDOMThreadService.h
@@ -42,23 +42,23 @@
 
 // Interfaces
 #include "nsIEventTarget.h"
 #include "nsIObserver.h"
 #include "nsIThreadPool.h"
 
 // Other includes
 #include "jsapi.h"
+#include "mozilla/Monitor.h"
 #include "nsAutoPtr.h"
 #include "nsCOMPtr.h"
 #include "nsDataHashtable.h"
 #include "nsRefPtrHashtable.h"
 #include "nsStringGlue.h"
 #include "nsTPtrArray.h"
-#include "prmon.h"
 
 #include "prlog.h"
 #ifdef PR_LOGGING
 extern PRLogModuleInfo* gDOMThreadsLog;
 #endif
 
 class nsDOMWorker;
 class nsDOMWorkerPool;
@@ -180,17 +180,17 @@ private:
   // Our internal thread pool.
   nsCOMPtr<nsIThreadPool> mThreadPool;
 
   // Maps nsIScriptGlobalObject* to nsDOMWorkerPool.
   nsRefPtrHashtable<nsVoidPtrHashKey, nsDOMWorkerPool> mPools;
 
   // mMonitor protects all access to mWorkersInProgress and
   // mCreationsInProgress.
-  PRMonitor* mMonitor;
+  mozilla::Monitor mMonitor;
 
   // A map from nsDOMWorkerThread to nsDOMWorkerRunnable.
   nsRefPtrHashtable<nsVoidPtrHashKey, nsDOMWorkerRunnable> mWorkersInProgress;
 
   // A list of active JSContexts that we've created. Always protected with
   // mMonitor.
   nsTArray<JSContext*> mJSContexts;
 
--- a/dom/src/threads/nsDOMWorker.cpp
+++ b/dom/src/threads/nsDOMWorker.cpp
@@ -43,17 +43,16 @@
 #include "nsIJSRuntimeService.h"
 #include "nsIXPConnect.h"
 
 #include "jscntxt.h"
 #ifdef MOZ_SHARK
 #include "jsdbgapi.h"
 #endif
 #include "nsAtomicRefcnt.h"
-#include "nsAutoLock.h"
 #include "nsAXPCNativeCallContext.h"
 #include "nsContentUtils.h"
 #include "nsDOMClassInfo.h"
 #include "nsDOMClassInfoID.h"
 #include "nsGlobalWindow.h"
 #include "nsJSON.h"
 #include "nsJSUtils.h"
 #include "nsProxyRelease.h"
@@ -65,16 +64,18 @@
 #include "nsDOMWorkerEvents.h"
 #include "nsDOMWorkerLocation.h"
 #include "nsDOMWorkerNavigator.h"
 #include "nsDOMWorkerPool.h"
 #include "nsDOMWorkerScriptLoader.h"
 #include "nsDOMWorkerTimeout.h"
 #include "nsDOMWorkerXHR.h"
 
+using namespace mozilla;
+
 class TestComponentThreadsafetyRunnable : public nsIRunnable
 {
 public:
   NS_DECL_ISUPPORTS
 
   TestComponentThreadsafetyRunnable(const nsACString& aContractId,
                                     PRBool aService)
   : mContractId(aContractId),
@@ -1346,17 +1347,17 @@ nsDOMWorkerFeature::Release()
 NS_IMPL_QUERY_INTERFACE0(nsDOMWorkerFeature)
 
 nsDOMWorker::nsDOMWorker(nsDOMWorker* aParent,
                          nsIXPConnectWrappedNative* aParentWN,
                          WorkerPrivilegeModel aPrivilegeModel)
 : mParent(aParent),
   mParentWN(aParentWN),
   mPrivilegeModel(aPrivilegeModel),
-  mLock(nsnull),
+  mLock("nsDOMWorker.mLock"),
   mInnerScope(nsnull),
   mGlobal(NULL),
   mNextTimeoutId(0),
   mFeatureSuspendDepth(0),
   mWrappedNative(nsnull),
   mErrorHandlerRecursionCount(0),
   mStatus(eRunning),
   mExpirationTime(0),
@@ -1370,20 +1371,16 @@ nsDOMWorker::nsDOMWorker(nsDOMWorker* aP
 }
 
 nsDOMWorker::~nsDOMWorker()
 {
   if (mPool) {
     mPool->NoteDyingWorker(this);
   }
 
-  if (mLock) {
-    nsAutoLock::DestroyLock(mLock);
-  }
-
   NS_ASSERTION(!mFeatures.Length(), "Live features!");
   NS_ASSERTION(!mQueuedRunnables.Length(), "Events that never ran!");
 
   nsCOMPtr<nsIThread> mainThread;
   NS_GetMainThread(getter_AddRefs(mainThread));
 
   nsIPrincipal* principal;
   mPrincipal.forget(&principal);
@@ -1495,31 +1492,31 @@ nsDOMWorker::PreCreate(nsISupports* aObj
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDOMWorker::PostCreate(nsIXPConnectWrappedNative* aWrapper,
                         JSContext* /* aCx */,
                         JSObject* /* aObj */)
 {
-  nsAutoLock lock(mLock);
+  MutexAutoLock lock(mLock);
   mWrappedNative = aWrapper;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDOMWorker::Trace(nsIXPConnectWrappedNative* /* aWrapper */,
                    JSTracer* aTracer,
                    JSObject* /*aObj */)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 
   PRBool canceled = PR_FALSE;
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     canceled = mStatus == eKilled;
   }
 
   if (!canceled) {
     nsDOMWorkerMessageHandler::Trace(aTracer);
   }
 
   return NS_OK;
@@ -1532,17 +1529,17 @@ nsDOMWorker::Finalize(nsIXPConnectWrappe
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 
   // Don't leave dangling JSObject pointers in our handlers!
   ClearAllListeners();
 
   // Clear our wrapped native now that it has died.
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     mWrappedNative = nsnull;
   }
 
   // Do this *after* we null out mWrappedNative so that we don't hand out a
   // freed pointer.
   if (TerminateInternal(PR_TRUE) == NS_ERROR_ILLEGAL_DURING_SHUTDOWN) {
     // We're shutting down, jump right to Kill.
     Kill();
@@ -1667,19 +1664,16 @@ nsDOMWorker::InitializeInternal(nsIScrip
         rv = NS_NewURI(getter_AddRefs(mBaseURI), filename);
         NS_ENSURE_SUCCESS(rv, rv);
       }
     }
 
     NS_ASSERTION(mPrincipal, "Should have set the principal!");
   }
 
-  mLock = nsAutoLock::NewLock("nsDOMWorker::mLock");
-  NS_ENSURE_TRUE(mLock, NS_ERROR_OUT_OF_MEMORY);
-
   NS_ASSERTION(!mGlobal, "Already got a global?!");
 
   nsCOMPtr<nsIXPConnectJSObjectHolder> thisWrapped;
   jsval v;
   rv = nsContentUtils::WrapNative(aCx, aObj, static_cast<nsIWorker*>(this), &v,
                                   getter_AddRefs(thisWrapped));
   NS_ENSURE_SUCCESS(rv, rv);
 
@@ -1728,17 +1722,17 @@ nsDOMWorker::Cancel()
   // canceled while close runnable is running) except that it always reports
   // that it is canceled when running on the main thread. This status trumps all
   // others (except eKilled). Have to do this because the window that created
   // us has gone away and had its scope cleared so XPConnect will assert all
   // over the place if we try to run anything.
 
   PRBool enforceTimeout = PR_FALSE;
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
 
     NS_ASSERTION(mStatus != eCanceled, "Canceled more than once?!");
 
     if (mStatus == eKilled) {
       return;
     }
 
     DOMWorkerStatus oldStatus = mStatus;
@@ -1790,17 +1784,17 @@ nsDOMWorker::Kill()
   if (mKillTimer) {
     mKillTimer->Cancel();
     mKillTimer = nsnull;
   }
 
   PRUint32 count, index;
   nsAutoTArray<nsRefPtr<nsDOMWorkerFeature>, 20> features;
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
 
     if (mStatus == eKilled) {
       NS_ASSERTION(mFeatures.Length() == 0, "Features added after killed!");
       return;
     }
     mStatus = eKilled;
 
     count = mFeatures.Length();
@@ -1839,17 +1833,17 @@ nsDOMWorker::Kill()
 
 void
 nsDOMWorker::Suspend()
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 
   PRBool shouldSuspendFeatures;
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     NS_ASSERTION(!mSuspended, "Suspended more than once!");
     shouldSuspendFeatures = !mSuspended;
     mSuspended = PR_TRUE;
   }
 
   if (shouldSuspendFeatures) {
     SuspendFeatures();
   }
@@ -1857,17 +1851,17 @@ nsDOMWorker::Suspend()
 
 void
 nsDOMWorker::Resume()
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 
   PRBool shouldResumeFeatures;
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
 #ifdef DEBUG
     // Should only have a mismatch if GC or Cancel happened while suspended.
     if (!mSuspended) {
       NS_ASSERTION(mStatus == eCanceled ||
                    (mStatus == eTerminated && !mWrappedNative),
                    "Not suspended!");
     }
 #endif
@@ -1885,17 +1879,17 @@ nsDOMWorker::Resume()
     NS_DispatchToCurrentThread(mQueuedRunnables[index]);
   }
   mQueuedRunnables.Clear();
 }
 
 PRBool
 nsDOMWorker::IsCanceled()
 {
-  nsAutoLock lock(mLock);
+  MutexAutoLock lock(mLock);
   return IsCanceledNoLock();
 }
 
 PRBool
 nsDOMWorker::IsCanceledNoLock()
 {
   // If we haven't started the close process then we're not canceled.
   if (mStatus == eRunning) {
@@ -1919,24 +1913,24 @@ nsDOMWorker::IsCanceledNoLock()
          (mExpirationTime && mExpirationTime != PR_INTERVAL_NO_TIMEOUT &&
           mExpirationTime <= PR_IntervalNow()) ||
          (mStatus == eCanceled && NS_IsMainThread());
 }
 
 PRBool
 nsDOMWorker::IsClosing()
 {
-  nsAutoLock lock(mLock);
+  MutexAutoLock lock(mLock);
   return mStatus != eRunning;
 }
 
 PRBool
 nsDOMWorker::IsSuspended()
 {
-  nsAutoLock lock(mLock);
+  MutexAutoLock lock(mLock);
   return mSuspended;
 }
 
 nsresult
 nsDOMWorker::PostMessageInternal(PRBool aToInner)
 {
   nsIXPConnect* xpc = nsContentUtils::XPConnect();
   NS_ENSURE_TRUE(xpc, NS_ERROR_UNEXPECTED);
@@ -2198,34 +2192,34 @@ nsDOMWorker::SetPool(nsDOMWorkerPool* aP
   mPool = aPool;
 }
 
 already_AddRefed<nsIXPConnectWrappedNative>
 nsDOMWorker::GetWrappedNative()
 {
   nsCOMPtr<nsIXPConnectWrappedNative> wrappedNative;
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     wrappedNative = mWrappedNative;
   }
   return wrappedNative.forget();
 }
 
 nsresult
 nsDOMWorker::AddFeature(nsDOMWorkerFeature* aFeature,
                         JSContext* aCx)
 {
   NS_ASSERTION(aFeature, "Null pointer!");
 
   PRBool shouldSuspend;
   {
     // aCx may be null.
     JSAutoSuspendRequest asr(aCx);
 
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
 
     if (mStatus == eKilled) {
       // No features may be added after we've been canceled. Sorry.
       return NS_ERROR_FAILURE;
     }
 
     nsDOMWorkerFeature** newFeature = mFeatures.AppendElement(aFeature);
     NS_ENSURE_TRUE(newFeature, NS_ERROR_OUT_OF_MEMORY);
@@ -2248,34 +2242,34 @@ nsDOMWorker::RemoveFeature(nsDOMWorkerFe
   NS_ASSERTION(aFeature, "Null pointer!");
 
   // This *must* be a nsRefPtr so that we call Release after setting FreeToDie.
   nsRefPtr<nsDOMWorkerFeature> feature(aFeature);
   {
     // aCx may be null.
     JSAutoSuspendRequest asr(aCx);
 
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
 
 #ifdef DEBUG
     PRBool removed =
 #endif
     mFeatures.RemoveElement(aFeature);
     NS_ASSERTION(removed, "Feature not in the list!");
 
     aFeature->FreeToDie(PR_TRUE);
   }
 }
 
 void
 nsDOMWorker::CancelTimeoutWithId(PRUint32 aId)
 {
   nsRefPtr<nsDOMWorkerFeature> foundFeature;
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     PRUint32 count = mFeatures.Length();
     for (PRUint32 index = 0; index < count; index++) {
       nsDOMWorkerFeature*& feature = mFeatures[index];
       if (feature->HasId() && feature->GetId() == aId) {
         foundFeature = feature;
         feature->FreeToDie(PR_TRUE);
         mFeatures.RemoveElementAt(index);
         break;
@@ -2288,17 +2282,17 @@ nsDOMWorker::CancelTimeoutWithId(PRUint3
   }
 }
 
 void
 nsDOMWorker::SuspendFeatures()
 {
   nsAutoTArray<nsRefPtr<nsDOMWorkerFeature>, 20> features;
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
 
     // We don't really have to worry about overflow here because the only way
     // to do this is through recursive script loading, which uses the stack. We
     // would exceed our stack limit long before this counter.
     NS_ASSERTION(mFeatureSuspendDepth < PR_UINT32_MAX, "Shouldn't happen!");
     if (++mFeatureSuspendDepth != 1) {
       // Allow nested suspending of timeouts.
       return;
@@ -2317,17 +2311,17 @@ nsDOMWorker::SuspendFeatures()
   }
 }
 
 void
 nsDOMWorker::ResumeFeatures()
 {
   nsAutoTArray<nsRefPtr<nsDOMWorkerFeature>, 20> features;
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
 
     NS_ASSERTION(mFeatureSuspendDepth > 0, "Shouldn't happen!");
     if (--mFeatureSuspendDepth != 0) {
       return;
     }
 
     features.AppendElements(mFeatures);
   }
@@ -2378,30 +2372,30 @@ nsDOMWorker::FireCloseRunnable(PRInterva
                                PRBool aFromFinalize)
 {
   // Resume the worker (but not its features) if we're currently suspended. This
   // should only ever happen if we are being called from Cancel (page falling
   // out of bfcache or quitting) or Finalize, in which case all we really want
   // to do is unblock the waiting thread.
   PRBool wakeUp;
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     NS_ASSERTION(mExpirationTime == 0,
                  "Close runnable should not be scheduled already!");
 
     if ((wakeUp = mSuspended)) {
       NS_ASSERTION(mStatus == eCanceled ||
                    (mStatus == eTerminated && aFromFinalize),
                    "How can this happen otherwise?!");
       mSuspended = PR_FALSE;
     }
   }
 
   if (wakeUp) {
-    nsAutoMonitor mon(mPool->Monitor());
+    MonitorAutoEnter mon(mPool->GetMonitor());
     mon.NotifyAll();
   }
 
   nsRefPtr<nsDOMWorkerEvent> event = new nsDOMWorkerEvent();
   NS_ENSURE_TRUE(event, NS_ERROR_OUT_OF_MEMORY);
 
   nsresult rv =
     event->InitEvent(NS_LITERAL_STRING("close"), PR_FALSE, PR_FALSE);
@@ -2425,17 +2419,17 @@ nsDOMWorker::FireCloseRunnable(PRInterva
   return nsDOMThreadService::get()->Dispatch(this, runnable, aTimeoutInterval,
                                              aClearQueue);
 }
 
 nsresult
 nsDOMWorker::Close()
 {
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     NS_ASSERTION(mStatus != eKilled, "This should be impossible!");
     if (mStatus != eRunning) {
       return NS_OK;
     }
     mStatus = eClosed;
   }
 
   nsresult rv = FireCloseRunnable(PR_INTERVAL_NO_TIMEOUT, PR_FALSE, PR_FALSE);
@@ -2443,17 +2437,17 @@ nsDOMWorker::Close()
 
   return NS_OK;
 }
 
 nsresult
 nsDOMWorker::TerminateInternal(PRBool aFromFinalize)
 {
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
 #ifdef DEBUG
     if (!aFromFinalize) {
       NS_ASSERTION(mStatus != eCanceled, "Shouldn't be able to get here!");
     }
 #endif
 
     if (mStatus == eRunning) {
       // This is the beginning of the close process, fire an event and prevent
@@ -2490,31 +2484,31 @@ nsDOMWorker::GetParent()
   nsRefPtr<nsDOMWorker> parent(mParent);
   return parent.forget();
 }
 
 void
 nsDOMWorker::SetExpirationTime(PRIntervalTime aExpirationTime)
 {
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
 
     NS_ASSERTION(mStatus != eRunning && mStatus != eKilled, "Bad status!");
     NS_ASSERTION(!mExpirationTime || mExpirationTime == PR_INTERVAL_NO_TIMEOUT,
                  "Overwriting a timeout that was previously set!");
 
     mExpirationTime = aExpirationTime;
   }
 }
 
 #ifdef DEBUG
 PRIntervalTime
 nsDOMWorker::GetExpirationTime()
 {
-  nsAutoLock lock(mLock);
+  MutexAutoLock lock(mLock);
   return mExpirationTime;
 }
 #endif
 
 // static
 JSObject*
 nsDOMWorker::ReadStructuredClone(JSContext* aCx,
                                  JSStructuredCloneReader* aReader,
@@ -2589,17 +2583,17 @@ nsDOMWorker::RemoveEventListener(const n
                                                         aUseCapture);
 }
 
 NS_IMETHODIMP
 nsDOMWorker::DispatchEvent(nsIDOMEvent* aEvent,
                            PRBool* _retval)
 {
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     if (IsCanceledNoLock()) {
       return NS_OK;
     }
     if (mStatus == eTerminated) {
       nsCOMPtr<nsIWorkerMessageEvent> messageEvent(do_QueryInterface(aEvent));
       if (messageEvent) {
         // This is a message event targeted to a terminated worker. Ignore it.
         return NS_OK;
@@ -2630,17 +2624,17 @@ nsDOMWorker::AddEventListener(const nsAS
 
 /**
  * See nsIWorker
  */
 NS_IMETHODIMP
 nsDOMWorker::PostMessage(/* JSObject aMessage */)
 {
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     // There's no reason to dispatch this message after the close handler has
     // been triggered since it will never be allowed to run.
     if (mStatus != eRunning) {
       return NS_OK;
     }
   }
 
   return PostMessageInternal(PR_TRUE);
--- a/dom/src/threads/nsDOMWorker.h
+++ b/dom/src/threads/nsDOMWorker.h
@@ -43,20 +43,20 @@
 #include "nsIDOMWorkers.h"
 #include "nsIJSNativeInitializer.h"
 #include "nsIPrincipal.h"
 #include "nsITimer.h"
 #include "nsIURI.h"
 #include "nsIXPCScriptable.h"
 
 #include "jsapi.h"
+#include "mozilla/Mutex.h"
 #include "nsAutoPtr.h"
 #include "nsCOMPtr.h"
 #include "nsTPtrArray.h"
-#include "prlock.h"
 
 #include "nsDOMWorkerMessageHandler.h"
 
 // {1295EFB5-8644-42B2-8B8E-80EEF56E4284}
 #define NS_WORKERFACTORY_CID \
  {0x1295efb5, 0x8644, 0x42b2, \
   {0x8b, 0x8e, 0x80, 0xee, 0xf5, 0x6e, 0x42, 0x84} }
 
@@ -138,16 +138,18 @@ private:
 };
 
 class nsDOMWorker : public nsDOMWorkerMessageHandler,
                     public nsIWorker,
                     public nsITimerCallback,
                     public nsIJSNativeInitializer,
                     public nsIXPCScriptable
 {
+  typedef mozilla::Mutex Mutex;
+
   friend class nsDOMWorkerFeature;
   friend class nsDOMWorkerFunctions;
   friend class nsDOMWorkerScope;
   friend class nsDOMWorkerScriptLoader;
   friend class nsDOMWorkerTimeout;
   friend class nsDOMWorkerXHR;
   friend class nsDOMWorkerXHRProxy;
   friend class nsReportErrorRunnable;
@@ -209,17 +211,17 @@ public:
   PRBool SetGlobalForContext(JSContext* aCx, nsLazyAutoRequest *aRequest, JSAutoEnterCompartment *aComp);
 
   void SetPool(nsDOMWorkerPool* aPool);
 
   nsDOMWorkerPool* Pool() {
     return mPool;
   }
 
-  PRLock* Lock() {
+  Mutex& GetLock() {
     return mLock;
   }
 
   already_AddRefed<nsIXPConnectWrappedNative> GetWrappedNative();
   already_AddRefed<nsDOMWorker> GetParent();
 
   nsDOMWorkerScope* GetInnerScope() {
     return mInnerScope;
@@ -347,17 +349,17 @@ private:
   // reflection alive, so we only hold one strong reference to mParentWN.
   nsDOMWorker* mParent;
   nsCOMPtr<nsIXPConnectWrappedNative> mParentWN;
 
   // Whether or not this worker has chrome privileges. Never changed after the
   // worker is created.
   WorkerPrivilegeModel mPrivilegeModel;
 
-  PRLock* mLock;
+  Mutex mLock;
 
   nsRefPtr<nsDOMWorkerPool> mPool;
 
   nsDOMWorkerScope* mInnerScope;
   nsCOMPtr<nsIXPConnectWrappedNative> mScopeWN;
   JSObject* mGlobal;
 
   PRUint32 mNextTimeoutId;
--- a/dom/src/threads/nsDOMWorkerPool.cpp
+++ b/dom/src/threads/nsDOMWorkerPool.cpp
@@ -45,33 +45,34 @@
 #include "nsIJSContextStack.h"
 #include "nsIScriptGlobalObject.h"
 #include "nsIServiceManager.h"
 #include "nsIThreadManager.h"
 #include "nsIXPConnect.h"
 #include "nsPIDOMWindow.h"
 
 // Other includes
-#include "nsAutoLock.h"
 #include "nsContentUtils.h"
 #include "nsDOMJSUtils.h"
 #include "nsProxyRelease.h"
 #include "nsThreadUtils.h"
 
 // DOMWorker includes
 #include "nsDOMThreadService.h"
 #include "nsDOMWorker.h"
 
+using namespace mozilla;
+
 #define LOG(_args) PR_LOG(gDOMThreadsLog, PR_LOG_DEBUG, _args)
 
 nsDOMWorkerPool::nsDOMWorkerPool(nsIScriptGlobalObject* aGlobalObject,
                                  nsIDocument* aDocument)
 : mParentGlobal(aGlobalObject),
   mParentDocument(aDocument),
-  mMonitor(nsnull),
+  mMonitor("nsDOMWorkerPool.mMonitor"),
   mCanceled(PR_FALSE),
   mSuspended(PR_FALSE),
   mWindowID(aDocument ? aDocument->OuterWindowID() : 0)
 {
 }
 
 nsDOMWorkerPool::~nsDOMWorkerPool()
 {
@@ -84,45 +85,37 @@ nsDOMWorkerPool::~nsDOMWorkerPool()
     NS_ProxyRelease(mainThread, global, PR_FALSE);
   }
 
   nsIDocument* document;
   mParentDocument.forget(&document);
   if (document) {
     NS_ProxyRelease(mainThread, document, PR_FALSE);
   }
-
-  if (mMonitor) {
-    nsAutoMonitor::DestroyMonitor(mMonitor);
-  }
 }
 
 NS_IMPL_THREADSAFE_ADDREF(nsDOMWorkerPool)
 NS_IMPL_THREADSAFE_RELEASE(nsDOMWorkerPool)
 
 nsresult
 nsDOMWorkerPool::Init()
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
-
-  mMonitor = nsAutoMonitor::NewMonitor("nsDOMWorkerPool::mMonitor");
-  NS_ENSURE_TRUE(mMonitor, NS_ERROR_OUT_OF_MEMORY);
-
   return NS_OK;
 }
 
 nsresult
 nsDOMWorkerPool::NoteWorker(nsDOMWorker* aWorker)
 {
   NS_ASSERTION(aWorker, "Null pointer!");
 
   PRBool suspendWorker;
 
   {
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
 
     if (mCanceled) {
       return NS_ERROR_ABORT;
     }
 
     nsDOMWorker** newWorker = mWorkers.AppendElement(aWorker);
     NS_ENSURE_TRUE(newWorker, NS_ERROR_OUT_OF_MEMORY);
 
@@ -139,17 +132,17 @@ nsDOMWorkerPool::NoteWorker(nsDOMWorker*
 void
 nsDOMWorkerPool::NoteDyingWorker(nsDOMWorker* aWorker)
 {
   NS_ASSERTION(aWorker, "Null pointer!");
 
   PRBool removeFromThreadService = PR_FALSE;
 
   {
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
 
     NS_ASSERTION(mWorkers.Contains(aWorker), "Worker from a different pool?!");
     mWorkers.RemoveElement(aWorker);
 
     if (!mCanceled && !mWorkers.Length()) {
       removeFromThreadService = PR_TRUE;
     }
   }
@@ -158,17 +151,17 @@ nsDOMWorkerPool::NoteDyingWorker(nsDOMWo
     nsRefPtr<nsDOMWorkerPool> kungFuDeathGrip(this);
     nsDOMThreadService::get()->NoteEmptyPool(this);
   }
 }
 
 void
 nsDOMWorkerPool::GetWorkers(nsTArray<nsDOMWorker*>& aArray)
 {
-  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
+  mMonitor.AssertCurrentThreadIn();
   NS_ASSERTION(!aArray.Length(), "Should be empty!");
 
 #ifdef DEBUG
   nsDOMWorker** newWorkers =
 #endif
   aArray.AppendElements(mWorkers);
   NS_WARN_IF_FALSE(newWorkers, "Out of memory!");
 }
@@ -176,41 +169,41 @@ nsDOMWorkerPool::GetWorkers(nsTArray<nsD
 void
 nsDOMWorkerPool::Cancel()
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(!mCanceled, "Canceled more than once!");
 
   nsAutoTArray<nsDOMWorker*, 10> workers;
   {
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
 
     mCanceled = PR_TRUE;
 
     GetWorkers(workers);
   }
 
   PRUint32 count = workers.Length();
   if (count) {
     for (PRUint32 index = 0; index < count; index++) {
       workers[index]->Cancel();
     }
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
     mon.NotifyAll();
   }
 }
 
 void
 nsDOMWorkerPool::Suspend()
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 
   nsAutoTArray<nsDOMWorker*, 10> workers;
   {
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
 
     NS_ASSERTION(!mSuspended, "Suspended more than once!");
     mSuspended = PR_TRUE;
 
     GetWorkers(workers);
   }
 
   PRUint32 count = workers.Length();
@@ -221,25 +214,25 @@ nsDOMWorkerPool::Suspend()
 
 void
 nsDOMWorkerPool::Resume()
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 
   nsAutoTArray<nsDOMWorker*, 10> workers;
   {
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
 
     NS_ASSERTION(mSuspended, "Not suspended!");
     mSuspended = PR_FALSE;
 
     GetWorkers(workers);
   }
 
   PRUint32 count = workers.Length();
   if (count) {
     for (PRUint32 index = 0; index < count; index++) {
       workers[index]->Resume();
     }
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
     mon.NotifyAll();
   }
 }
--- a/dom/src/threads/nsDOMWorkerPool.h
+++ b/dom/src/threads/nsDOMWorkerPool.h
@@ -37,29 +37,31 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef __NSDOMWORKERPOOL_H__
 #define __NSDOMWORKERPOOL_H__
 
 // Other includes
 #include "jsapi.h"
+#include "mozilla/Monitor.h"
 #include "nsCOMPtr.h"
 #include "nsStringGlue.h"
 #include "nsTArray.h"
-#include "prmon.h"
 
 class nsDOMWorker;
 class nsIDocument;
 class nsIScriptContext;
 class nsIScriptError;
 class nsIScriptGlobalObject;
 
 class nsDOMWorkerPool
 {
+  typedef mozilla::Monitor Monitor;
+
 public:
   nsDOMWorkerPool(nsIScriptGlobalObject* aGlobalObject,
                   nsIDocument* aDocument);
 
   NS_IMETHOD_(nsrefcnt) AddRef();
   NS_IMETHOD_(nsrefcnt) Release();
 
   nsIScriptGlobalObject* ScriptGlobalObject() {
@@ -74,17 +76,17 @@ public:
 
   void Cancel();
   void Suspend();
   void Resume();
 
   nsresult NoteWorker(nsDOMWorker* aWorker);
   void NoteDyingWorker(nsDOMWorker* aWorker);
 
-  PRMonitor* Monitor() {
+  Monitor& GetMonitor() {
     return mMonitor;
   }
 
   const PRUint64 WindowID() const {
     return mWindowID;
   }
 
 private:
@@ -100,17 +102,17 @@ private:
   // Reference to the document that created this pool.
   nsCOMPtr<nsIDocument> mParentDocument;
 
   // Weak array of workers. The idea is that workers can be garbage collected
   // independently of the owning pool and other workers.
   nsTArray<nsDOMWorker*> mWorkers;
 
   // Monitor for suspending and resuming workers.
-  PRMonitor* mMonitor;
+  Monitor mMonitor;
 
   PRPackedBool mCanceled;
   PRPackedBool mSuspended;
 
   const PRUint64 mWindowID;
 };
 
 #endif /* __NSDOMWORKERPOOL_H__ */
--- a/dom/src/threads/nsDOMWorkerScriptLoader.cpp
+++ b/dom/src/threads/nsDOMWorkerScriptLoader.cpp
@@ -44,17 +44,16 @@
 #include "nsIHttpChannel.h"
 #include "nsIIOService.h"
 #include "nsIProtocolHandler.h"
 #include "nsIRequest.h"
 #include "nsIScriptSecurityManager.h"
 #include "nsIStreamLoader.h"
 
 // Other includes
-#include "nsAutoLock.h"
 #include "nsContentErrors.h"
 #include "nsContentPolicyUtils.h"
 #include "nsContentUtils.h"
 #include "nsISupportsPrimitives.h"
 #include "nsNetError.h"
 #include "nsNetUtil.h"
 #include "nsScriptLoader.h"
 #include "nsThreadUtils.h"
@@ -65,16 +64,18 @@
 #include "nsIContentSecurityPolicy.h"
 
 // DOMWorker includes
 #include "nsDOMWorkerPool.h"
 #include "nsDOMWorkerSecurityManager.h"
 #include "nsDOMThreadService.h"
 #include "nsDOMWorkerTimeout.h"
 
+using namespace mozilla;
+
 #define LOG(_args) PR_LOG(gDOMThreadsLog, PR_LOG_DEBUG, _args)
 
 nsDOMWorkerScriptLoader::nsDOMWorkerScriptLoader(nsDOMWorker* aWorker)
 : nsDOMWorkerFeature(aWorker),
   mTarget(nsnull),
   mScriptCount(0),
   mCanceled(PR_FALSE),
   mForWorker(PR_FALSE)
@@ -298,17 +299,17 @@ nsDOMWorkerScriptLoader::Cancel()
 #endif
       request->Cancel(NS_BINDING_ABORTED);
       NS_WARN_IF_FALSE(NS_SUCCEEDED(rv), "Failed to cancel channel!");
     }
   }
 
   nsAutoTArray<ScriptLoaderRunnable*, 10> runnables;
   {
-    nsAutoLock lock(mWorker->Lock());
+    MutexAutoLock lock(mWorker->GetLock());
     runnables.AppendElements(mPendingRunnables);
     mPendingRunnables.Clear();
   }
 
   PRUint32 runnableCount = runnables.Length();
   for (PRUint32 index = 0; index < runnableCount; index++) {
     runnables[index]->Revoke();
   }
@@ -748,29 +749,29 @@ nsDOMWorkerScriptLoader::ResumeWorkerEve
   mWorker->ResumeFeatures();
 }
 
 nsDOMWorkerScriptLoader::
 ScriptLoaderRunnable::ScriptLoaderRunnable(nsDOMWorkerScriptLoader* aLoader)
 : mRevoked(PR_FALSE),
   mLoader(aLoader)
 {
-  nsAutoLock lock(aLoader->Lock());
+  MutexAutoLock lock(aLoader->GetLock());
 #ifdef DEBUG
   nsDOMWorkerScriptLoader::ScriptLoaderRunnable** added =
 #endif
   aLoader->mPendingRunnables.AppendElement(this);
   NS_ASSERTION(added, "This shouldn't fail because we SetCapacity earlier!");
 }
 
 nsDOMWorkerScriptLoader::
 ScriptLoaderRunnable::~ScriptLoaderRunnable()
 {
   if (!mRevoked) {
-    nsAutoLock lock(mLoader->Lock());
+    MutexAutoLock lock(mLoader->GetLock());
 #ifdef DEBUG
     PRBool removed =
 #endif
     mLoader->mPendingRunnables.RemoveElement(this);
     NS_ASSERTION(removed, "Someone has changed the array!");
   }
 }
 
--- a/dom/src/threads/nsDOMWorkerScriptLoader.h
+++ b/dom/src/threads/nsDOMWorkerScriptLoader.h
@@ -49,17 +49,16 @@
 
 // Other includes
 #include "jsapi.h"
 #include "nsAutoPtr.h"
 #include "nsAutoJSValHolder.h"
 #include "nsCOMPtr.h"
 #include "nsStringGlue.h"
 #include "nsTArray.h"
-#include "prlock.h"
 
 #include "nsDOMWorker.h"
 
 class nsIThread;
 
 /**
  * This class takes a list of script URLs, downloads the scripts, compiles the
  * scripts, and then finally executes them. Due to platform limitations all
@@ -86,16 +85,18 @@ class nsIThread;
  *
  * Currently if *anything* after 2 fails then we cancel any pending loads and
  * bail out entirely.
  */
 class nsDOMWorkerScriptLoader : public nsDOMWorkerFeature,
                                 public nsIRunnable,
                                 public nsIStreamLoaderObserver
 {
+  typedef mozilla::Mutex Mutex;
+
   friend class AutoSuspendWorkerEvents;
   friend class ScriptLoaderRunnable;
 
 public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_NSIRUNNABLE
   NS_DECL_NSISTREAMLOADEROBSERVER
 
@@ -127,18 +128,18 @@ private:
                                     PRUint32 aStringLen,
                                     const PRUint8* aString);
 
   void NotifyDone();
 
   void SuspendWorkerEvents();
   void ResumeWorkerEvents();
 
-  PRLock* Lock() {
-    return mWorker->Lock();
+  Mutex& GetLock() {
+    return mWorker->GetLock();
   }
 
   class ScriptLoaderRunnable : public nsIRunnable
   {
   public:
     NS_DECL_ISUPPORTS
 
   protected:
--- a/dom/src/threads/nsDOMWorkerXHR.cpp
+++ b/dom/src/threads/nsDOMWorkerXHR.cpp
@@ -40,30 +40,31 @@
 
 // Interfaces
 #include "nsIDocument.h"
 #include "nsIDOMEvent.h"
 #include "nsIThread.h"
 #include "nsIXPConnect.h"
 
 // Other includes
-#include "nsAutoLock.h"
 #include "nsAXPCNativeCallContext.h"
 #include "nsComponentManagerUtils.h"
 #include "nsContentUtils.h"
 #include "nsIClassInfoImpl.h"
 #include "nsJSUtils.h"
 #include "nsThreadUtils.h"
 
 // DOMWorker includes
 #include "nsDOMThreadService.h"
 #include "nsDOMWorkerEvents.h"
 #include "nsDOMWorkerPool.h"
 #include "nsDOMWorkerXHRProxy.h"
 
+using namespace mozilla;
+
 // The list of event types that we support. This list and the defines based on
 // it determine the sizes of the listener arrays in nsDOMWorkerXHRProxy. Make
 // sure that any event types shared by both the XHR and Upload objects are
 // together at the beginning of the list. Any changes made to this list may
 // affect sMaxUploadEventTypes, so make sure that it is adjusted accordingly or
 // things will break!
 const char* const nsDOMWorkerXHREventTarget::sListenerTypes[] = {
   // nsIXMLHttpRequestEventTarget listeners.
@@ -488,17 +489,17 @@ nsDOMWorkerXHR::Cancel()
 
   // Just in case mUpload holds the only ref to this object we make sure to stay
   // alive through this call.
   nsRefPtr<nsDOMWorkerXHR> kungFuDeathGrip(this);
 
   {
     // This lock is here to prevent a race between Cancel and GetUpload, not to
     // protect mCanceled.
-    nsAutoLock lock(mWorker->Lock());
+    MutexAutoLock lock(mWorker->GetLock());
 
     mCanceled = PR_TRUE;
     mUpload = nsnull;
   }
 
   if (mXHRProxy) {
     mXHRProxy->Destroy();
     mXHRProxy = nsnull;
@@ -824,17 +825,17 @@ nsDOMWorkerXHR::GetUpload(nsIXMLHttpRequ
 {
   NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
 
   nsRefPtr<nsDOMWorker> worker = mWorker;
   if (!worker) {
     return NS_ERROR_ABORT;
   }
 
-  nsAutoLock lock(worker->Lock());
+  MutexAutoLock lock(worker->GetLock());
 
   if (mCanceled) {
     return NS_ERROR_ABORT;
   }
 
   NS_ENSURE_ARG_POINTER(aUpload);
 
   if (!mUpload) {
--- a/dom/src/threads/nsDOMWorkerXHR.h
+++ b/dom/src/threads/nsDOMWorkerXHR.h
@@ -43,17 +43,16 @@
 #include "nsIClassInfo.h"
 #include "nsIXMLHttpRequest.h"
 #include "nsIXPCScriptable.h"
 
 // Other includes
 #include "nsAutoPtr.h"
 #include "nsCOMPtr.h"
 #include "nsTArray.h"
-#include "prlock.h"
 
 // DOMWorker includes
 #include "nsDOMWorker.h"
 #include "nsDOMWorkerMacros.h"
 #include "nsDOMWorkerXHRProxy.h"
 
 // Convenience defines for event *indexes* in the sListenerTypes array.
 #define LISTENER_TYPE_ABORT 0
@@ -87,16 +86,18 @@ protected:
 
 class nsDOMWorkerXHRUpload;
 
 class nsDOMWorkerXHR : public nsDOMWorkerFeature,
                        public nsDOMWorkerXHREventTarget,
                        public nsIXMLHttpRequest,
                        public nsIXPCScriptable
 {
+  typedef mozilla::Mutex Mutex;
+
   friend class nsDOMWorkerXHREvent;
   friend class nsDOMWorkerXHRLastProgressOrLoadEvent;
   friend class nsDOMWorkerXHRProxy;
   friend class nsDOMWorkerXHRUpload;
 
 public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_NSIXMLHTTPREQUEST
@@ -111,18 +112,18 @@ public:
   virtual void Cancel();
 
   virtual nsresult SetOnXListener(const nsAString& aType,
                                   nsIDOMEventListener* aListener);
 
 private:
   virtual ~nsDOMWorkerXHR();
 
-  PRLock* Lock() {
-    return mWorker->Lock();
+  Mutex& GetLock() {
+    return mWorker->GetLock();
   }
 
   already_AddRefed<nsIXPConnectWrappedNative> GetWrappedNative() {
     nsCOMPtr<nsIXPConnectWrappedNative> wrappedNative(mWrappedNative);
     return wrappedNative.forget();
   }
 
   nsRefPtr<nsDOMWorkerXHRProxy> mXHRProxy;
--- a/dom/src/threads/nsDOMWorkerXHRProxy.cpp
+++ b/dom/src/threads/nsDOMWorkerXHRProxy.cpp
@@ -44,33 +44,34 @@
 #include "nsIDOMProgressEvent.h"
 #include "nsILoadGroup.h"
 #include "nsIRequest.h"
 #include "nsIThread.h"
 #include "nsIVariant.h"
 #include "nsIXMLHttpRequest.h"
 
 // Other includes
-#include "nsAutoLock.h"
 #include "nsComponentManagerUtils.h"
 #include "nsIClassInfoImpl.h"
 #include "nsThreadUtils.h"
 #include "nsXMLHttpRequest.h"
 #include "prinrval.h"
 #include "prthread.h"
 
 // DOMWorker includes
 #include "nsDOMThreadService.h"
 #include "nsDOMWorker.h"
 #include "nsDOMWorkerEvents.h"
 #include "nsDOMWorkerMacros.h"
 #include "nsDOMWorkerPool.h"
 #include "nsDOMWorkerXHR.h"
 #include "nsDOMWorkerXHRProxiedFunctions.h"
 
+using namespace mozilla;
+
 #define MAX_XHR_LISTENER_TYPE nsDOMWorkerXHREventTarget::sMaxXHREventTypes
 #define MAX_UPLOAD_LISTENER_TYPE nsDOMWorkerXHREventTarget::sMaxUploadEventTypes
 
 #define RUN_PROXIED_FUNCTION(_name, _args)                                     \
   PR_BEGIN_MACRO                                                               \
     NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");                         \
                                                                                \
     if (mCanceled) {                                                           \
@@ -176,17 +177,17 @@ public:
   : mProxy(aProxy) {
     NS_ASSERTION(aProxy, "Null pointer!");
   }
 
   NS_IMETHOD Run() {
     nsRefPtr<nsDOMWorkerXHREvent> lastProgressOrLoadEvent;
 
     if (!mProxy->mCanceled) {
-      nsAutoLock lock(mProxy->mWorkerXHR->Lock());
+      MutexAutoLock lock(mProxy->mWorkerXHR->GetLock());
       mProxy->mLastProgressOrLoadEvent.swap(lastProgressOrLoadEvent);
       if (mProxy->mCanceled) {
         return NS_ERROR_ABORT;
       }
     }
 
     if (lastProgressOrLoadEvent) {
       return lastProgressOrLoadEvent->Run();
@@ -370,17 +371,17 @@ nsDOMWorkerXHRProxy::GetXMLHttpRequest()
 }
 
 nsresult
 nsDOMWorkerXHRProxy::Destroy()
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 
   {
-    nsAutoLock lock(mWorkerXHR->Lock());
+    MutexAutoLock lock(mWorkerXHR->GetLock());
 
     mCanceled = PR_TRUE;
 
     mLastProgressOrLoadEvent = nsnull;
     mLastXHRState = nsnull;
   }
 
   DestroyInternal();
@@ -460,17 +461,17 @@ nsDOMWorkerXHRProxy::DestroyInternal()
   if (mOwnedByXHR) {
     mXHR->Abort();
   }
   else {
     // There's a slight chance that Send was called yet we've canceled before
     // necko has fired its OnStartRequest notification. Guard against that here.
     nsRefPtr<nsDOMWorkerXHRFinishSyncXHRRunnable> syncFinishedRunnable;
     {
-      nsAutoLock lock(mWorkerXHR->Lock());
+      MutexAutoLock lock(mWorkerXHR->GetLock());
       mSyncFinishedRunnable.swap(syncFinishedRunnable);
     }
 
     if (syncFinishedRunnable) {
       syncFinishedRunnable->Dispatch();
     }
   }
 
@@ -575,17 +576,17 @@ nsDOMWorkerXHRProxy::UploadEventListener
 nsresult
 nsDOMWorkerXHRProxy::HandleWorkerEvent(nsDOMWorkerXHREvent* aEvent,
                                        PRBool aUploadEvent)
 {
   NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(aEvent, "Should not be null!");
 
   {
-    nsAutoLock lock(mWorkerXHR->Lock());
+    MutexAutoLock lock(mWorkerXHR->GetLock());
 
     if (mCanceled ||
         (aEvent->mChannelID != -1 && aEvent->mChannelID != mChannelID)) {
       return NS_OK;
     }
 
     mLastXHRState = aEvent->ForgetState();
   }
@@ -600,17 +601,17 @@ nsDOMWorkerXHRProxy::HandleWorkerEvent(n
   if (type == LISTENER_TYPE_ABORT || type == LISTENER_TYPE_ERROR ||
       type == LISTENER_TYPE_LOAD) {
     nsAutoPtr<ProgressInfo>& progressInfo = aUploadEvent ?
                                             mUploadProgressInfo :
                                             mDownloadProgressInfo;
     progressInfo = nsnull;
 
     // Dummy memory barrier.
-    nsAutoLock lock(mWorkerXHR->Lock());
+    MutexAutoLock lock(mWorkerXHR->GetLock());
   }
 
   nsIDOMEventTarget* target = aUploadEvent ?
     static_cast<nsDOMWorkerMessageHandler*>(mWorkerXHR->mUpload) :
     static_cast<nsDOMWorkerMessageHandler*>(mWorkerXHR);
 
   return target->DispatchEvent(static_cast<nsDOMWorkerEvent*>(aEvent), nsnull);
 }
@@ -764,17 +765,17 @@ nsDOMWorkerXHRProxy::HandleEvent(nsIDOME
         progressEvent->GetLengthComputable(&progressInfo->computable);
         progressEvent->GetLoaded(&progressInfo->loaded);
         progressEvent->GetTotal(&progressInfo->total);
       }
     }
 
     NS_ASSERTION(!syncFinishedRunnable, "This shouldn't be set!");
 
-    nsAutoLock lock(mWorkerXHR->Lock());
+    MutexAutoLock lock(mWorkerXHR->GetLock());
     mSyncFinishedRunnable.swap(syncFinishedRunnable);
   }
   else {
     requestDone = PR_FALSE;
   }
 
   if (mCanceled) {
     // When Abort is called on nsXMLHttpRequest (either from a proxied Abort
@@ -806,17 +807,17 @@ nsDOMWorkerXHRProxy::HandleEvent(nsIDOME
 
   nsCOMPtr<nsIRunnable> runnable(newEvent);
 
   if (type == LISTENER_TYPE_LOAD || type == LISTENER_TYPE_PROGRESS) {
     runnable = new nsDOMWorkerXHRLastProgressOrLoadEvent(this);
     NS_ENSURE_TRUE(runnable, NS_ERROR_OUT_OF_MEMORY);
 
     {
-      nsAutoLock lock(mWorkerXHR->Lock());
+      MutexAutoLock lock(mWorkerXHR->GetLock());
 
       if (mCanceled) {
         return NS_ERROR_ABORT;
       }
 
       mLastProgressOrLoadEvent.swap(newEvent);
 
       if (newEvent) {
@@ -952,17 +953,17 @@ nsDOMWorkerXHRProxy::Send(nsIVariant* aB
 {
   NS_ASSERTION(!mSyncXHRThread, "Shouldn't reenter here!");
 
   if (mSyncRequest) {
 
     mSyncXHRThread = NS_GetCurrentThread();
     NS_ENSURE_TRUE(mSyncXHRThread, NS_ERROR_FAILURE);
 
-    nsAutoLock lock(mWorkerXHR->Lock());
+    MutexAutoLock lock(mWorkerXHR->GetLock());
 
     if (mCanceled) {
       return NS_ERROR_ABORT;
     }
 
     mSyncFinishedRunnable =
       new nsDOMWorkerXHRFinishSyncXHRRunnable(this, mSyncXHRThread);
     NS_ENSURE_TRUE(mSyncFinishedRunnable, NS_ERROR_FAILURE);
@@ -977,17 +978,17 @@ nsresult
 nsDOMWorkerXHRProxy::SendAsBinary(const nsAString& aBody)
 {
   NS_ASSERTION(!mSyncXHRThread, "Shouldn't reenter here!");
 
   if (mSyncRequest) {
     mSyncXHRThread = NS_GetCurrentThread();
     NS_ENSURE_TRUE(mSyncXHRThread, NS_ERROR_FAILURE);
 
-    nsAutoLock lock(mWorkerXHR->Lock());
+    MutexAutoLock lock(mWorkerXHR->GetLock());
 
     if (mCanceled) {
       return NS_ERROR_ABORT;
     }
 
     mSyncFinishedRunnable =
       new nsDOMWorkerXHRFinishSyncXHRRunnable(this, mSyncXHRThread);
     NS_ENSURE_TRUE(mSyncFinishedRunnable, NS_ERROR_FAILURE);
--- a/editor/txmgr/tests/TestTXMgr.cpp
+++ b/editor/txmgr/tests/TestTXMgr.cpp
@@ -4618,20 +4618,27 @@ simple_stress_test()
    *******************************************************************/
 
   printf("\n-----------------------------------------------------\n");
   printf("- Simple Transaction Stress Test:\n");
   printf("-----------------------------------------------------\n");
 
   SimpleTransactionFactory factory;
 
+  PRInt32 iterations =
+#ifdef DEBUG
+  10
+#else
   //
   // 1500 iterations sends 1,125,750 transactions through the system!!
   //
-  return stress_test(&factory, 1500);
+  1500
+#endif
+  ;
+  return stress_test(&factory, iterations);
 }
 
 nsresult
 aggregation_stress_test()
 {
   /*******************************************************************
    *
    * Initialize globals for test.
@@ -4647,20 +4654,27 @@ aggregation_stress_test()
    *******************************************************************/
 
   printf("\n-----------------------------------------------------\n");
   printf("- Aggregate Transaction Stress Test:\n");
   printf("-----------------------------------------------------\n");
 
   AggregateTransactionFactory factory(3, 4);
 
+  PRInt32 iterations =
+#ifdef DEBUG
+  10
+#else
   //
   // 500 iterations sends 2,630,250 transactions through the system!!
   //
-  return stress_test(&factory, 500);
+  500
+#endif
+  ;
+  return stress_test(&factory, iterations);
 }
 
 nsresult
 aggregation_batch_stress_test()
 {
   /*******************************************************************
    *
    * Initialize globals for test.
@@ -4676,20 +4690,27 @@ aggregation_batch_stress_test()
    *******************************************************************/
 
   printf("\n-----------------------------------------------------\n");
   printf("- Aggregate Batch Transaction Stress Test:\n");
   printf("-----------------------------------------------------\n");
 
   AggregateTransactionFactory factory(3, 4, BATCH_FLAG);
 
+  PRInt32 iterations =
+#ifdef DEBUG
+  10
+#else
   //
   // 500 iterations sends 2,630,250 transactions through the system!!
   //
-  return stress_test(&factory, 500);
+  iterations = 500
+#endif
+  ;
+  return stress_test(&factory, iterations);
 }
 
 int
 main (int argc, char *argv[])
 {
   ScopedXPCOM xpcom("nsITransactionManager");
   if (xpcom.failed())
     return 1;
--- a/embedding/components/windowwatcher/src/nsWindowWatcher.cpp
+++ b/embedding/components/windowwatcher/src/nsWindowWatcher.cpp
@@ -37,17 +37,16 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 //#define USEWEAKREFS // (haven't quite figured that out yet)
 
 #include "nsWindowWatcher.h"
 #include "nsAutoWindowStateHelper.h"
 
-#include "nsAutoLock.h"
 #include "nsCRT.h"
 #include "nsNetUtil.h"
 #include "nsWWJSUtils.h"
 #include "plstr.h"
 #include "nsIContentUtils.h"
 
 #include "nsIBaseWindow.h"
 #include "nsIDocShell.h"
@@ -96,16 +95,18 @@
 
 #include "nsIPrefBranch.h"
 #include "nsIPrefService.h"
 
 #ifdef USEWEAKREFS
 #include "nsIWeakReference.h"
 #endif
 
+using namespace mozilla;
+
 static const char *sJSStackContractID="@mozilla.org/js/xpc/ContextStack;1";
 
 /****************************************************************
  ******************** nsWatcherWindowEntry **********************
  ****************************************************************/
 
 class nsWindowWatcher;
 
@@ -333,36 +334,30 @@ NS_IMPL_RELEASE(nsWindowWatcher)
 NS_IMPL_QUERY_INTERFACE3(nsWindowWatcher,
                          nsIWindowWatcher,
                          nsIPromptFactory,
                          nsPIWindowWatcher)
 
 nsWindowWatcher::nsWindowWatcher() :
         mEnumeratorList(),
         mOldestWindow(0),
-        mListLock(0)
+        mListLock("nsWindowWatcher.mListLock")
 {
 }
 
 nsWindowWatcher::~nsWindowWatcher()
 {
   // delete data
   while (mOldestWindow)
     RemoveWindow(mOldestWindow);
-
-  if (mListLock)
-    nsAutoLock::DestroyLock(mListLock);
 }
 
 nsresult
 nsWindowWatcher::Init()
 {
-  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,
                             const char *aName,
                             const char *aFeatures,
@@ -1068,17 +1063,17 @@ nsWindowWatcher::UnregisterNotification(
 }
 
 NS_IMETHODIMP
 nsWindowWatcher::GetWindowEnumerator(nsISimpleEnumerator** _retval)
 {
   if (!_retval)
     return NS_ERROR_INVALID_ARG;
 
-  nsAutoLock lock(mListLock);
+  MutexAutoLock lock(mListLock);
   nsWatcherWindowEnumerator *enumerator = new nsWatcherWindowEnumerator(this);
   if (enumerator)
     return CallQueryInterface(enumerator, _retval);
 
   return NS_ERROR_OUT_OF_MEMORY;
 }
     
 NS_IMETHODIMP
@@ -1164,17 +1159,17 @@ nsWindowWatcher::AddWindow(nsIDOMWindow 
 
     NS_ASSERTION(win->IsOuterWindow(),
                  "Uh, the active window must be an outer window!");
   }
 #endif
 
   {
     nsWatcherWindowEntry *info;
-    nsAutoLock lock(mListLock);
+    MutexAutoLock lock(mListLock);
 
     // if we already have an entry for this window, adjust
     // its chrome mapping and return
     info = FindWindowEntry(aWindow);
     if (info) {
       nsCOMPtr<nsISupportsWeakReference> supportsweak(do_QueryInterface(aChrome));
       if (supportsweak) {
         supportsweak->GetWeakReference(getter_AddRefs(info->mChromeWeak));
@@ -1264,17 +1259,17 @@ nsWindowWatcher::FindWindowEntry(nsIDOMW
 
 nsresult nsWindowWatcher::RemoveWindow(nsWatcherWindowEntry *inInfo)
 {
   PRUint32  ctr,
             count = mEnumeratorList.Length();
 
   {
     // notify the enumerators
-    nsAutoLock lock(mListLock);
+    MutexAutoLock lock(mListLock);
     for (ctr = 0; ctr < count; ++ctr) 
       mEnumeratorList[ctr]->WindowRemoved(inInfo);
 
     // remove the element from the list
     if (inInfo == mOldestWindow)
       mOldestWindow = inInfo->mYounger == mOldestWindow ? 0 : inInfo->mYounger;
     inInfo->Unlink();
   }
@@ -1300,17 +1295,17 @@ nsresult nsWindowWatcher::RemoveWindow(n
 
 NS_IMETHODIMP
 nsWindowWatcher::GetChromeForWindow(nsIDOMWindow *aWindow, nsIWebBrowserChrome **_retval)
 {
   if (!aWindow || !_retval)
     return NS_ERROR_INVALID_ARG;
   *_retval = 0;
 
-  nsAutoLock lock(mListLock);
+  MutexAutoLock lock(mListLock);
   nsWatcherWindowEntry *info = FindWindowEntry(aWindow);
   if (info) {
     if (info->mChromeWeak != nsnull) {
       return info->mChromeWeak->
                             QueryReferent(NS_GET_IID(nsIWebBrowserChrome),
                                           reinterpret_cast<void**>(_retval));
     }
     *_retval = info->mChrome;
--- a/embedding/components/windowwatcher/src/nsWindowWatcher.h
+++ b/embedding/components/windowwatcher/src/nsWindowWatcher.h
@@ -39,16 +39,17 @@
 #define __nsWindowWatcher_h__
 
 // {a21bfa01-f349-4394-a84c-8de5cf0737d0}
 #define NS_WINDOWWATCHER_CID \
  {0xa21bfa01, 0xf349, 0x4394, {0xa8, 0x4c, 0x8d, 0xe5, 0xcf, 0x7, 0x37, 0xd0}}
 
 #include "nsCOMPtr.h"
 #include "jspubtd.h"
+#include "mozilla/Mutex.h"
 #include "nsIWindowCreator.h" // for stupid compilers
 #include "nsIWindowWatcher.h"
 #include "nsIPromptFactory.h"
 #include "nsPIWindowWatcher.h"
 #include "nsTArray.h"
 
 class  nsIURI;
 class  nsIDocShellTreeItem;
@@ -56,17 +57,16 @@ class  nsIDocShellTreeOwner;
 class  nsIWebBrowserChrome;
 class  nsString;
 class  nsWatcherWindowEnumerator;
 class  nsIScriptContext;
 class  nsPromptService;
 struct JSContext;
 struct JSObject;
 struct nsWatcherWindowEntry;
-struct PRLock;
 struct SizeSpec;
 
 class nsWindowWatcher :
       public nsIWindowWatcher,
       public nsPIWindowWatcher,
       public nsIPromptFactory
 {
 friend class nsWatcherWindowEnumerator;
@@ -140,15 +140,15 @@ protected:
                                            const SizeSpec & aSizeSpec);
   static void       GetWindowTreeItem(nsIDOMWindow *inWindow,
                                       nsIDocShellTreeItem **outTreeItem);
   static void       GetWindowTreeOwner(nsIDOMWindow *inWindow,
                                        nsIDocShellTreeOwner **outTreeOwner);
 
   nsTArray<nsWatcherWindowEnumerator*> mEnumeratorList;
   nsWatcherWindowEntry *mOldestWindow;
-  PRLock               *mListLock;
+  mozilla::Mutex        mListLock;
 
   nsCOMPtr<nsIWindowCreator> mWindowCreator;
 };
 
 #endif
 
--- a/gfx/src/nsRegion.cpp
+++ b/gfx/src/nsRegion.cpp
@@ -29,17 +29,16 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
-#include "prlock.h"
 #include "nsRegion.h"
 #include "nsISupportsImpl.h"
 #include "nsTArray.h"
 
 /*
  * The SENTINEL values below guaranties that a < or >
  * comparison with it will be false for all values of the
  * underlying nscoord type.  E.g. this is always false:
@@ -104,24 +103,17 @@ inline void nsRegion::nsRectFast::UnionR
 #define INIT_MEM_CHUNK_ENTRIES 100
 #define INCR_MEM_CHUNK_ENTRIES 100
 
 class RgnRectMemoryAllocator
 {
   nsRegion::RgnRect*  mFreeListHead;
   PRUint32  mFreeEntries;
   void*     mChunkListHead;
-#if 0
-  PRLock*   mLock;
-
-  void InitLock ()    { mLock = PR_NewLock (); }
-  void DestroyLock () { PR_DestroyLock (mLock); }
-  void Lock ()        { PR_Lock   (mLock); }
-  void Unlock ()      { PR_Unlock (mLock); }
-#elif defined (DEBUG)
+#if defined (DEBUG)
   NS_DECL_OWNINGTHREAD
 
   void InitLock ()    { NS_ASSERT_OWNINGTHREAD (RgnRectMemoryAllocator); }
   void DestroyLock () { NS_ASSERT_OWNINGTHREAD (RgnRectMemoryAllocator); }
   void Lock ()        { NS_ASSERT_OWNINGTHREAD (RgnRectMemoryAllocator); }
   void Unlock ()      { NS_ASSERT_OWNINGTHREAD (RgnRectMemoryAllocator); }
 #else
   void InitLock ()    { }
--- a/intl/strres/src/nsStringBundle.cpp
+++ b/intl/strres/src/nsStringBundle.cpp
@@ -54,46 +54,45 @@
 #include "nsNetUtil.h"
 #include "nsIURL.h"
 #include "nsIComponentManager.h"
 #include "nsIMemory.h"
 #include "nsIObserverService.h"
 #include "pratom.h"
 #include "prmem.h"
 #include "nsCOMArray.h"
-#include "nsAutoLock.h"
 #include "nsTextFormatter.h"
 #include "nsIErrorService.h"
 #include "nsITimelineService.h"
 #include "nsICategoryManager.h"
 
 #include "nsPrintfCString.h"
 // for async loading
 #ifdef ASYNC_LOADING
 #include "nsIBinaryInputStream.h"
 #include "nsIStringStream.h"
 #endif
 
 #include "prenv.h"
 #include "nsCRT.h"
 
+using namespace mozilla;
+
 static NS_DEFINE_CID(kErrorServiceCID, NS_ERRORSERVICE_CID);
 static NS_DEFINE_CID(kPersistentPropertiesCID, NS_IPERSISTENTPROPERTIES_CID);
 
 nsStringBundle::~nsStringBundle()
 {
-  if (mMonitor)
-    nsAutoMonitor::DestroyMonitor(mMonitor);
 }
 
 nsStringBundle::nsStringBundle(const char* aURLSpec,
                                nsIStringBundleOverride* aOverrideStrings) :
   mPropertiesURL(aURLSpec),
   mOverrideStrings(aOverrideStrings),
-  mMonitor(0),
+  mMonitor("nsStringBundle.mMonitor"),
   mAttemptedLoad(PR_FALSE),
   mLoaded(PR_FALSE)
 {
 }
 
 nsresult
 nsStringBundle::LoadProperties()
 {
@@ -107,20 +106,16 @@ nsStringBundle::LoadProperties()
       
     return NS_ERROR_UNEXPECTED;
   }
   
   mAttemptedLoad = PR_TRUE;
 
   nsresult rv;
 
-  mMonitor = nsAutoMonitor::NewMonitor("StringBundle monitor");
-  if (!mMonitor)
-    return NS_ERROR_OUT_OF_MEMORY;
-
   // do it synchronously
   nsCOMPtr<nsIURI> uri;
   rv = NS_NewURI(getter_AddRefs(uri), mPropertiesURL);
   if (NS_FAILED(rv)) return rv;
 
   // We don't use NS_OpenURI because we want to tweak the channel
   nsCOMPtr<nsIChannel> channel;
   rv = NS_NewChannel(getter_AddRefs(channel), uri);
@@ -148,17 +143,17 @@ nsStringBundle::LoadProperties()
   
   return rv;
 }
 
 
 nsresult
 nsStringBundle::GetStringFromID(PRInt32 aID, nsAString& aResult)
 {  
-  nsAutoMonitor automon(mMonitor);
+  MonitorAutoEnter automon(mMonitor);
   nsCAutoString name;
   name.AppendInt(aID, 10);
 
   nsresult rv;
   
   // try override first
   if (mOverrideStrings) {
     rv = mOverrideStrings->GetStringFromName(mPropertiesURL,
@@ -269,17 +264,17 @@ nsStringBundle::GetStringFromName(const 
 {
   NS_ENSURE_ARG_POINTER(aName);
   NS_ENSURE_ARG_POINTER(aResult);
 
   nsresult rv;
   rv = LoadProperties();
   if (NS_FAILED(rv)) return rv;
 
-  nsAutoMonitor automon(mMonitor);
+  MonitorAutoEnter automon(mMonitor);
   *aResult = nsnull;
   nsAutoString tmpstr;
   rv = GetStringFromName(nsDependentString(aName), tmpstr);
   if (NS_FAILED(rv))
   {
 #if 0
     // it is not uncommon for apps to request a string name which may not exist
     // so be quiet about it. 
--- a/intl/strres/src/nsStringBundle.h
+++ b/intl/strres/src/nsStringBundle.h
@@ -33,23 +33,23 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef nsStringBundle_h__
 #define nsStringBundle_h__
 
+#include "mozilla/Monitor.h"
 #include "nsIStringBundle.h"
 #include "nsCOMPtr.h"
 #include "nsIPersistentProperties2.h"
 #include "nsString.h"
 #include "nsCOMArray.h"
 #include "nsIStringBundleOverride.h"
-#include "nsAutoLock.h"
 
 class nsStringBundle : public nsIStringBundle
 {
 public:
     // init version
     nsStringBundle(const char* aURLSpec, nsIStringBundleOverride*);
     nsresult LoadProperties();
     virtual ~nsStringBundle();
@@ -66,17 +66,17 @@ protected:
     nsresult GetStringFromID(PRInt32 aID, nsAString& aResult);
     nsresult GetStringFromName(const nsAString& aName, nsAString& aResult);
 
     nsresult GetCombinedEnumeration(nsIStringBundleOverride* aOverrideString,
                                     nsISimpleEnumerator** aResult);
 private:
     nsCString              mPropertiesURL;
     nsCOMPtr<nsIStringBundleOverride> mOverrideStrings;
-    PRMonitor*                   mMonitor;
+    mozilla::Monitor             mMonitor;
     PRPackedBool                 mAttemptedLoad;
     PRPackedBool                 mLoaded;
     
 public:
     static nsresult FormatString(const PRUnichar *formatStr,
                                  const PRUnichar **aParams, PRUint32 aLength,
                                  PRUnichar **aResult);
 };
--- a/intl/uconv/src/nsUNIXCharset.cpp
+++ b/intl/uconv/src/nsUNIXCharset.cpp
@@ -54,17 +54,16 @@
 #endif
 #ifdef HAVE_NL_TYPES_H
 #include <nl_types.h>
 #endif
 #if HAVE_LANGINFO_CODESET
 #include <langinfo.h>
 #endif
 #include "nsPlatformCharset.h"
-#include "nsAutoLock.h"
 #include "prinit.h"
 #include "nsUnicharUtils.h"
 
 static const char* kUnixCharsets[][3] = {
 #include "unixcharset.properties.h"
 };
 
 NS_IMPL_THREADSAFE_ISUPPORTS1(nsPlatformCharset, nsIPlatformCharset)
--- a/js/src/xpconnect/src/xpcjsruntime.cpp
+++ b/js/src/xpconnect/src/xpcjsruntime.cpp
@@ -44,16 +44,18 @@
 #include "WrapperFactory.h"
 #include "dom_quickstubs.h"
 
 #include "jsgcchunk.h"
 #include "nsIMemoryReporter.h"
 #include "mozilla/FunctionTimer.h"
 #include "prsystem.h"
 
+using namespace mozilla;
+
 /***************************************************************************/
 
 const char* XPCJSRuntime::mStrings[] = {
     "constructor",          // IDX_CONSTRUCTOR
     "toString",             // IDX_TO_STRING
     "toSource",             // IDX_TO_SOURCE
     "lastResult",           // IDX_LAST_RESULT
     "returnCode",           // IDX_RETURN_CODE
@@ -334,20 +336,20 @@ XPCJSRuntime::RemoveJSHolder(void* aHold
 void XPCJSRuntime::TraceJS(JSTracer* trc, void* data)
 {
     XPCJSRuntime* self = (XPCJSRuntime*)data;
 
     // Skip this part if XPConnect is shutting down. We get into
     // bad locking problems with the thread iteration otherwise.
     if(!self->GetXPConnect()->IsShuttingDown())
     {
-        PRLock* threadLock = XPCPerThreadData::GetLock();
+        Mutex* threadLock = XPCPerThreadData::GetLock();
         if(threadLock)
         { // scoped lock
-            nsAutoLock lock(threadLock);
+            MutexAutoLock lock(*threadLock);
 
             XPCPerThreadData* iterp = nsnull;
             XPCPerThreadData* thread;
 
             while(nsnull != (thread =
                              XPCPerThreadData::IterateThreads(&iterp)))
             {
                 // Trace those AutoMarkingPtr lists!
@@ -752,20 +754,20 @@ JSBool XPCJSRuntime::GCCallback(JSContex
             // we need to do this marking to avoid collecting those sets
             // that might no longer be otherwise reachable from the wrappers
             // or the wrapperprotos.
 
             // Skip this part if XPConnect is shutting down. We get into
             // bad locking problems with the thread iteration otherwise.
             if(!self->GetXPConnect()->IsShuttingDown())
             {
-                PRLock* threadLock = XPCPerThreadData::GetLock();
+                Mutex* threadLock = XPCPerThreadData::GetLock();
                 if(threadLock)
                 { // scoped lock
-                    nsAutoLock lock(threadLock);
+                    MutexAutoLock lock(*threadLock);
 
                     XPCPerThreadData* iterp = nsnull;
                     XPCPerThreadData* thread;
 
                     while(nsnull != (thread =
                                  XPCPerThreadData::IterateThreads(&iterp)))
                     {
                         // Mark those AutoMarkingPtr lists!
@@ -846,23 +848,23 @@ JSBool XPCJSRuntime::GCCallback(JSContex
             // on our wrapped natives that we are not actually using.
             //
             // XXX We may decide to not do this on *every* gc cycle.
 
             // Skip this part if XPConnect is shutting down. We get into
             // bad locking problems with the thread iteration otherwise.
             if(!self->GetXPConnect()->IsShuttingDown())
             {
-                PRLock* threadLock = XPCPerThreadData::GetLock();
+                Mutex* threadLock = XPCPerThreadData::GetLock();
                 if(threadLock)
                 {
                     // Do the marking...
                     
                     { // scoped lock
-                        nsAutoLock lock(threadLock);
+                        MutexAutoLock lock(*threadLock);
 
                         XPCPerThreadData* iterp = nsnull;
                         XPCPerThreadData* thread;
 
                         while(nsnull != (thread =
                                  XPCPerThreadData::IterateThreads(&iterp)))
                         {
                             XPCCallContext* ccxp = thread->GetCallContext();
--- a/js/src/xpconnect/src/xpcprivate.h
+++ b/js/src/xpconnect/src/xpcprivate.h
@@ -76,33 +76,34 @@
 #include "nsIXPConnect.h"
 #include "nsIInterfaceInfo.h"
 #include "nsIInterfaceInfoManager.h"
 #include "nsIXPCScriptable.h"
 #include "nsIXPCSecurityManager.h"
 #include "nsIJSRuntimeService.h"
 #include "nsWeakReference.h"
 #include "nsCOMPtr.h"
-#include "nsAutoLock.h"
 #include "nsXPTCUtils.h"
 #include "xptinfo.h"
 #include "xpcforwards.h"
 #include "xpclog.h"
 #include "xpccomponents.h"
 #include "xpcexception.h"
 #include "xpcjsid.h"
 #include "prlong.h"
 #include "prmem.h"
 #include "prenv.h"
 #include "prclist.h"
 #include "nsString.h"
 #include "nsReadableUtils.h"
 #include "nsXPIDLString.h"
 #include "nsAutoJSValHolder.h"
 #include "mozilla/AutoRestore.h"
+#include "mozilla/Monitor.h"
+#include "mozilla/Mutex.h"
 #include "nsDataHashtable.h"
 
 #include "nsThreadUtils.h"
 #include "nsIJSContextStack.h"
 #include "nsDeque.h"
 
 #include "nsIConsoleService.h"
 #include "nsIScriptError.h"
@@ -345,78 +346,61 @@ typedef nsDataHashtable<xpc::PtrAndPrinc
 /***************************************************************************/
 // Auto locking support class...
 
 // We PROMISE to never screw this up.
 #ifdef _MSC_VER
 #pragma warning(disable : 4355) // OK to pass "this" in member initializer
 #endif
 
-typedef PRMonitor XPCLock;
+typedef mozilla::Monitor XPCLock;
 
 static inline void xpc_Wait(XPCLock* lock) 
     {
         NS_ASSERTION(lock, "xpc_Wait called with null lock!");
-#ifdef DEBUG
-        PRStatus result = 
-#endif
-        PR_Wait(lock, PR_INTERVAL_NO_TIMEOUT);
-        NS_ASSERTION(PR_SUCCESS == result, "bad result from PR_Wait!");
+        lock->Wait();
     }
 
 static inline void xpc_NotifyAll(XPCLock* lock) 
     {
         NS_ASSERTION(lock, "xpc_NotifyAll called with null lock!");
-#ifdef DEBUG
-        PRStatus result = 
-#endif    
-        PR_NotifyAll(lock);
-        NS_ASSERTION(PR_SUCCESS == result, "bad result from PR_NotifyAll!");
+        lock->NotifyAll();
     }
 
 // This is a cloned subset of nsAutoMonitor. We want the use of a monitor -
 // mostly because we need reenterability - but we also want to support passing
 // a null monitor in without things blowing up. This is used for wrappers that
 // are guaranteed to be used only on one thread. We avoid lock overhead by
 // using a null monitor. By changing this class we can avoid having multiplte
 // code paths or (conditional) manual calls to PR_{Enter,Exit}Monitor.
 //
 // Note that xpconnect only makes *one* monitor and *mostly* holds it locked
 // only through very small critical sections.
 
-class NS_STACK_CLASS XPCAutoLock : public nsAutoLockBase {
+class NS_STACK_CLASS XPCAutoLock {
 public:
 
     static XPCLock* NewLock(const char* name)
-                        {return nsAutoMonitor::NewMonitor(name);}
+                        {return new mozilla::Monitor(name);}
     static void     DestroyLock(XPCLock* lock)
-                        {nsAutoMonitor::DestroyMonitor(lock);}
+                        {delete lock;}
 
     XPCAutoLock(XPCLock* lock MOZILLA_GUARD_OBJECT_NOTIFIER_PARAM)
-#ifdef DEBUG_jband
-        : nsAutoLockBase(lock ? (void*) lock : (void*) this, eAutoMonitor),
-#else
-        : nsAutoLockBase(lock, eAutoMonitor),
-#endif
-          mLock(lock)
+        : mLock(lock)
     {
         MOZILLA_GUARD_OBJECT_NOTIFIER_INIT;
         if(mLock)
-            PR_EnterMonitor(mLock);
+            mLock->Enter();
     }
 
     ~XPCAutoLock()
     {
         if(mLock)
         {
-#ifdef DEBUG
-            PRStatus status =
-#endif
-                PR_ExitMonitor(mLock);
-            NS_ASSERTION(status == PR_SUCCESS, "PR_ExitMonitor failed");
+            mLock->Exit();
         }
     }
 
 private:
     XPCLock*  mLock;
     MOZILLA_DECL_USE_GUARD_OBJECT_NOTIFIER
 
     // Not meant to be implemented. This makes it a compiler error to
@@ -432,37 +416,32 @@ private:
     static void* operator new(size_t /*size*/) CPP_THROW_NEW {
         return nsnull;
     }
     static void operator delete(void* /*memory*/) {}
 };
 
 /************************************************/
 
-class NS_STACK_CLASS XPCAutoUnlock : public nsAutoUnlockBase {
+class NS_STACK_CLASS XPCAutoUnlock {
 public:
     XPCAutoUnlock(XPCLock* lock MOZILLA_GUARD_OBJECT_NOTIFIER_PARAM)
-        : nsAutoUnlockBase(lock),
-          mLock(lock)
+        : mLock(lock)
     {
         MOZILLA_GUARD_OBJECT_NOTIFIER_INIT;
         if(mLock)
         {
-#ifdef DEBUG
-            PRStatus status =
-#endif
-                PR_ExitMonitor(mLock);
-            NS_ASSERTION(status == PR_SUCCESS, "PR_ExitMonitor failed");
+            mLock->Exit();
         }
     }
 
     ~XPCAutoUnlock()
     {
         if(mLock)
-            PR_EnterMonitor(mLock);
+            mLock->Enter();
     }
 
 private:
     XPCLock*  mLock;
     MOZILLA_DECL_USE_GUARD_OBJECT_NOTIFIER
 
     // Not meant to be implemented. This makes it a compiler error to
     // construct or assign an XPCAutoUnlock object incorrectly.
@@ -3668,16 +3647,18 @@ private:
 
 /**************************************************************/
 // All of our thread local storage.
 
 #define BAD_TLS_INDEX ((PRUint32) -1)
 
 class XPCPerThreadData
 {
+    typedef mozilla::Mutex Mutex;
+
 public:
     // Get the instance of this object for the current thread
     static inline XPCPerThreadData* GetData(JSContext *cx)
     {
         if(cx)
         {
             NS_ASSERTION(cx->thread, "Uh, JS context w/o a thread?");
 
@@ -3758,17 +3739,17 @@ public:
         {XPCWrappedNative* old = mResolvingWrapper;
          mResolvingWrapper = w; return old;}
 
     void Cleanup();
     void ReleaseNatives();
 
     PRBool IsValid() const {return mJSContextStack != nsnull;}
 
-    static PRLock* GetLock() {return gLock;}
+    static Mutex* GetLock() {return gLock;}
     // Must be called with the threads locked.
     static XPCPerThreadData* IterateThreads(XPCPerThreadData** iteratorp);
 
     AutoMarkingPtr**  GetAutoRootsAdr() {return &mAutoRoots;}
 
     void TraceJS(JSTracer* trc);
     void MarkAutoRootsAfterJSFinalize();
 
@@ -3804,17 +3785,17 @@ private:
     JSBool               mExceptionManagerNotAvailable;
     AutoMarkingPtr*      mAutoRoots;
 
 #ifdef XPC_CHECK_WRAPPER_THREADSAFETY
     JSUint32             mWrappedNativeThreadsafetyReportDepth;
 #endif
     PRThread*            mThread;
 
-    static PRLock*           gLock;
+    static Mutex*            gLock;
     static XPCPerThreadData* gThreads;
     static PRUintn           gTLSIndex;
 
     // Cached value of cx->thread on the main thread. 
     static void *sMainJSThread;
 
     // Cached per thread data for the main thread. Only safe to access
     // if cx->thread == sMainJSThread.
--- a/js/src/xpconnect/src/xpcthreadcontext.cpp
+++ b/js/src/xpconnect/src/xpcthreadcontext.cpp
@@ -38,20 +38,23 @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 /* Implement global service to track stack of JSContext per thread. */
 
 #include "xpcprivate.h"
 #include "XPCWrapper.h"
+#include "mozilla/Mutex.h"
 #include "nsDOMJSUtils.h"
 #include "nsIScriptGlobalObject.h"
 #include "nsNullPrincipal.h"
 
+using namespace mozilla;
+
 /***************************************************************************/
 
 XPCJSContextStack::XPCJSContextStack()
     : mStack(),
       mSafeJSContext(nsnull),
       mOwnSafeJSContext(nsnull)
 {
     // empty...
@@ -336,17 +339,17 @@ XPCJSContextStack::SetSafeJSContext(JSCo
 
     mSafeJSContext = aSafeJSContext;
     return NS_OK;
 }
 
 /***************************************************************************/
 
 PRUintn           XPCPerThreadData::gTLSIndex       = BAD_TLS_INDEX;
-PRLock*           XPCPerThreadData::gLock           = nsnull;
+Mutex*            XPCPerThreadData::gLock           = nsnull;
 XPCPerThreadData* XPCPerThreadData::gThreads        = nsnull;
 XPCPerThreadData *XPCPerThreadData::sMainThreadData = nsnull;
 void *            XPCPerThreadData::sMainJSThread   = nsnull;
 
 XPCPerThreadData::XPCPerThreadData()
     :   mJSContextStack(new XPCJSContextStack()),
         mNextThread(nsnull),
         mCallContext(nsnull),
@@ -358,17 +361,17 @@ XPCPerThreadData::XPCPerThreadData()
         mAutoRoots(nsnull)
 #ifdef XPC_CHECK_WRAPPER_THREADSAFETY
       , mWrappedNativeThreadsafetyReportDepth(0)
 #endif
 {
     MOZ_COUNT_CTOR(xpcPerThreadData);
     if(gLock)
     {
-        nsAutoLock lock(gLock);
+        MutexAutoLock lock(*gLock);
         mNextThread = gThreads;
         gThreads = this;
     }
 }
 
 void
 XPCPerThreadData::Cleanup()
 {
@@ -392,17 +395,17 @@ XPCPerThreadData::~XPCPerThreadData()
 
     MOZ_COUNT_DTOR(xpcPerThreadData);
 
     Cleanup();
 
     // Unlink 'this' from the list of threads.
     if(gLock)
     {
-        nsAutoLock lock(gLock);
+        MutexAutoLock lock(*gLock);
         if(gThreads == this)
             gThreads = mNextThread;
         else
         {
             XPCPerThreadData* cur = gThreads;
             while(cur)
             {
                 if(cur->mNextThread == this)
@@ -414,17 +417,17 @@ XPCPerThreadData::~XPCPerThreadData()
             }
         }
         if (!gThreads)
             doDestroyLock = PR_TRUE;
     }
 
     if(gLock && doDestroyLock)
     {
-        nsAutoLock::DestroyLock(gLock);
+        delete gLock;
         gLock = nsnull;
     }
 }
 
 static void
 xpc_ThreadDataDtorCB(void* ptr)
 {
     XPCPerThreadData* data = (XPCPerThreadData*) ptr;
@@ -460,24 +463,22 @@ void XPCPerThreadData::MarkAutoRootsAfte
 // static
 XPCPerThreadData*
 XPCPerThreadData::GetDataImpl(JSContext *cx)
 {
     XPCPerThreadData* data;
 
     if(!gLock)
     {
-        gLock = nsAutoLock::NewLock("XPCPerThreadData::gLock");
-        if(!gLock)
-            return nsnull;
+        gLock = new Mutex("XPCPerThreadData.gLock");
     }
 
     if(gTLSIndex == BAD_TLS_INDEX)
     {
-        nsAutoLock lock(gLock);
+        MutexAutoLock lock(*gLock);
         // check again now that we have the lock...
         if(gTLSIndex == BAD_TLS_INDEX)
         {
             if(PR_FAILURE ==
                PR_NewThreadPrivateIndex(&gTLSIndex, xpc_ThreadDataDtorCB))
             {
                 NS_ERROR("PR_NewThreadPrivateIndex failed!");
                 gTLSIndex = BAD_TLS_INDEX;
@@ -528,17 +529,17 @@ XPCPerThreadData::CleanupAllThreads()
     // the lock. Yuk!
 
     XPCJSContextStack** stacks = nsnull;
     int count = 0;
     int i;
 
     if(gLock)
     {
-        nsAutoLock lock(gLock);
+        MutexAutoLock lock(*gLock);
 
         for(XPCPerThreadData* cur = gThreads; cur; cur = cur->mNextThread)
             count++;
 
         stacks = (XPCJSContextStack**) new XPCJSContextStack*[count] ;
         if(stacks)
         {
             i = 0;
--- a/modules/libjar/nsJAR.cpp
+++ b/modules/libjar/nsJAR.cpp
@@ -50,16 +50,18 @@
 #include "mozilla/Omnijar.h"
 
 #ifdef XP_UNIX
   #include <sys/stat.h>
 #elif defined (XP_WIN) || defined(XP_OS2)
   #include <io.h>
 #endif
 
+using namespace mozilla;
+
 //----------------------------------------------
 // nsJARManifestItem declaration
 //----------------------------------------------
 /*
  * nsJARManifestItem contains meta-information pertaining 
  * to an individual JAR entry, taken from the 
  * META-INF/MANIFEST.MF and META-INF/ *.SF files.
  * This is security-critical information, defined here so it is not
@@ -118,18 +120,19 @@ DeleteManifestEntry(nsHashKey* aKey, voi
 
 // The following initialization makes a guess of 10 entries per jarfile.
 nsJAR::nsJAR(): mZip(new nsZipArchive()),
                 mManifestData(nsnull, nsnull, DeleteManifestEntry, nsnull, 10),
                 mParsedManifest(PR_FALSE),
                 mGlobalStatus(JAR_MANIFEST_NOT_PARSED),
                 mReleaseTime(PR_INTERVAL_NO_TIMEOUT), 
                 mCache(nsnull), 
-                mLock(nsnull),
-                mTotalItemsInManifest(0)
+                mLock("nsJAR::mLock"),
+                mTotalItemsInManifest(0),
+                mOpened(PR_FALSE)
 {
 }
 
 nsJAR::~nsJAR()
 {
   Close();
 }
 
@@ -163,23 +166,21 @@ nsrefcnt nsJAR::Release(void)
 //----------------------------------------------
 // nsIZipReader implementation
 //----------------------------------------------
 
 NS_IMETHODIMP
 nsJAR::Open(nsIFile* zipFile)
 {
   NS_ENSURE_ARG_POINTER(zipFile);
-  if (mLock) return NS_ERROR_FAILURE; // Already open!
+  if (mOpened) return NS_ERROR_FAILURE; // Already open!
 
   mZipFile = zipFile;
   mOuterZipEntry.Truncate();
-
-  mLock = nsAutoLock::NewLock("nsJAR::mLock");
-  NS_ENSURE_TRUE(mLock, NS_ERROR_OUT_OF_MEMORY);
+  mOpened = PR_TRUE;
   
 #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) {
     mZip = mozilla::OmnijarReader();
@@ -189,28 +190,27 @@ nsJAR::Open(nsIFile* zipFile)
   return mZip->OpenArchive(zipFile);
 }
 
 NS_IMETHODIMP
 nsJAR::OpenInner(nsIZipReader *aZipReader, const char *aZipEntry)
 {
   NS_ENSURE_ARG_POINTER(aZipReader);
   NS_ENSURE_ARG_POINTER(aZipEntry);
-  if (mLock) return NS_ERROR_FAILURE; // Already open!
+  if (mOpened) return NS_ERROR_FAILURE; // Already open!
 
   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 = nsAutoLock::NewLock("nsJAR::mLock");
-  NS_ENSURE_TRUE(mLock, NS_ERROR_OUT_OF_MEMORY);
+  mOpened = PR_TRUE;
 
   mOuterZipEntry.Assign(aZipEntry);
 
   nsRefPtr<nsZipHandle> handle;
   rv = nsZipHandle::Init(static_cast<nsJAR*>(aZipReader)->mZip.get(), aZipEntry,
                          getter_AddRefs(handle));
   if (NS_FAILED(rv))
     return rv;
@@ -224,21 +224,17 @@ nsJAR::GetFile(nsIFile* *result)
   *result = mZipFile;
   NS_IF_ADDREF(*result);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsJAR::Close()
 {
-  if (mLock) {
-    nsAutoLock::DestroyLock(mLock);
-    mLock = nsnull;
-  }
-
+  mOpened = PR_FALSE;
   mParsedManifest = PR_FALSE;
   mManifestData.Reset();
   mGlobalStatus = JAR_MANIFEST_NOT_PARSED;
   mTotalItemsInManifest = 0;
 
 #ifdef MOZ_OMNIJAR
   if (mZip == mozilla::OmnijarReader()) {
     mZip.forget();
@@ -255,17 +251,17 @@ nsJAR::Test(const char *aEntryName)
   return mZip->Test(aEntryName);
 }
 
 NS_IMETHODIMP
 nsJAR::Extract(const char *zipEntry, nsIFile* outFile)
 {
   // nsZipArchive and zlib are not thread safe
   // we need to use a lock to prevent bug #51267
-  nsAutoLock lock(mLock);
+  MutexAutoLock lock(mLock);
 
   nsresult rv;
   nsCOMPtr<nsILocalFile> localFile = do_QueryInterface(outFile, &rv);
   if (NS_FAILED(rv)) return rv;
 
   nsZipItem *item = mZip->GetItem(zipEntry);
   NS_ENSURE_TRUE(item, NS_ERROR_FILE_TARGET_DOES_NOT_EXIST);
 
@@ -1055,17 +1051,17 @@ nsJARItem::GetLastModifiedTime(PRTime* a
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsIZipReaderCache
 
 NS_IMPL_THREADSAFE_ISUPPORTS3(nsZipReaderCache, nsIZipReaderCache, nsIObserver, nsISupportsWeakReference)
 
 nsZipReaderCache::nsZipReaderCache()
-  : mLock(nsnull)
+  : mLock("nsZipReaderCache.mLock")
   , mZips(16)
 #ifdef ZIP_CACHE_HIT_RATE
     ,
     mZipCacheLookups(0),
     mZipCacheHits(0),
     mZipCacheFlushes(0),
     mZipSyncMisses(0)
 #endif
@@ -1083,49 +1079,46 @@ 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 = nsAutoLock::NewLock("nsZipReaderCache::mLock");
-  return mLock ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+  return NS_OK;
 }
 
 static PRBool
 DropZipReaderCache(nsHashKey *aKey, void *aData, void* closure)
 {
   nsJAR* zip = (nsJAR*)aData;
   zip->SetZipReaderCache(nsnull);
   return PR_TRUE;
 }
 
 nsZipReaderCache::~nsZipReaderCache()
 {
-  if (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
 }
 
 NS_IMETHODIMP
 nsZipReaderCache::GetZip(nsIFile* zipFile, nsIZipReader* *result)
 {
   NS_ENSURE_ARG_POINTER(zipFile);
   nsresult rv;
   nsCOMPtr<nsIZipReader> antiLockZipGrip;
-  nsAutoLock lock(mLock);
+  MutexAutoLock lock(mLock);
 
 #ifdef ZIP_CACHE_HIT_RATE
   mZipCacheLookups++;
 #endif
 
   nsCAutoString uri;
   rv = zipFile->GetNativePath(uri);
   if (NS_FAILED(rv)) return rv;
@@ -1242,17 +1235,17 @@ FindZip(nsHashKey *aKey, void *aData, vo
   }
   return PR_TRUE;
 }
 
 nsresult
 nsZipReaderCache::ReleaseZip(nsJAR* zip)
 {
   nsresult rv;
-  nsAutoLock lock(mLock);
+  MutexAutoLock lock(mLock);
 
   // It is possible that two thread compete for this zip. The dangerous 
   // case is where one thread Releases the zip and discovers that the ref
   // count has gone to one. Before it can call this ReleaseZip method
   // another thread calls our GetZip method. The ref count goes to two. That
   // second thread then Releases the zip and the ref count goes to one. It
   // then tries to enter this ReleaseZip method and blocks while the first
   // thread is still here. The first thread continues and remove the zip from 
@@ -1331,17 +1324,17 @@ FindFlushableZip(nsHashKey *aKey, void *
 }
 
 NS_IMETHODIMP
 nsZipReaderCache::Observe(nsISupports *aSubject,
                           const char *aTopic, 
                           const PRUnichar *aSomeData)
 {
   if (strcmp(aTopic, "memory-pressure") == 0) {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     while (PR_TRUE) {
       nsHashKey* flushable = nsnull;
       mZips.Enumerate(FindFlushableZip, &flushable); 
       if ( ! flushable )
         break;
 #ifdef DEBUG
       PRBool removed =
 #endif
@@ -1364,17 +1357,17 @@ nsZipReaderCache::Observe(nsISupports *a
 
     nsCAutoString uri;
     if (NS_FAILED(file->GetNativePath(uri)))
       return NS_OK;
 
     uri.Insert(NS_LITERAL_CSTRING("file:"), 0);
     nsCStringKey key(uri);
 
-    nsAutoLock lock(mLock);    
+    MutexAutoLock lock(mLock);    
     nsJAR* zip = static_cast<nsJAR*>(static_cast<nsIZipReader*>(mZips.Get(&key)));
     if (!zip)
       return NS_OK;
 
 #ifdef ZIP_CACHE_HIT_RATE
     mZipCacheFlushes++;
 #endif
 
--- a/modules/libjar/nsJAR.h
+++ b/modules/libjar/nsJAR.h
@@ -47,23 +47,23 @@
 #include "pratom.h"
 #include "prmem.h"
 #include "prio.h"
 #include "plstr.h"
 #include "prlog.h"
 #include "prtypes.h"
 #include "prinrval.h"
 
+#include "mozilla/Mutex.h"
 #include "nsIComponentManager.h"
 #include "nsCOMPtr.h"
 #include "nsString.h"
 #include "nsIFile.h"
 #include "nsStringEnumerator.h"
 #include "nsHashtable.h"
-#include "nsAutoLock.h"
 #include "nsIZipReader.h"
 #include "nsZipArchive.h"
 #include "nsIPrincipal.h"
 #include "nsISignatureVerifier.h"
 #include "nsIObserverService.h"
 #include "nsWeakReference.h"
 #include "nsIObserver.h"
 
@@ -135,20 +135,21 @@ class nsJAR : public nsIZipReader
     nsCString                mOuterZipEntry;  // The entry in the zip this zip is reading from
     nsAutoPtr<nsZipArchive>  mZip;            // The underlying zip archive
     nsObjectHashtable        mManifestData;   // Stores metadata for each entry
     PRBool                   mParsedManifest; // True if manifest has been parsed
     nsCOMPtr<nsIPrincipal>   mPrincipal;      // The entity which signed this file
     PRInt16                  mGlobalStatus;   // Global signature verification status
     PRIntervalTime           mReleaseTime;    // used by nsZipReaderCache for flushing entries
     nsZipReaderCache*        mCache;          // if cached, this points to the cache it's contained in
-    PRLock*                  mLock;	
+    mozilla::Mutex           mLock;	
     PRInt64                  mMtime;
     PRInt32                  mTotalItemsInManifest;
-    
+    PRBool                   mOpened;
+
     nsresult ParseManifest();
     void     ReportError(const char* aFilename, PRInt16 errorCode);
     nsresult LoadEntry(const char* aFilename, char** aBuf, 
                        PRUint32* aBufLen = nsnull);
     PRInt32  ReadLine(const char** src); 
     nsresult ParseOneFile(const char* filebuf, PRInt16 aFileType);
     nsresult VerifyEntry(nsJARManifestItem* aEntry, const char* aEntryData, 
                          PRUint32 aLen);
@@ -224,17 +225,17 @@ public:
   NS_DECL_NSIOBSERVER
 
   nsZipReaderCache();
   virtual ~nsZipReaderCache();
 
   nsresult ReleaseZip(nsJAR* reader);
 
 protected:
-  PRLock*               mLock;
+  mozilla::Mutex        mLock;
   PRInt32               mCacheSize;
   nsSupportsHashtable   mZips;
 
 #ifdef ZIP_CACHE_HIT_RATE
   PRUint32              mZipCacheLookups;
   PRUint32              mZipCacheHits;
   PRUint32              mZipCacheFlushes;
   PRUint32              mZipSyncMisses;
--- a/modules/plugin/base/src/nsNPAPIPlugin.cpp
+++ b/modules/plugin/base/src/nsNPAPIPlugin.cpp
@@ -46,17 +46,16 @@
 
 #include "prtypes.h"
 #include "prmem.h"
 #include "prenv.h"
 #include "prclist.h"
 
 #include "jscntxt.h"
 
-#include "nsAutoLock.h"
 #include "nsNPAPIPlugin.h"
 #include "nsNPAPIPluginInstance.h"
 #include "nsNPAPIPluginStreamListener.h"
 #include "nsIServiceManager.h"
 #include "nsThreadUtils.h"
 #include "nsIPrivateBrowsingService.h"
 
 #include "nsIPluginStreamListener.h"
@@ -103,16 +102,17 @@
 #endif
 
 #include "nsJSNPRuntime.h"
 #include "nsIHttpAuthManager.h"
 #include "nsICookieService.h"
 
 #include "nsNetUtil.h"
 
+#include "mozilla/Mutex.h"
 #include "mozilla/PluginLibrary.h"
 using mozilla::PluginLibrary;
 
 #include "mozilla/PluginPRLibrary.h"
 using mozilla::PluginPRLibrary;
 
 #ifdef MOZ_IPC
 #include "mozilla/plugins/PluginModuleParent.h"
@@ -122,16 +122,17 @@ using mozilla::plugins::PluginModulePare
 #ifdef MOZ_X11
 #include "mozilla/X11Util.h"
 #endif
 
 #ifdef XP_WIN
 #include <windows.h>
 #endif
 
+using namespace mozilla;
 using namespace mozilla::plugins::parent;
 
 // We should make this const...
 static NPNetscapeFuncs sBrowserFuncs = {
   sizeof(sBrowserFuncs),
   (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR,
   _geturl,
   _posturl,
@@ -185,17 +186,17 @@ static NPNetscapeFuncs sBrowserFuncs = {
   _unscheduletimer,
   _popupcontextmenu,
   _convertpoint,
   NULL, // handleevent, unimplemented
   NULL, // unfocusinstance, unimplemented
   _urlredirectresponse
 };
 
-static PRLock *sPluginThreadAsyncCallLock = nsnull;
+static Mutex *sPluginThreadAsyncCallLock = nsnull;
 static PRCList sPendingAsyncCalls = PR_INIT_STATIC_CLIST(&sPendingAsyncCalls);
 
 // POST/GET stream type
 enum eNPPStreamTypeInternal {
   eNPPStreamTypeInternal_Get,
   eNPPStreamTypeInternal_Post
 };
 
@@ -224,17 +225,17 @@ void NS_NotifyPluginCall(PRIntervalTime 
 static void CheckClassInitialized()
 {
   static PRBool initialized = PR_FALSE;
 
   if (initialized)
     return;
 
   if (!sPluginThreadAsyncCallLock)
-    sPluginThreadAsyncCallLock = nsAutoLock::NewLock("sPluginThreadAsyncCallLock");
+    sPluginThreadAsyncCallLock = new Mutex("nsNPAPIPlugin.sPluginThreadAsyncCallLock");
 
   initialized = PR_TRUE;
 
   NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL,("NPN callbacks initialized\n"));
 }
 
 NS_IMPL_ISUPPORTS1(nsNPAPIPlugin, nsIPlugin)
 
@@ -835,17 +836,17 @@ nsPluginThreadRunnable::nsPluginThreadRu
     mFunc = nsnull;
 
     return;
   }
 
   PR_INIT_CLIST(this);
 
   {
-    nsAutoLock lock(sPluginThreadAsyncCallLock);
+    MutexAutoLock lock(*sPluginThreadAsyncCallLock);
 
     nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *)instance->ndata;
     if (!inst || !inst->IsRunning()) {
       // The plugin was stopped, ignore this async call.
       mFunc = nsnull;
 
       return;
     }
@@ -856,17 +857,17 @@ nsPluginThreadRunnable::nsPluginThreadRu
 
 nsPluginThreadRunnable::~nsPluginThreadRunnable()
 {
   if (!sPluginThreadAsyncCallLock) {
     return;
   }
 
   {
-    nsAutoLock lock(sPluginThreadAsyncCallLock);
+    MutexAutoLock lock(*sPluginThreadAsyncCallLock);
 
     PR_REMOVE_LINK(this);
   }
 }
 
 NS_IMETHODIMP
 nsPluginThreadRunnable::Run()
 {
@@ -882,17 +883,17 @@ nsPluginThreadRunnable::Run()
 void
 OnPluginDestroy(NPP instance)
 {
   if (!sPluginThreadAsyncCallLock) {
     return;
   }
 
   {
-    nsAutoLock lock(sPluginThreadAsyncCallLock);
+    MutexAutoLock lock(*sPluginThreadAsyncCallLock);
 
     if (PR_CLIST_IS_EMPTY(&sPendingAsyncCalls)) {
       return;
     }
 
     nsPluginThreadRunnable *r =
       (nsPluginThreadRunnable *)PR_LIST_HEAD(&sPendingAsyncCalls);
 
@@ -908,38 +909,33 @@ OnPluginDestroy(NPP instance)
 
 void
 OnShutdown()
 {
   NS_ASSERTION(PR_CLIST_IS_EMPTY(&sPendingAsyncCalls),
                "Pending async plugin call list not cleaned up!");
 
   if (sPluginThreadAsyncCallLock) {
-    nsAutoLock::DestroyLock(sPluginThreadAsyncCallLock);
+    delete sPluginThreadAsyncCallLock;
 
     sPluginThreadAsyncCallLock = nsnull;
   }
 }
 
-void
-EnterAsyncPluginThreadCallLock()
+AsyncCallbackAutoLock::AsyncCallbackAutoLock()
 {
-  if (sPluginThreadAsyncCallLock) {
-    PR_Lock(sPluginThreadAsyncCallLock);
-  }
+  sPluginThreadAsyncCallLock->Lock();
 }
 
-void
-ExitAsyncPluginThreadCallLock()
+AsyncCallbackAutoLock::~AsyncCallbackAutoLock()
 {
-  if (sPluginThreadAsyncCallLock) {
-    PR_Unlock(sPluginThreadAsyncCallLock);
-  }
+  sPluginThreadAsyncCallLock->Unlock();
 }
 
+
 NPP NPPStack::sCurrentNPP = nsnull;
 
 const char *
 PeekException()
 {
   return gNPPException;
 }
 
--- a/modules/plugin/base/src/nsNPAPIPlugin.h
+++ b/modules/plugin/base/src/nsNPAPIPlugin.h
@@ -378,20 +378,25 @@ void
 PopException();
 
 void
 OnPluginDestroy(NPP instance);
 
 void
 OnShutdown();
 
-void
-EnterAsyncPluginThreadCallLock();
-void
-ExitAsyncPluginThreadCallLock();
+/**
+ * within a lexical scope, locks and unlocks the mutex used to
+ * serialize modifications to plugin async callback state.
+ */
+struct NS_STACK_CLASS AsyncCallbackAutoLock
+{
+  AsyncCallbackAutoLock();
+  ~AsyncCallbackAutoLock();
+};
 
 class NPPStack
 {
 public:
   static NPP Peek()
   {
     return sCurrentNPP;
   }
--- a/modules/plugin/base/src/nsNPAPIPluginInstance.cpp
+++ b/modules/plugin/base/src/nsNPAPIPluginInstance.cpp
@@ -184,20 +184,21 @@ NS_IMETHODIMP nsNPAPIPluginInstance::Sto
   // If there's code from this plugin instance on the stack, delay the
   // destroy.
   if (PluginDestructionGuard::DelayDestroy(this)) {
     return NS_OK;
   }
 
   // Make sure we lock while we're writing to mRunning after we've
   // started as other threads might be checking that inside a lock.
-  EnterAsyncPluginThreadCallLock();
-  mRunning = DESTROYING;
-  mStopTime = TimeStamp::Now();
-  ExitAsyncPluginThreadCallLock();
+  {
+    AsyncCallbackAutoLock lock;
+    mRunning = DESTROYING;
+    mStopTime = TimeStamp::Now();
+  }
 
   OnPluginDestroy(&mNPP);
 
   // clean up open streams
   while (mStreamListeners.Length() > 0) {
     nsRefPtr<nsNPAPIPluginStreamListener> currentListener(mStreamListeners[0]);
     currentListener->CleanUpStream(NPRES_USER_BREAK);
     mStreamListeners.RemoveElement(currentListener);
--- a/netwerk/base/src/nsAsyncStreamCopier.cpp
+++ b/netwerk/base/src/nsAsyncStreamCopier.cpp
@@ -36,68 +36,67 @@
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsIOService.h"
 #include "nsAsyncStreamCopier.h"
 #include "nsIEventTarget.h"
 #include "nsStreamUtils.h"
 #include "nsNetSegmentUtils.h"
 #include "nsNetUtil.h"
-#include "nsAutoLock.h"
 #include "prlog.h"
 
+using namespace mozilla;
+
 #if defined(PR_LOGGING)
 //
 // NSPR_LOG_MODULES=nsStreamCopier:5
 //
 static PRLogModuleInfo *gStreamCopierLog = nsnull;
 #endif
 #define LOG(args) PR_LOG(gStreamCopierLog, PR_LOG_DEBUG, args)
 
 //-----------------------------------------------------------------------------
 
 nsAsyncStreamCopier::nsAsyncStreamCopier()
-    : mLock(nsnull)
+    : mLock("nsAsyncStreamCopier.mLock")
     , mMode(NS_ASYNCCOPY_VIA_READSEGMENTS)
     , mChunkSize(nsIOService::gDefaultSegmentSize)
     , mStatus(NS_OK)
     , mIsPending(PR_FALSE)
 {
 #if defined(PR_LOGGING)
     if (!gStreamCopierLog)
         gStreamCopierLog = PR_NewLogModule("nsStreamCopier");
 #endif
     LOG(("Creating nsAsyncStreamCopier @%x\n", this));
 }
 
 nsAsyncStreamCopier::~nsAsyncStreamCopier()
 {
     LOG(("Destroying nsAsyncStreamCopier @%x\n", this));
-    if (mLock)
-        nsAutoLock::DestroyLock(mLock);
 }
 
 PRBool
 nsAsyncStreamCopier::IsComplete(nsresult *status)
 {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     if (status)
         *status = mStatus;
     return !mIsPending;
 }
 
 void
 nsAsyncStreamCopier::Complete(nsresult status)
 {
     LOG(("nsAsyncStreamCopier::Complete [this=%x status=%x]\n", this, status));
 
     nsCOMPtr<nsIRequestObserver> observer;
     nsCOMPtr<nsISupports> ctx;
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
         mCopierCtx = nsnull;
 
         if (mIsPending) {
             mIsPending = PR_FALSE;
             mStatus = status;
 
             // setup OnStopRequest callback and release references...
             observer = mObserver;
@@ -152,17 +151,17 @@ nsAsyncStreamCopier::GetStatus(nsresult 
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsAsyncStreamCopier::Cancel(nsresult status)
 {
     nsCOMPtr<nsISupports> copierCtx;
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
         if (!mIsPending)
             return NS_OK;
         copierCtx.swap(mCopierCtx);
     }
 
     if (NS_SUCCEEDED(status)) {
         NS_WARNING("cancel with non-failure status code");
         status = NS_BASE_STREAM_CLOSED;
@@ -224,21 +223,16 @@ nsAsyncStreamCopier::Init(nsIInputStream
                           PRBool sourceBuffered,
                           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 = nsAutoLock::NewLock("nsAsyncStreamCopier::mLock");
-    if (!mLock)
-        return NS_ERROR_OUT_OF_MEMORY;
-
     if (chunkSize == 0)
         chunkSize = nsIOService::gDefaultSegmentSize;
     mChunkSize = chunkSize;
 
     mSource = source;
     mSink = sink;
     mCloseSource = closeSource;
     mCloseSink = closeSink;
--- a/netwerk/base/src/nsAsyncStreamCopier.h
+++ b/netwerk/base/src/nsAsyncStreamCopier.h
@@ -37,19 +37,19 @@
 
 #ifndef nsAsyncStreamCopier_h__
 #define nsAsyncStreamCopier_h__
 
 #include "nsIAsyncStreamCopier.h"
 #include "nsIAsyncInputStream.h"
 #include "nsIAsyncOutputStream.h"
 #include "nsIRequestObserver.h"
+#include "mozilla/Mutex.h"
 #include "nsStreamUtils.h"
 #include "nsCOMPtr.h"
-#include "prlock.h"
 
 //-----------------------------------------------------------------------------
 
 class nsAsyncStreamCopier : public nsIAsyncStreamCopier
 {
 public:
     NS_DECL_ISUPPORTS
     NS_DECL_NSIREQUEST
@@ -73,17 +73,17 @@ private:
 
     nsCOMPtr<nsIRequestObserver>   mObserver;
     nsCOMPtr<nsISupports>          mObserverContext;
 
     nsCOMPtr<nsIEventTarget>       mTarget;
 
     nsCOMPtr<nsISupports>          mCopierCtx;
 
-    PRLock                        *mLock;
+    mozilla::Mutex                 mLock;
 
     nsAsyncCopyMode                mMode;
     PRUint32                       mChunkSize;
     nsresult                       mStatus;
     PRPackedBool                   mIsPending;
     PRPackedBool                   mCloseSource;
     PRPackedBool                   mCloseSink;
 };
--- a/netwerk/base/src/nsPACMan.cpp
+++ b/netwerk/base/src/nsPACMan.cpp
@@ -42,17 +42,16 @@
 #include "nsIDNSListener.h"
 #include "nsICancelable.h"
 #include "nsIAuthPrompt.h"
 #include "nsIPromptFactory.h"
 #include "nsIHttpChannel.h"
 #include "nsIPrefService.h"
 #include "nsIPrefBranch.h"
 #include "nsNetUtil.h"
-#include "nsAutoLock.h"
 #include "nsAutoPtr.h"
 #include "nsCRT.h"
 #include "prmon.h"
 #include "nsIAsyncVerifyRedirectCallback.h"
 
 //-----------------------------------------------------------------------------
 
 // Check to see if the underlying request was not an error page in the case of
--- a/netwerk/base/src/nsProtocolProxyService.cpp
+++ b/netwerk/base/src/nsProtocolProxyService.cpp
@@ -38,17 +38,16 @@
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsProtocolProxyService.h"
 #include "nsProxyInfo.h"
 #include "nsIClassInfoImpl.h"
 #include "nsIServiceManager.h"
 #include "nsXPIDLString.h"
 #include "nsIProxyAutoConfig.h"
-#include "nsAutoLock.h"
 #include "nsIIOService.h"
 #include "nsIObserverService.h"
 #include "nsIProtocolHandler.h"
 #include "nsIProtocolProxyCallback.h"
 #include "nsICancelable.h"
 #include "nsIDNSService.h"
 #include "nsIPrefService.h"
 #include "nsIPrefBranch2.h"
--- a/netwerk/base/src/nsServerSocket.cpp
+++ b/netwerk/base/src/nsServerSocket.cpp
@@ -35,23 +35,24 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsIProxyObjectManager.h"
 #include "nsIServiceManager.h"
 #include "nsSocketTransport2.h"
 #include "nsServerSocket.h"
 #include "nsProxyRelease.h"
-#include "nsAutoLock.h"
 #include "nsAutoPtr.h"
 #include "nsNetError.h"
 #include "nsNetCID.h"
 #include "prnetdb.h"
 #include "prio.h"
 
+using namespace mozilla;
+
 static NS_DEFINE_CID(kSocketTransportServiceCID, NS_SOCKETTRANSPORTSERVICE_CID);
 
 //-----------------------------------------------------------------------------
 
 typedef void (nsServerSocket:: *nsServerSocketFunc)(void);
 
 static nsresult
 PostEvent(nsServerSocket *s, nsServerSocketFunc func)
@@ -66,17 +67,17 @@ PostEvent(nsServerSocket *s, nsServerSoc
   return gSocketTransportService->Dispatch(ev, NS_DISPATCH_NORMAL);
 }
 
 //-----------------------------------------------------------------------------
 // nsServerSocket
 //-----------------------------------------------------------------------------
 
 nsServerSocket::nsServerSocket()
-  : mLock(nsnull)
+  : mLock("nsServerSocket.mLock")
   , mFD(nsnull)
   , mAttached(PR_FALSE)
 {
   // we want to be able to access the STS directly, and it may not have been
   // constructed yet.  the STS constructor sets gSocketTransportService.
   if (!gSocketTransportService)
   {
     // This call can fail if we're offline, for example.
@@ -86,19 +87,16 @@ nsServerSocket::nsServerSocket()
   // make sure the STS sticks around as long as we do
   NS_IF_ADDREF(gSocketTransportService);
 }
 
 nsServerSocket::~nsServerSocket()
 {
   Close(); // just in case :)
 
-  if (mLock)
-    nsAutoLock::DestroyLock(mLock);
-
   // release our reference to the STS
   nsSocketTransportService *serv = gSocketTransportService;
   NS_IF_RELEASE(serv);
 }
 
 void
 nsServerSocket::OnMsgClose()
 {
@@ -241,17 +239,17 @@ nsServerSocket::OnSocketDetached(PRFileD
 
   if (mListener)
   {
     mListener->OnStopListening(this, mCondition);
 
     // need to atomically clear mListener.  see our Close() method.
     nsIServerSocketListener *listener = nsnull;
     {
-      nsAutoLock lock(mLock);
+      MutexAutoLock lock(mLock);
       mListener.swap(listener);
     }
     // XXX we need to proxy the release to the listener's target thread to work
     // around bug 337492.
     if (listener)
       NS_ProxyRelease(mListenerTarget, listener);
   }
 }
@@ -285,23 +283,16 @@ nsServerSocket::Init(PRInt32 aPort, PRBo
   return InitWithAddress(&addr, aBackLog);
 }
 
 NS_IMETHODIMP
 nsServerSocket::InitWithAddress(const PRNetAddr *aAddr, PRInt32 aBackLog)
 {
   NS_ENSURE_TRUE(mFD == nsnull, NS_ERROR_ALREADY_INITIALIZED);
 
-  if (!mLock)
-  {
-    mLock = nsAutoLock::NewLock("nsServerSocket::mLock");
-    if (!mLock)
-      return NS_ERROR_OUT_OF_MEMORY;
-  }
-
   //
   // configure listening socket...
   //
 
   mFD = PR_OpenTCPSocket(aAddr->raw.family);
   if (!mFD)
   {
     NS_WARNING("unable to create server socket");
@@ -348,19 +339,18 @@ nsServerSocket::InitWithAddress(const PR
 fail:
   Close();
   return NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 nsServerSocket::Close()
 {
-  NS_ENSURE_TRUE(mLock, NS_ERROR_NOT_INITIALIZED);
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     // we want to proxy the close operation to the socket thread if a listener
     // has been set.  otherwise, we should just close the socket here...
     if (!mListener)
     {
       if (mFD)
       {
         PR_Close(mFD);
         mFD = nsnull;
@@ -373,17 +363,17 @@ nsServerSocket::Close()
 
 NS_IMETHODIMP
 nsServerSocket::AsyncListen(nsIServerSocketListener *aListener)
 {
   // ensuring mFD implies ensuring mLock
   NS_ENSURE_TRUE(mFD, NS_ERROR_NOT_INITIALIZED);
   NS_ENSURE_TRUE(mListener == nsnull, NS_ERROR_IN_PROGRESS);
   {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     nsresult rv = NS_GetProxyForObject(NS_PROXY_TO_CURRENT_THREAD,
                                        NS_GET_IID(nsIServerSocketListener),
                                        aListener,
                                        NS_PROXY_ASYNC | NS_PROXY_ALWAYS,
                                        getter_AddRefs(mListener));
     if (NS_FAILED(rv))
       return rv;
     mListenerTarget = NS_GetCurrentThread();
--- a/netwerk/base/src/nsServerSocket.h
+++ b/netwerk/base/src/nsServerSocket.h
@@ -35,16 +35,17 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef nsServerSocket_h__
 #define nsServerSocket_h__
 
 #include "nsIServerSocket.h"
 #include "nsSocketTransportService2.h"
+#include "mozilla/Mutex.h"
 
 //-----------------------------------------------------------------------------
 
 class nsServerSocket : public nsASocketHandler
                      , public nsIServerSocket
 {
 public:
   NS_DECL_ISUPPORTS
@@ -62,17 +63,17 @@ public:
 private:
   void OnMsgClose();
   void OnMsgAttach();
   
   // try attaching our socket (mFD) to the STS's poll list.
   nsresult TryAttach();
 
   // lock protects access to mListener; so it is not cleared while being used.
-  PRLock                           *mLock;
+  mozilla::Mutex                    mLock;
   PRFileDesc                       *mFD;
   PRNetAddr                         mAddr;
   nsCOMPtr<nsIServerSocketListener> mListener;
   nsCOMPtr<nsIEventTarget>          mListenerTarget;
   PRBool                            mAttached;
 };
 
 //-----------------------------------------------------------------------------
--- a/netwerk/base/src/nsSocketTransport2.cpp
+++ b/netwerk/base/src/nsSocketTransport2.cpp
@@ -45,17 +45,16 @@
 #include "nsSocketTransport2.h"
 #include "nsAtomicRefcnt.h"
 #include "nsIOService.h"
 #include "nsStreamUtils.h"
 #include "nsNetSegmentUtils.h"
 #include "nsTransportUtils.h"
 #include "nsProxyInfo.h"
 #include "nsNetCID.h"
-#include "nsAutoLock.h"
 #include "nsAutoPtr.h"
 #include "nsCOMPtr.h"
 #include "netCore.h"
 #include "nsInt64.h"
 #include "prmem.h"
 #include "plstr.h"
 #include "prnetdb.h"
 #include "prerror.h"
@@ -70,16 +69,18 @@
 #include "nsIPipe.h"
 #include "nsIProgrammingLanguage.h"
 #include "nsIClassInfoImpl.h"
 
 #if defined(XP_WIN) || defined(MOZ_PLATFORM_MAEMO)
 #include "nsNativeConnectionHelper.h"
 #endif
 
+using namespace mozilla;
+
 //-----------------------------------------------------------------------------
 
 static NS_DEFINE_CID(kSocketProviderServiceCID, NS_SOCKETPROVIDERSERVICE_CID);
 static NS_DEFINE_CID(kDNSServiceCID, NS_DNSSERVICE_CID);
 
 //-----------------------------------------------------------------------------
 
 class nsSocketEvent : public nsRunnable
@@ -232,17 +233,17 @@ nsSocketInputStream::OnSocketReady(nsres
 {
     SOCKET_LOG(("nsSocketInputStream::OnSocketReady [this=%x cond=%x]\n",
         this, condition));
 
     NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
 
     nsCOMPtr<nsIInputStreamCallback> callback;
     {
-        nsAutoLock lock(mTransport->mLock);
+        MutexAutoLock lock(mTransport->mLock);
 
         // update condition, but be careful not to erase an already
         // existing error condition.
         if (NS_SUCCEEDED(mCondition))
             mCondition = condition;
 
         // ignore event if only waiting for closure and not closed.
         if (NS_FAILED(mCondition) || !(mCallbackFlags & WAIT_CLOSURE_ONLY)) {
@@ -285,34 +286,34 @@ NS_IMETHODIMP
 nsSocketInputStream::Available(PRUint32 *avail)
 {
     SOCKET_LOG(("nsSocketInputStream::Available [this=%x]\n", this));
 
     *avail = 0;
 
     PRFileDesc *fd;
     {
-        nsAutoLock lock(mTransport->mLock);
+        MutexAutoLock lock(mTransport->mLock);
 
         if (NS_FAILED(mCondition))
             return mCondition;
 
         fd = mTransport->GetFD_Locked();
         if (!fd)
             return NS_OK;
     }
 
     // cannot hold lock while calling NSPR.  (worried about the fact that PSM
     // synchronously proxies notifications over to the UI thread, which could
     // mistakenly try to re-enter this code.)
     PRInt32 n = PR_Available(fd);
 
     nsresult rv;
     {
-        nsAutoLock lock(mTransport->mLock);
+        MutexAutoLock lock(mTransport->mLock);
 
         mTransport->ReleaseFD_Locked(fd);
 
         if (n >= 0)
             *avail = n;
         else {
             PRErrorCode code = PR_GetError();
             if (code == PR_WOULD_BLOCK_ERROR)
@@ -330,17 +331,17 @@ NS_IMETHODIMP
 nsSocketInputStream::Read(char *buf, PRUint32 count, PRUint32 *countRead)
 {
     SOCKET_LOG(("nsSocketInputStream::Read [this=%x count=%u]\n", this, count));
 
     *countRead = 0;
 
     PRFileDesc *fd;
     {
-        nsAutoLock lock(mTransport->mLock);
+        MutexAutoLock lock(mTransport->mLock);
 
         if (NS_FAILED(mCondition))
             return (mCondition == NS_BASE_STREAM_CLOSED) ? NS_OK : mCondition;
 
         fd = mTransport->GetFD_Locked();
         if (!fd)
             return NS_BASE_STREAM_WOULD_BLOCK;
     }
@@ -351,17 +352,17 @@ nsSocketInputStream::Read(char *buf, PRU
     // synchronously proxies notifications over to the UI thread, which could
     // mistakenly try to re-enter this code.)
     PRInt32 n = PR_Read(fd, buf, count);
 
     SOCKET_LOG(("  PR_Read returned [n=%d]\n", n));
 
     nsresult rv;
     {
-        nsAutoLock lock(mTransport->mLock);
+        MutexAutoLock lock(mTransport->mLock);
 
 #ifdef ENABLE_SOCKET_TRACING
         if (n > 0)
             mTransport->TraceInBuf(buf, n);
 #endif
 
         mTransport->ReleaseFD_Locked(fd);
 
@@ -404,17 +405,17 @@ NS_IMETHODIMP
 nsSocketInputStream::CloseWithStatus(nsresult reason)
 {
     SOCKET_LOG(("nsSocketInputStream::CloseWithStatus [this=%x reason=%x]\n", this, reason));
 
     // may be called from any thread
  
     nsresult rv;
     {
-        nsAutoLock lock(mTransport->mLock);
+        MutexAutoLock lock(mTransport->mLock);
 
         if (NS_SUCCEEDED(mCondition))
             rv = mCondition = reason;
         else
             rv = NS_OK;
     }
     if (NS_FAILED(rv))
         mTransport->OnInputClosed(rv);
@@ -429,17 +430,17 @@ nsSocketInputStream::AsyncWait(nsIInputS
 {
     SOCKET_LOG(("nsSocketInputStream::AsyncWait [this=%x]\n", this));
 
     // This variable will be non-null when we want to call the callback
     // directly from this function, but outside the lock.
     // (different from callback when target is not null)
     nsCOMPtr<nsIInputStreamCallback> directCallback;
     {
-        nsAutoLock lock(mTransport->mLock);
+        MutexAutoLock lock(mTransport->mLock);
 
         if (callback && target) {
             //
             // build event proxy
             //
             // failure to create an event proxy (most likely out of memory)
             // shouldn't alter the state of the transport.
             //
@@ -491,17 +492,17 @@ nsSocketOutputStream::OnSocketReady(nsre
 {
     SOCKET_LOG(("nsSocketOutputStream::OnSocketReady [this=%x cond=%x]\n",
         this, condition));
 
     NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
 
     nsCOMPtr<nsIOutputStreamCallback> callback;
     {
-        nsAutoLock lock(mTransport->mLock);
+        MutexAutoLock lock(mTransport->mLock);
 
         // update condition, but be careful not to erase an already
         // existing error condition.
         if (NS_SUCCEEDED(mCondition))
             mCondition = condition;
 
         // ignore event if only waiting for closure and not closed.
         if (NS_FAILED(mCondition) || !(mCallbackFlags & WAIT_CLOSURE_ONLY)) {
@@ -553,17 +554,17 @@ nsSocketOutputStream::Write(const char *
 
     *countWritten = 0;
 
     if (count == 0)
         return NS_OK;
 
     PRFileDesc *fd;
     {
-        nsAutoLock lock(mTransport->mLock);
+        MutexAutoLock lock(mTransport->mLock);
 
         if (NS_FAILED(mCondition))
             return mCondition;
         
         fd = mTransport->GetFD_Locked();
         if (!fd)
             return NS_BASE_STREAM_WOULD_BLOCK;
     }
@@ -575,17 +576,17 @@ nsSocketOutputStream::Write(const char *
     // mistakenly try to re-enter this code.)
     PRInt32 n = PR_Write(fd, buf, count);
 
     SOCKET_LOG(("  PR_Write returned [n=%d]\n", n));
     NS_ASSERTION(n != 0, "unexpected return value");
 
     nsresult rv;
     {
-        nsAutoLock lock(mTransport->mLock);
+        MutexAutoLock lock(mTransport->mLock);
 
 #ifdef ENABLE_SOCKET_TRACING
     if (n > 0)
         mTransport->TraceOutBuf(buf, n);
 #endif
 
         mTransport->ReleaseFD_Locked(fd);
 
@@ -646,17 +647,17 @@ NS_IMETHODIMP
 nsSocketOutputStream::CloseWithStatus(nsresult reason)
 {
     SOCKET_LOG(("nsSocketOutputStream::CloseWithStatus [this=%x reason=%x]\n", this, reason));
 
     // may be called from any thread
  
     nsresult rv;
     {
-        nsAutoLock lock(mTransport->mLock);
+        MutexAutoLock lock(mTransport->mLock);
 
         if (NS_SUCCEEDED(mCondition))
             rv = mCondition = reason;
         else
             rv = NS_OK;
     }
     if (NS_FAILED(rv))
         mTransport->OnOutputClosed(rv);
@@ -667,17 +668,17 @@ NS_IMETHODIMP
 nsSocketOutputStream::AsyncWait(nsIOutputStreamCallback *callback,
                                 PRUint32 flags,
                                 PRUint32 amount,
                                 nsIEventTarget *target)
 {
     SOCKET_LOG(("nsSocketOutputStream::AsyncWait [this=%x]\n", this));
 
     {
-        nsAutoLock lock(mTransport->mLock);
+        MutexAutoLock lock(mTransport->mLock);
 
         if (callback && target) {
             //
             // build event proxy
             //
             // failure to create an event proxy (most likely out of memory)
             // shouldn't alter the state of the transport.
             //
@@ -708,17 +709,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(nsAutoLock::NewLock("nsSocketTransport::mLock"))
+    , mLock("nsSocketTransport.mLock")
     , mFD(nsnull)
     , mFDref(0)
     , mFDconnected(PR_FALSE)
     , mInput(this)
     , mOutput(this)
     , mQoSBits(0x00)
 {
     SOCKET_LOG(("creating nsSocketTransport @%x\n", this));
@@ -735,32 +736,26 @@ nsSocketTransport::~nsSocketTransport()
 
     // cleanup socket type info
     if (mTypes) {
         PRUint32 i;
         for (i=0; i<mTypeCount; ++i)
             PL_strfree(mTypes[i]);
         free(mTypes);
     }
-
-    if (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,
                         nsIProxyInfo *givenProxyInfo)
 {
-    if (!mLock)
-        return NS_ERROR_OUT_OF_MEMORY;
-
     nsCOMPtr<nsProxyInfo> proxyInfo;
     if (givenProxyInfo) {
         proxyInfo = do_QueryInterface(givenProxyInfo);
         NS_ENSURE_ARG(proxyInfo);
     }
 
     // init socket type info
 
@@ -832,19 +827,16 @@ nsSocketTransport::Init(const char **typ
     }
 
     return NS_OK;
 }
 
 nsresult
 nsSocketTransport::InitWithConnectedSocket(PRFileDesc *fd, const PRNetAddr *addr)
 {
-    if (!mLock)
-        return NS_ERROR_OUT_OF_MEMORY;
-
     NS_ASSERTION(!mFD, "already initialized");
 
     char buf[64];
     PR_NetAddrToString(addr, buf, sizeof(buf));
     mHost.Assign(buf);
 
     PRUint16 port;
     if (addr->raw.family == PR_AF_INET)
@@ -892,17 +884,17 @@ nsSocketTransport::PostEvent(PRUint32 ty
 void
 nsSocketTransport::SendStatus(nsresult status)
 {
     SOCKET_LOG(("nsSocketTransport::SendStatus [this=%x status=%x]\n", this, status));
 
     nsCOMPtr<nsITransportEventSink> sink;
     PRUint64 progress;
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
         sink = mEventSink;
         switch (status) {
         case STATUS_SENDING_TO:
             progress = mOutput.ByteCount();
             break;
         case STATUS_RECEIVING_FROM:
             progress = mInput.ByteCount();
             break;
@@ -1035,17 +1027,17 @@ nsSocketTransport::BuildSocket(PRFileDes
                 break;
 
             // if the service was ssl or starttls, we want to hold onto the socket info
             PRBool isSSL = (strcmp(mTypes[i], "ssl") == 0);
             if (isSSL || (strcmp(mTypes[i], "starttls") == 0)) {
                 // remember security info and give notification callbacks to PSM...
                 nsCOMPtr<nsIInterfaceRequestor> callbacks;
                 {
-                    nsAutoLock lock(mLock);
+                    MutexAutoLock lock(mLock);
                     mSecInfo = secinfo;
                     callbacks = mCallbacks;
                     SOCKET_LOG(("  [secinfo=%x callbacks=%x]\n", mSecInfo.get(), mCallbacks.get()));
                 }
                 // don't call into PSM while holding mLock!!
                 nsCOMPtr<nsISSLSocketControl> secCtrl(do_QueryInterface(secinfo));
                 if (secCtrl)
                     secCtrl->SetNotificationCallbacks(callbacks);
@@ -1154,17 +1146,17 @@ nsSocketTransport::InitiateSocket()
         PR_Close(fd);
         return rv;
     }
     mAttached = PR_TRUE;
 
     // assign mFD so that we can properly handle OnSocketDetached before we've
     // established a connection.
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
         mFD = fd;
         mFDref = 1;
         mFDconnected = PR_FALSE;
     }
 
     SOCKET_LOG(("  advancing to STATE_CONNECTING\n"));
     mState = STATE_CONNECTING;
     mPollTimeout = mTimeouts[TIMEOUT_CONNECT];
@@ -1368,17 +1360,17 @@ nsSocketTransport::OnSocketConnected()
 
     mPollFlags = (PR_POLL_READ | PR_POLL_WRITE | PR_POLL_EXCEPT);
     mPollTimeout = mTimeouts[TIMEOUT_READ_WRITE];
     mState = STATE_TRANSFERRING;
 
     // assign mFD (must do this within the transport lock), but take care not
     // to trample over mFDref if mFD is already set.
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
         NS_ASSERTION(mFD, "no socket");
         NS_ASSERTION(mFDref == 1, "wrong socket ref count");
         mFDconnected = PR_TRUE;
     }
 
     SendStatus(STATUS_CONNECTED_TO);
 }
 
@@ -1635,17 +1627,17 @@ nsSocketTransport::OnSocketDetached(PRFi
     // We should be careful not to release mEventSink and mCallbacks while
     // we're locked, because releasing it might require acquiring the lock
     // again, so we just null out mEventSink and mCallbacks while we're
     // holding the lock, and let the stack based objects' destuctors take
     // care of destroying it if needed.
     nsCOMPtr<nsIInterfaceRequestor> ourCallbacks;
     nsCOMPtr<nsITransportEventSink> ourEventSink;
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
         if (mFD) {
             ReleaseFD_Locked(mFD);
             // flag mFD as unusable; this prevents other consumers from 
             // acquiring a reference to mFD.
             mFDconnected = PR_FALSE;
         }
 
         // We must release mCallbacks and mEventSink to avoid memory leak
@@ -1776,33 +1768,33 @@ nsSocketTransport::Close(nsresult reason
     mInput.CloseWithStatus(reason);
     mOutput.CloseWithStatus(reason);
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsSocketTransport::GetSecurityInfo(nsISupports **secinfo)
 {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     NS_IF_ADDREF(*secinfo = mSecInfo);
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsSocketTransport::GetSecurityCallbacks(nsIInterfaceRequestor **callbacks)
 {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     NS_IF_ADDREF(*callbacks = mCallbacks);
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsSocketTransport::SetSecurityCallbacks(nsIInterfaceRequestor *callbacks)
 {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     mCallbacks = callbacks;
     // XXX should we tell PSM about this?
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsSocketTransport::SetEventSink(nsITransportEventSink *sink,
                                 nsIEventTarget *target)
@@ -1811,46 +1803,46 @@ nsSocketTransport::SetEventSink(nsITrans
     if (target) {
         nsresult rv = net_NewTransportEventSinkProxy(getter_AddRefs(temp),
                                                      sink, target);
         if (NS_FAILED(rv))
             return rv;
         sink = temp.get();
     }
 
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     mEventSink = sink;
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsSocketTransport::IsAlive(PRBool *result)
 {
     *result = PR_FALSE;
 
     PRFileDesc *fd;
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
         if (NS_FAILED(mCondition))
             return NS_OK;
         fd = GetFD_Locked();
         if (!fd)
             return NS_OK;
     }
 
     // XXX do some idle-time based checks??
 
     char c;
     PRInt32 rval = PR_Recv(fd, &c, 1, PR_MSG_PEEK, 0);
 
     if ((rval > 0) || (rval < 0 && PR_GetError() == PR_WOULD_BLOCK_ERROR))
         *result = PR_TRUE;
 
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
         ReleaseFD_Locked(fd);
     }
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsSocketTransport::GetHost(nsACString &host)
 {
@@ -1883,28 +1875,28 @@ NS_IMETHODIMP
 nsSocketTransport::GetSelfAddr(PRNetAddr *addr)
 {
     // we must not call any PR methods on our file descriptor
     // while holding mLock since those methods might re-enter
     // socket transport code.
 
     PRFileDesc *fd;
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
         fd = GetFD_Locked();
     }
 
     if (!fd)
         return NS_ERROR_NOT_CONNECTED;
 
     nsresult rv =
         (PR_GetSockName(fd, addr) == PR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
         ReleaseFD_Locked(fd);
     }
 
     return rv;
 }
 
 NS_IMETHODIMP
 nsSocketTransport::GetTimeout(PRUint32 type, PRUint32 *value)
--- a/netwerk/base/src/nsSocketTransport2.h
+++ b/netwerk/base/src/nsSocketTransport2.h
@@ -37,16 +37,17 @@
 
 #ifndef nsSocketTransport2_h__
 #define nsSocketTransport2_h__
 
 #ifdef DEBUG_darinf
 #define ENABLE_SOCKET_TRACING
 #endif
 
+#include "mozilla/Mutex.h"
 #include "nsSocketTransportService2.h"
 #include "nsString.h"
 #include "nsCOMPtr.h"
 #include "nsInt64.h"
 
 #include "nsISocketTransport.h"
 #include "nsIInterfaceRequestor.h"
 #include "nsIAsyncInputStream.h"
@@ -129,16 +130,18 @@ private:
 
 //-----------------------------------------------------------------------------
 
 class nsSocketTransport : public nsASocketHandler
                         , public nsISocketTransport
                         , public nsIDNSListener
                         , public nsIClassInfo
 {
+    typedef mozilla::Mutex Mutex;
+
 public:
     NS_DECL_ISUPPORTS
     NS_DECL_NSITRANSPORT
     NS_DECL_NSISOCKETTRANSPORT
     NS_DECL_NSIDNSLISTENER
     NS_DECL_NSICLASSINFO
 
     nsSocketTransport();
@@ -249,17 +252,17 @@ private:
 
     // called when the socket is connected
     void OnSocketConnected();
 
     //-------------------------------------------------------------------------
     // socket input/output objects.  these may be accessed on any thread with
     // the exception of some specific methods (XXX).
 
-    PRLock     *mLock;  // protects members in this section
+    Mutex       mLock;  // protects members in this section
     PRFileDesc *mFD;
     nsrefcnt    mFDref;       // mFD is closed when mFDref goes to zero.
     PRBool      mFDconnected; // mFD is available to consumer when TRUE.
 
     nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
     nsCOMPtr<nsITransportEventSink> mEventSink;
     nsCOMPtr<nsISupports>           mSecInfo;
 
--- a/netwerk/base/src/nsSocketTransportService2.cpp
+++ b/netwerk/base/src/nsSocketTransportService2.cpp
@@ -38,46 +38,46 @@
 
 #ifdef MOZ_LOGGING
 #define FORCE_PR_LOG
 #endif
 
 #include "nsSocketTransportService2.h"
 #include "nsSocketTransport2.h"
 #include "nsReadableUtils.h"
-#include "nsAutoLock.h"
 #include "nsNetError.h"
 #include "prnetdb.h"
-#include "prlock.h"
 #include "prerror.h"
 #include "plstr.h"
 #include "nsIPrefService.h"
 #include "nsIPrefBranch2.h"
 #include "nsServiceManagerUtils.h"
 #include "nsIOService.h"
 
 #include "mozilla/FunctionTimer.h"
 
+using namespace mozilla;
+
 #if defined(PR_LOGGING)
 PRLogModuleInfo *gSocketTransportLog = nsnull;
 #endif
 
 nsSocketTransportService *gSocketTransportService = nsnull;
 PRThread                 *gSocketThread           = nsnull;
 
 #define SEND_BUFFER_PREF "network.tcp.sendbuffer"
 
 //-----------------------------------------------------------------------------
 // ctor/dtor (called on the main/UI thread by the service manager)
 
 nsSocketTransportService::nsSocketTransportService()
     : mThread(nsnull)
     , mThreadEvent(nsnull)
     , mAutodialEnabled(PR_FALSE)
-    , mLock(nsAutoLock::NewLock("nsSocketTransportService::mLock"))
+    , mLock("nsSocketTransportService::mLock")
     , mInitialized(PR_FALSE)
     , mShuttingDown(PR_FALSE)
     , mActiveCount(0)
     , mIdleCount(0)
     , mSendBufferSize(0)
 {
 #if defined(PR_LOGGING)
     gSocketTransportLog = PR_NewLogModule("nsSocketTransport");
@@ -88,33 +88,30 @@ nsSocketTransportService::nsSocketTransp
     NS_ASSERTION(!gSocketTransportService, "must not instantiate twice");
     gSocketTransportService = this;
 }
 
 nsSocketTransportService::~nsSocketTransportService()
 {
     NS_ASSERTION(NS_IsMainThread(), "wrong thread");
     NS_ASSERTION(!mInitialized, "not shutdown properly");
-
-    if (mLock)
-        nsAutoLock::DestroyLock(mLock);
     
     if (mThreadEvent)
         PR_DestroyPollableEvent(mThreadEvent);
 
     gSocketTransportService = nsnull;
 }
 
 //-----------------------------------------------------------------------------
 // event queue (any thread)
 
 already_AddRefed<nsIThread>
 nsSocketTransportService::GetThreadSafely()
 {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     nsIThread* result = mThread;
     NS_IF_ADDREF(result);
     return result;
 }
 
 NS_IMETHODIMP
 nsSocketTransportService::Dispatch(nsIRunnable *event, PRUint32 flags)
 {
@@ -378,18 +375,16 @@ NS_IMPL_THREADSAFE_ISUPPORTS6(nsSocketTr
                               nsIObserver)
 
 // called from main thread only
 NS_IMETHODIMP
 nsSocketTransportService::Init()
 {
     NS_TIME_FUNCTION;
 
-    NS_ENSURE_TRUE(mLock, NS_ERROR_OUT_OF_MEMORY);
-
     if (!NS_IsMainThread()) {
         NS_ERROR("wrong thread");
         return NS_ERROR_UNEXPECTED;
     }
 
     if (mInitialized)
         return NS_OK;
 
@@ -420,17 +415,17 @@ nsSocketTransportService::Init()
     
     NS_TIME_FUNCTION_MARK("Created thread");
 
     nsCOMPtr<nsIThread> thread;
     nsresult rv = NS_NewThread(getter_AddRefs(thread), this);
     if (NS_FAILED(rv)) return rv;
     
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
         // Install our mThread, protecting against concurrent readers
         thread.swap(mThread);
     }
 
     nsCOMPtr<nsIPrefBranch2> tmpPrefService = do_GetService(NS_PREFSERVICE_CONTRACTID);
     if (tmpPrefService) 
         tmpPrefService->AddObserver(SEND_BUFFER_PREF, this, PR_FALSE);
     UpdatePrefs();
@@ -451,30 +446,30 @@ nsSocketTransportService::Shutdown()
 
     if (!mInitialized)
         return NS_OK;
 
     if (mShuttingDown)
         return NS_ERROR_UNEXPECTED;
 
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
 
         // signal the socket thread to shutdown
         mShuttingDown = PR_TRUE;
 
         if (mThreadEvent)
             PR_SetPollableEvent(mThreadEvent);
         // else wait for Poll timeout
     }
 
     // join with thread
     mThread->Shutdown();
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
         // Drop our reference to mThread and make sure that any concurrent
         // readers are excluded
         mThread = nsnull;
     }
 
     nsCOMPtr<nsIPrefBranch2> tmpPrefService = do_GetService(NS_PREFSERVICE_CONTRACTID);
     if (tmpPrefService) 
         tmpPrefService->RemoveObserver(SEND_BUFFER_PREF, this);
@@ -523,17 +518,17 @@ nsSocketTransportService::SetAutodialEna
 {
     mAutodialEnabled = value;
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsSocketTransportService::OnDispatchedEvent(nsIThreadInternal *thread)
 {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     if (mThreadEvent)
         PR_SetPollableEvent(mThreadEvent);
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsSocketTransportService::OnProcessNextEvent(nsIThreadInternal *thread,
                                              PRBool mayWait, PRUint32 depth)
@@ -580,17 +575,17 @@ nsSocketTransportService::Run()
     threadInt->SetObserver(this);
 
     for (;;) {
         // process all pending events
         NS_ProcessPendingEvents(thread);
 
         // now that our event queue is empty, check to see if we should exit
         {
-            nsAutoLock lock(mLock);
+            MutexAutoLock lock(mLock);
             if (mShuttingDown)
                 break;
         }
 
         // wait for and process the next pending event
         NS_ProcessNextEvent(thread);
     }
 
@@ -715,17 +710,17 @@ nsSocketTransportService::DoPollIteratio
             if (PR_WaitForPollableEvent(mThreadEvent) != PR_SUCCESS) {
                 // On Windows, the TCP loopback connection in the
                 // pollable event may become broken when a laptop
                 // switches between wired and wireless networks or
                 // wakes up from hibernation.  We try to create a
                 // new pollable event.  If that fails, we fall back
                 // on "busy wait".
                 {
-                    nsAutoLock lock(mLock);
+                    MutexAutoLock lock(mLock);
                     PR_DestroyPollableEvent(mThreadEvent);
                     mThreadEvent = PR_NewPollableEvent();
                 }
                 if (!mThreadEvent) {
                     NS_WARNING("running socket transport thread without "
                                "a pollable event");
                     SOCKET_LOG(("running socket transport thread without "
                          "a pollable event"));
--- a/netwerk/base/src/nsSocketTransportService2.h
+++ b/netwerk/base/src/nsSocketTransportService2.h
@@ -45,16 +45,17 @@
 #include "nsEventQueue.h"
 #include "nsCOMPtr.h"
 #include "pldhash.h"
 #include "prinrval.h"
 #include "prlog.h"
 #include "prio.h"
 #include "nsASocketHandler.h"
 #include "nsIObserver.h"
+#include "mozilla/Mutex.h"
 
 //-----------------------------------------------------------------------------
 
 #if defined(PR_LOGGING)
 //
 // set NSPR_LOG_MODULES=nsSocketTransport:5
 //
 extern PRLogModuleInfo *gSocketTransportLog;
@@ -70,16 +71,18 @@ extern PRLogModuleInfo *gSocketTransport
 //-----------------------------------------------------------------------------
 
 class nsSocketTransportService : public nsPISocketTransportService
                                , public nsIEventTarget
                                , public nsIThreadObserver
                                , public nsIRunnable
                                , public nsIObserver
 {
+    typedef mozilla::Mutex Mutex;
+
 public:
     NS_DECL_ISUPPORTS
     NS_DECL_NSPISOCKETTRANSPORTSERVICE
     NS_DECL_NSISOCKETTRANSPORTSERVICE
     NS_DECL_NSIEVENTTARGET
     NS_DECL_NSITHREADOBSERVER
     NS_DECL_NSIRUNNABLE
     NS_DECL_NSIOBSERVER 
@@ -121,17 +124,17 @@ private:
 
     // Returns mThread, protecting the get-and-addref with mLock
     already_AddRefed<nsIThread> GetThreadSafely();
 
     //-------------------------------------------------------------------------
     // initialization and shutdown (any thread)
     //-------------------------------------------------------------------------
 
-    PRLock       *mLock;
+    Mutex         mLock;
     PRPackedBool  mInitialized;
     PRPackedBool  mShuttingDown;
                             // indicates whether we are currently in the
                             // process of shutting down
 
     //-------------------------------------------------------------------------
     // socket lists (socket thread only)
     //
--- a/netwerk/base/src/nsStreamTransportService.cpp
+++ b/netwerk/base/src/nsStreamTransportService.cpp
@@ -33,17 +33,16 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsStreamTransportService.h"
 #include "nsXPCOMCIDInternal.h"
 #include "nsNetSegmentUtils.h"
-#include "nsAutoLock.h"
 #include "nsInt64.h"
 #include "nsTransportUtils.h"
 #include "nsStreamUtils.h"
 #include "nsNetError.h"
 #include "nsNetCID.h"
 
 #include "nsIServiceManager.h"
 #include "nsIAsyncInputStream.h"
--- a/netwerk/base/src/nsTransportUtils.cpp
+++ b/netwerk/base/src/nsTransportUtils.cpp
@@ -29,59 +29,58 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
+#include "mozilla/Mutex.h"
 #include "nsTransportUtils.h"
 #include "nsITransport.h"
 #include "nsProxyRelease.h"
 #include "nsThreadUtils.h"
-#include "nsAutoLock.h"
 #include "nsAutoPtr.h"
 #include "nsCOMPtr.h"
 
+using namespace mozilla;
+
 //-----------------------------------------------------------------------------
 
 class nsTransportStatusEvent;
 
 class nsTransportEventSinkProxy : public nsITransportEventSink
 {
 public:
     NS_DECL_ISUPPORTS
     NS_DECL_NSITRANSPORTEVENTSINK
 
     nsTransportEventSinkProxy(nsITransportEventSink *sink,
                               nsIEventTarget *target,
                               PRBool coalesceAll)
         : mSink(sink)
         , mTarget(target)
-        , mLock(nsAutoLock::NewLock("nsTransportEventSinkProxy::mLock"))
+        , mLock("nsTransportEventSinkProxy.mLock")
         , mLastEvent(nsnull)
         , mCoalesceAll(coalesceAll)
     {
         NS_ADDREF(mSink);
     }
 
     virtual ~nsTransportEventSinkProxy()
     {
-        if (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;
-    PRLock                          *mLock;
+    Mutex                            mLock;
     nsTransportStatusEvent          *mLastEvent;
     PRBool                           mCoalesceAll;
 };
 
 class nsTransportStatusEvent : public nsRunnable
 {
 public:
     nsTransportStatusEvent(nsTransportEventSinkProxy *proxy,
@@ -98,17 +97,17 @@ public:
 
     ~nsTransportStatusEvent() {}
 
     NS_IMETHOD Run()
     {
         // since this event is being handled, we need to clear the proxy's ref.
         // if not coalescing all, then last event may not equal self!
         {
-            nsAutoLock lock(mProxy->mLock);
+            MutexAutoLock lock(mProxy->mLock);
             if (mProxy->mLastEvent == this)
                 mProxy->mLastEvent = nsnull;
         }
 
         mProxy->mSink->OnTransportStatus(mTransport, mStatus, mProgress,
                                          mProgressMax);
         return nsnull;
     }
@@ -128,17 +127,17 @@ NS_IMETHODIMP
 nsTransportEventSinkProxy::OnTransportStatus(nsITransport *transport,
                                              nsresult status,
                                              PRUint64 progress,
                                              PRUint64 progressMax)
 {
     nsresult rv = NS_OK;
     nsRefPtr<nsTransportStatusEvent> event;
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
 
         // try to coalesce events! ;-)
         if (mLastEvent && (mCoalesceAll || mLastEvent->mStatus == status)) {
             mLastEvent->mStatus = status;
             mLastEvent->mProgress = progress;
             mLastEvent->mProgressMax = progressMax;
         }
         else {
@@ -149,17 +148,17 @@ nsTransportEventSinkProxy::OnTransportSt
             mLastEvent = event;  // weak ref
         }
     }
     if (event) {
         rv = mTarget->Dispatch(event, NS_DISPATCH_NORMAL);
         if (NS_FAILED(rv)) {
             NS_WARNING("unable to post transport status event");
 
-            nsAutoLock lock(mLock); // cleanup.. don't reference anymore!
+            MutexAutoLock lock(mLock); // cleanup.. don't reference anymore!
             mLastEvent = nsnull;
         }
     }
     return rv;
 }
 
 //-----------------------------------------------------------------------------
 
--- a/netwerk/build/nsNetModule.cpp
+++ b/netwerk/build/nsNetModule.cpp
@@ -249,17 +249,17 @@ NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsFt
 #include "nsHttpActivityDistributor.h"
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsHttpNTLMAuth)
 #undef LOG
 #undef LOG_ENABLED
 NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsHttpHandler, Init)
 NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsHttpsHandler, Init)
 NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsHttpAuthManager, Init)
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsHttpChannelAuthProvider)
-NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsHttpActivityDistributor, Init)
+NS_GENERIC_FACTORY_CONSTRUCTOR(nsHttpActivityDistributor)
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsHttpBasicAuth)
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsHttpDigestAuth)
 #endif // !NECKO_PROTOCOL_http
 
 #ifdef NECKO_PROTOCOL_res
 // resource
 #include "nsResProtocolHandler.h"
 NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsResProtocolHandler, Init)
--- a/netwerk/cache/nsCacheRequest.h
+++ b/netwerk/cache/nsCacheRequest.h
@@ -37,58 +37,62 @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef _nsCacheRequest_h_
 #define _nsCacheRequest_h_
 
 #include "nspr.h"
+#include "mozilla/CondVar.h"
+#include "mozilla/Mutex.h"
 #include "nsCOMPtr.h"
 #include "nsICache.h"
 #include "nsICacheListener.h"
 #include "nsCacheSession.h"
 #include "nsCacheService.h"
 
 
 class nsCacheRequest : public PRCList
 {
+    typedef mozilla::CondVar CondVar;
+    typedef mozilla::MutexAutoLock MutexAutoLock;
+    typedef mozilla::Mutex Mutex;
+
 private:
     friend class nsCacheService;
     friend class nsCacheEntry;
     friend class nsProcessRequestEvent;
 
     nsCacheRequest( nsCString *           key, 
                     nsICacheListener *    listener,
                     nsCacheAccessMode     accessRequested,
                     PRBool                blockingMode,
                     nsCacheSession *      session)
         : mKey(key),
           mInfo(0),
           mListener(listener),
-          mLock(nsnull),
-          mCondVar(nsnull)
+          mLock("nsCacheRequest.mLock"),
+          mCondVar(mLock, "nsCacheRequest.mCondVar")
     {
         MOZ_COUNT_CTOR(nsCacheRequest);
         PR_INIT_CLIST(this);
         SetAccessRequested(accessRequested);
         SetStoragePolicy(session->StoragePolicy());
         if (session->IsStreamBased())             MarkStreamBased();
         if (session->WillDoomEntriesIfExpired())  MarkDoomEntriesIfExpired();
         if (blockingMode == nsICache::BLOCKING)    MarkBlockingMode();
         MarkWaitingForValidation();
         NS_IF_ADDREF(mListener);
     }
     
     ~nsCacheRequest()
     {
         MOZ_COUNT_DTOR(nsCacheRequest);
         delete mKey;
-        if (mLock)    PR_DestroyLock(mLock);
-        if (mCondVar) PR_DestroyCondVar(mCondVar);
         NS_ASSERTION(PR_CLIST_IS_EMPTY(this), "request still on a list");
 
         if (mListener)
             nsCacheService::ReleaseObject_Locked(mListener, mThread);
     }
     
     /**
      * Simple Accessors
@@ -146,56 +150,36 @@ private:
 
     nsresult
     WaitForValidation(void)
     {
         if (!WaitingForValidation()) {   // flag already cleared
             MarkWaitingForValidation();  // set up for next time
             return NS_OK;                // early exit;
         }
-
-        if (!mLock) {
-            mLock = PR_NewLock();
-            if (!mLock) return NS_ERROR_OUT_OF_MEMORY;
-
-            NS_ASSERTION(!mCondVar,"we have mCondVar, but didn't have mLock?");
-            mCondVar = PR_NewCondVar(mLock);
-            if (!mCondVar) {
-                PR_DestroyLock(mLock);
-                return NS_ERROR_OUT_OF_MEMORY;
+        {
+            MutexAutoLock lock(mLock);
+            while (WaitingForValidation()) {
+                mCondVar.Wait();
             }
-        }
-        PRStatus status = PR_SUCCESS;
-        PR_Lock(mLock);
-        while (WaitingForValidation() && (status == PR_SUCCESS) ) {
-            status = PR_WaitCondVar(mCondVar, PR_INTERVAL_NO_TIMEOUT);
-        }
-        MarkWaitingForValidation();  // set up for next time
-        PR_Unlock(mLock);
-        
-        NS_ASSERTION(status == PR_SUCCESS, "PR_WaitCondVar() returned PR_FAILURE?");
-        if (status == PR_FAILURE)
-            return NS_ERROR_UNEXPECTED;
-
+            MarkWaitingForValidation();  // set up for next time
+        }       
         return NS_OK;
     }
 
     void WakeUp(void) {
         DoneWaitingForValidation();
-        if (mLock) {
-        PR_Lock(mLock);
-        PR_NotifyCondVar(mCondVar);
-        PR_Unlock(mLock);
-        }
+        MutexAutoLock lock(mLock);
+        mCondVar.Notify();
     }
 
     /**
      * Data members
      */
     nsCString *                mKey;
     PRUint32                   mInfo;
     nsICacheListener *         mListener;  // strong ref
     nsCOMPtr<nsIThread>        mThread;
-    PRLock *                   mLock;
-    PRCondVar *                mCondVar;
+    Mutex                      mLock;
+    CondVar                    mCondVar;
 };
 
 #endif // _nsCacheRequest_h_
--- a/netwerk/cache/nsCacheService.cpp
+++ b/netwerk/cache/nsCacheService.cpp
@@ -75,16 +75,18 @@
 #include "mozilla/Services.h"
 
 #include "mozilla/FunctionTimer.h"
 
 #ifdef MOZ_IPC
 #include "mozilla/net/NeckoCommon.h"
 #endif
 
+using namespace mozilla;
+
 /******************************************************************************
  * nsCacheProfilePrefObserver
  *****************************************************************************/
 #ifdef XP_MAC
 #pragma mark nsCacheProfilePrefObserver
 #endif
 
 #define DISK_CACHE_ENABLE_PREF      "browser.cache.disk.enable"
@@ -270,22 +272,21 @@ private:
 
 class nsBlockOnCacheThreadEvent : public nsRunnable {
 public:
     nsBlockOnCacheThreadEvent()
     {
     }
     NS_IMETHOD Run()
     {
-        mozilla::MonitorAutoEnter
-            autoMonitor(nsCacheService::gService->mMonitor);
+        nsCacheServiceAutoLock autoLock;
 #ifdef PR_LOGGING
         CACHE_LOG_DEBUG(("nsBlockOnCacheThreadEvent [%p]\n", this));
 #endif
-        autoMonitor.Notify();
+        nsCacheService::gService->mCondVar.Notify();
         return NS_OK;
     }
 };
 
 
 nsresult
 nsCacheProfilePrefObserver::Install()
 {
@@ -804,36 +805,31 @@ nsCacheService::DispatchToCacheIOThread(
 {
     if (!gService->mCacheIOThread) return NS_ERROR_NOT_AVAILABLE;
     return gService->mCacheIOThread->Dispatch(event, NS_DISPATCH_NORMAL);
 }
 
 nsresult
 nsCacheService::SyncWithCacheIOThread()
 {
-    NS_ASSERTION(gService->mLockedThread == PR_GetCurrentThread(),
-                 "not holding cache-lock");
+    gService->mLock.AssertCurrentThreadOwns();
     if (!gService->mCacheIOThread) return NS_ERROR_NOT_AVAILABLE;
 
-    mozilla::MonitorAutoEnter autoMonitor(gService->mMonitor);
-
     nsCOMPtr<nsIRunnable> event = new nsBlockOnCacheThreadEvent();
 
     // dispatch event - it will notify the monitor when it's done
     nsresult rv =
         gService->mCacheIOThread->Dispatch(event, NS_DISPATCH_NORMAL);
     if (NS_FAILED(rv)) {
         NS_WARNING("Failed dispatching block-event");
         return NS_ERROR_UNEXPECTED;
     }
 
-    Unlock();
     // wait until notified, then return
-    rv = autoMonitor.Wait();
-    Lock();
+    rv = gService->mCondVar.Wait();
 
     return rv;
 }
 
 
 PRBool
 nsCacheProfilePrefObserver::DiskCacheEnabled()
 {
@@ -980,18 +976,18 @@ private:
 #pragma mark nsCacheService
 #endif
 
 nsCacheService *   nsCacheService::gService = nsnull;
 
 NS_IMPL_THREADSAFE_ISUPPORTS1(nsCacheService, nsICacheService)
 
 nsCacheService::nsCacheService()
-    : mLock(nsnull),
-      mMonitor("block-on-cache-monitor"),
+    : mLock("nsCacheService.mLock"),
+      mCondVar(mLock, "nsCacheService.mCondVar"),
       mInitialized(PR_FALSE),
       mEnableMemoryDevice(PR_TRUE),
       mEnableDiskDevice(PR_TRUE),
       mMemoryDevice(nsnull),
       mDiskDevice(nsnull),
       mOfflineDevice(nsnull),
       mTotalEntries(0),
       mCacheHits(0),
@@ -1002,31 +998,23 @@ nsCacheService::nsCacheService()
       mDeactivateFailures(0),
       mDeactivatedUnboundEntries(0)
 {
     NS_ASSERTION(gService==nsnull, "multiple nsCacheService instances!");
     gService = this;
 
     // create list of cache devices
     PR_INIT_CLIST(&mDoomedEntries);
-  
-    // allocate service lock
-    mLock = PR_NewLock();
-
-#if defined(DEBUG)
-    mLockedThread = nsnull;
-#endif
 }
 
 nsCacheService::~nsCacheService()
 {
     if (mInitialized) // Shutdown hasn't been called yet.
         (void) Shutdown();
 
-    PR_DestroyLock(mLock);
     gService = nsnull;
 }
 
 
 nsresult
 nsCacheService::Init()
 {
     NS_TIME_FUNCTION;
@@ -1036,19 +1024,16 @@ nsCacheService::Init()
         return NS_ERROR_ALREADY_INITIALIZED;
 
 #ifdef MOZ_IPC
     if (mozilla::net::IsNeckoChild()) {
         return NS_ERROR_UNEXPECTED;
     }
 #endif
 
-    if (mLock == nsnull)
-        return NS_ERROR_OUT_OF_MEMORY;
-
     CACHE_LOG_INIT();
 
     nsresult rv = NS_NewThread(getter_AddRefs(mCacheIOThread));
     if (NS_FAILED(rv)) {
         NS_WARNING("Can't create cache IO thread");
     }
 
     // initialize hashtable for active cache entries
@@ -2206,45 +2191,38 @@ nsCacheService::OnDataSizeChange(nsCache
     if (!device)  return  NS_ERROR_UNEXPECTED;
 
     return device->OnDataSizeChange(entry, deltaSize);
 }
 
 void
 nsCacheService::Lock()
 {
-    PR_Lock(gService->mLock);
-
-#if defined(DEBUG)
-    gService->mLockedThread = PR_GetCurrentThread();
-#endif
+    gService->mLock.Lock();
 }
 
 void
 nsCacheService::Unlock()
 {
-    NS_ASSERTION(gService->mLockedThread == PR_GetCurrentThread(), "oops");
+    gService->mLock.AssertCurrentThreadOwns();
 
     nsTArray<nsISupports*> doomed;
     doomed.SwapElements(gService->mDoomedObjects);
 
-#if defined(DEBUG)
-    gService->mLockedThread = nsnull;
-#endif
-    PR_Unlock(gService->mLock);
+    gService->mLock.Unlock();
 
     for (PRUint32 i = 0; i < doomed.Length(); ++i)
         doomed[i]->Release();
 }
 
 void
 nsCacheService::ReleaseObject_Locked(nsISupports * obj,
                                      nsIEventTarget * target)
 {
-    NS_ASSERTION(gService->mLockedThread == PR_GetCurrentThread(), "oops");
+    gService->mLock.AssertCurrentThreadOwns();
 
     PRBool isCur;
     if (!target || (NS_SUCCEEDED(target->IsOnCurrentThread(&isCur)) && isCur)) {
         gService->mDoomedObjects.AppendElement(obj);
     } else {
         NS_ProxyRelease(target, obj);
     }
 }
--- a/netwerk/cache/nsCacheService.h
+++ b/netwerk/cache/nsCacheService.h
@@ -45,23 +45,23 @@
 #ifndef _nsCacheService_h_
 #define _nsCacheService_h_
 
 #include "nsICacheService.h"
 #include "nsCacheSession.h"
 #include "nsCacheDevice.h"
 #include "nsCacheEntry.h"
 
-#include "prlock.h"
 #include "prthread.h"
 #include "nsIObserver.h"
 #include "nsString.h"
 #include "nsProxiedService.h"
 #include "nsTArray.h"
-#include "mozilla/Monitor.h"
+#include "mozilla/CondVar.h"
+#include "mozilla/Mutex.h"
 
 class nsCacheRequest;
 class nsCacheProfilePrefObserver;
 class nsDiskCacheDevice;
 class nsMemoryCacheDevice;
 class nsOfflineCacheDevice;
 class nsCacheServiceAutoLock;
 
@@ -167,16 +167,20 @@ public:
     static void      SetOfflineCacheCapacity(PRInt32  capacity);
 
     static void      SetMemoryCache();
 
     static void      OnEnterExitPrivateBrowsing();
 
     nsresult         Init();
     void             Shutdown();
+
+    static void      AssertOwnsLock()
+    { gService->mLock.AssertCurrentThreadOwns(); }
+
 private:
     friend class nsCacheServiceAutoLock;
     friend class nsOfflineCacheDevice;
     friend class nsProcessRequestEvent;
     friend class nsSetSmartSizeEvent;
     friend class nsBlockOnCacheThreadEvent;
 
     /**
@@ -249,23 +253,18 @@ private:
     /**
      *  Data Members
      */
 
     static nsCacheService *         gService;  // there can be only one...
     
     nsCacheProfilePrefObserver *    mObserver;
     
-    PRLock *                        mLock;
-
-    mozilla::Monitor                mMonitor;
-
-#if defined(DEBUG)
-    PRThread *                      mLockedThread;  // The thread holding mLock
-#endif
+    mozilla::Mutex                  mLock;
+    mozilla::CondVar                mCondVar;
 
     nsCOMPtr<nsIThread>             mCacheIOThread;
 
     nsTArray<nsISupports*>          mDoomedObjects;
     
     PRBool                          mInitialized;
     
     PRBool                          mEnableMemoryDevice;
--- a/netwerk/cache/nsDiskCacheDevice.cpp
+++ b/netwerk/cache/nsDiskCacheDevice.cpp
@@ -70,17 +70,16 @@
 #include "nsCache.h"
 
 #include "nsDeleteDir.h"
 
 #include "nsICacheVisitor.h"
 #include "nsReadableUtils.h"
 #include "nsIInputStream.h"
 #include "nsIOutputStream.h"
-#include "nsAutoLock.h"
 #include "nsCRT.h"
 #include "nsCOMArray.h"
 #include "nsISimpleEnumerator.h"
 
 #include "mozilla/FunctionTimer.h"
 
 static const char DISK_CACHE_DEVICE_ID[] = { "disk" };
 
@@ -393,16 +392,18 @@ nsDiskCacheDevice::Init()
 
 
 /**
  *  NOTE: called while holding the cache service lock
  */
 nsresult
 nsDiskCacheDevice::Shutdown()
 {
+    nsCacheService::AssertOwnsLock();
+
     nsresult rv = Shutdown_Private(PR_TRUE);
     if (NS_FAILED(rv))
         return rv;
 
     if (mCacheDirectory) {
         // delete any trash files left-over before shutting down.
         nsCOMPtr<nsIFile> trashDir;
         GetTrashDir(mCacheDirectory, &trashDir);
--- a/netwerk/dns/nsDNSService2.cpp
+++ b/netwerk/dns/nsDNSService2.cpp
@@ -41,31 +41,32 @@
 #include "nsICancelable.h"
 #include "nsIProxyObjectManager.h"
 #include "nsIPrefService.h"
 #include "nsIPrefBranch.h"
 #include "nsIPrefBranch2.h"
 #include "nsIServiceManager.h"
 #include "nsReadableUtils.h"
 #include "nsString.h"
-#include "nsAutoLock.h"
 #include "nsAutoPtr.h"
 #include "nsNetCID.h"
 #include "nsNetError.h"
 #include "nsDNSPrefetch.h"
 #include "nsIProtocolProxyService.h"
 #include "prsystem.h"
 #include "prnetdb.h"
 #include "prmon.h"
 #include "prio.h"
 #include "plstr.h"
 #include "nsIOService.h"
 
 #include "mozilla/FunctionTimer.h"
 
+using namespace mozilla;
+
 static const char kPrefDnsCacheEntries[]    = "network.dnsCacheEntries";
 static const char kPrefDnsCacheExpiration[] = "network.dnsCacheExpiration";
 static const char kPrefEnableIDN[]          = "network.enableIDN";
 static const char kPrefIPv4OnlyDomains[]    = "network.dns.ipv4OnlyDomains";
 static const char kPrefDisableIPv6[]        = "network.dns.disableIPv6";
 static const char kPrefDisablePrefetch[]    = "network.dns.disablePrefetch";
 
 //-----------------------------------------------------------------------------
@@ -100,54 +101,55 @@ nsDNSRecord::GetCanonicalName(nsACString
 {
     // this method should only be called if we have a CNAME
     NS_ENSURE_TRUE(mHostRecord->flags & nsHostResolver::RES_CANON_NAME,
                    NS_ERROR_NOT_AVAILABLE);
 
     // if the record is for an IP address literal, then the canonical
     // host name is the IP address literal.
     const char *cname;
-    PR_Lock(mHostRecord->addr_info_lock);
-    if (mHostRecord->addr_info)
-        cname = PR_GetCanonNameFromAddrInfo(mHostRecord->addr_info);
-    else
-        cname = mHostRecord->host;
-    result.Assign(cname);
-    PR_Unlock(mHostRecord->addr_info_lock);
+    {
+        MutexAutoLock lock(*mHostRecord->addr_info_lock);
+        if (mHostRecord->addr_info)
+            cname = PR_GetCanonNameFromAddrInfo(mHostRecord->addr_info);
+        else
+            cname = mHostRecord->host;
+        result.Assign(cname);
+    }
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDNSRecord::GetNextAddr(PRUint16 port, PRNetAddr *addr)
 {
     // not a programming error to poke the DNS record when it has no more
     // entries.  just fail without any debug warnings.  this enables consumers
     // to enumerate the DNS record without calling HasMore.
     if (mDone)
         return NS_ERROR_NOT_AVAILABLE;
 
-    PR_Lock(mHostRecord->addr_info_lock);
+    mHostRecord->addr_info_lock->Lock();
     if (mHostRecord->addr_info) {
         if (!mIter)
             mIterGenCnt = mHostRecord->addr_info_gencnt;
         else if (mIterGenCnt != mHostRecord->addr_info_gencnt) {
             // mHostRecord->addr_info has changed, so mIter is invalid.
             // Restart the iteration.  Alternatively, we could just fail.
             mIter = nsnull;
             mIterGenCnt = mHostRecord->addr_info_gencnt;
         }
         mIter = PR_EnumerateAddrInfo(mIter, mHostRecord->addr_info, port, addr);
-        PR_Unlock(mHostRecord->addr_info_lock);
+        mHostRecord->addr_info_lock->Unlock();
         if (!mIter) {
             mDone = PR_TRUE;
             return NS_ERROR_NOT_AVAILABLE;
         }
     }
     else {
-        PR_Unlock(mHostRecord->addr_info_lock);
+        mHostRecord->addr_info_lock->Unlock();
         if (!mHostRecord->addr) {
             // Both mHostRecord->addr_info and mHostRecord->addr are null.
             // This can happen if mHostRecord->addr_info expired and the
             // attempt to reresolve it failed.
             return NS_ERROR_NOT_AVAILABLE;
         }
         memcpy(addr, mHostRecord->addr, sizeof(PRNetAddr));
         // set given port
@@ -301,38 +303,35 @@ nsDNSSyncRequest::OnLookupComplete(nsHos
     mHostRecord = hostRecord;
     PR_Notify(mMonitor);
     PR_ExitMonitor(mMonitor);
 }
 
 //-----------------------------------------------------------------------------
 
 nsDNSService::nsDNSService()
-    : mLock(nsnull)
+    : mLock("nsDNSServer.mLock")
+    , mFirstTime(PR_TRUE)
 {
 }
 
 nsDNSService::~nsDNSService()
 {
-    if (mLock)
-        nsAutoLock::DestroyLock(mLock);
 }
 
 NS_IMPL_THREADSAFE_ISUPPORTS3(nsDNSService, nsIDNSService, nsPIDNSService,
                               nsIObserver)
 
 NS_IMETHODIMP
 nsDNSService::Init()
 {
     NS_TIME_FUNCTION;
 
     NS_ENSURE_TRUE(!mResolver, NS_ERROR_ALREADY_INITIALIZED);
 
-    PRBool firstTime = (mLock == nsnull);
-
     // prefs
     PRUint32 maxCacheEntries  = 400;
     PRUint32 maxCacheLifetime = 3; // minutes
     PRBool   enableIDN        = PR_TRUE;
     PRBool   disableIPv6      = PR_FALSE;
     PRBool   disablePrefetch  = PR_FALSE;
     int      proxyType        = nsIProtocolProxyService::PROXYCONFIG_DIRECT;
     
@@ -352,20 +351,18 @@ nsDNSService::Init()
         prefs->GetBoolPref(kPrefDisableIPv6, &disableIPv6);
         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 = nsAutoLock::NewLock("nsDNSService::mLock");
-        if (!mLock)
-            return NS_ERROR_OUT_OF_MEMORY;
+    if (mFirstTime) {
+        mFirstTime = PR_FALSE;
 
         // register as prefs observer
         if (prefs) {
             prefs->AddObserver(kPrefDnsCacheEntries, this, PR_FALSE);
             prefs->AddObserver(kPrefDnsCacheExpiration, this, PR_FALSE);
             prefs->AddObserver(kPrefEnableIDN, this, PR_FALSE);
             prefs->AddObserver(kPrefIPv4OnlyDomains, this, PR_FALSE);
             prefs->AddObserver(kPrefDisableIPv6, this, PR_FALSE);
@@ -391,34 +388,34 @@ nsDNSService::Init()
         return NS_OK;
 
     nsRefPtr<nsHostResolver> res;
     nsresult rv = nsHostResolver::Create(maxCacheEntries,
                                          maxCacheLifetime,
                                          getter_AddRefs(res));
     if (NS_SUCCEEDED(rv)) {
         // now, set all of our member variables while holding the lock
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
         mResolver = res;
         mIDN = idn;
         mIPv4OnlyDomains = ipv4OnlyDomains; // exchanges buffer ownership
         mDisableIPv6 = disableIPv6;
 
         // Disable prefetching either by explicit preference or if a manual proxy is configured 
         mDisablePrefetch = disablePrefetch || (proxyType == nsIProtocolProxyService::PROXYCONFIG_MANUAL);
     }
     return rv;
 }
 
 NS_IMETHODIMP
 nsDNSService::Shutdown()
 {
     nsRefPtr<nsHostResolver> res;
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
         res = mResolver;
         mResolver = nsnull;
     }
     if (res)
         res->Shutdown();
     return NS_OK;
 }
 
@@ -429,17 +426,17 @@ nsDNSService::AsyncResolve(const nsACStr
                            nsIEventTarget    *target,
                            nsICancelable    **result)
 {
     // grab reference to global host resolver and IDN service.  beware
     // simultaneous shutdown!!
     nsRefPtr<nsHostResolver> res;
     nsCOMPtr<nsIIDNService> idn;
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
 
         if (mDisablePrefetch && (flags & RESOLVE_SPECULATE))
             return NS_ERROR_DNS_LOOKUP_QUEUE_FULL;
 
         res = mResolver;
         idn = mIDN;
     }
     if (!res)
@@ -488,17 +485,17 @@ nsDNSService::Resolve(const nsACString &
                       PRUint32          flags,
                       nsIDNSRecord    **result)
 {
     // grab reference to global host resolver and IDN service.  beware
     // simultaneous shutdown!!
     nsRefPtr<nsHostResolver> res;
     nsCOMPtr<nsIIDNService> idn;
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
         res = mResolver;
         idn = mIDN;
     }
     NS_ENSURE_TRUE(res, NS_ERROR_OFFLINE);
 
     const nsACString *hostPtr = &hostname;
 
     nsresult rv;
@@ -583,17 +580,17 @@ nsDNSService::Observe(nsISupports *subje
 }
 
 PRUint16
 nsDNSService::GetAFForLookup(const nsACString &host)
 {
     if (mDisableIPv6)
         return PR_AF_INET;
 
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
 
     PRUint16 af = PR_AF_UNSPEC;
 
     if (!mIPv4OnlyDomains.IsEmpty()) {
         const char *domain, *domainEnd, *end;
         PRUint32 hostLen, domainLen;
 
         // see if host is in one of the IPv4-only domains
--- a/netwerk/dns/nsDNSService2.h
+++ b/netwerk/dns/nsDNSService2.h
@@ -35,17 +35,17 @@
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsPIDNSService.h"
 #include "nsIIDNService.h"
 #include "nsIObserver.h"
 #include "nsHostResolver.h"
 #include "nsAutoPtr.h"
 #include "nsString.h"
-#include "prlock.h"
+#include "mozilla/Mutex.h"
 
 class nsDNSService : public nsPIDNSService
                    , public nsIObserver
 {
 public:
     NS_DECL_ISUPPORTS
     NS_DECL_NSPIDNSSERVICE
     NS_DECL_NSIDNSSERVICE
@@ -56,17 +56,18 @@ public:
 
 private:
     PRUint16 GetAFForLookup(const nsACString &host);
 
     nsRefPtr<nsHostResolver>  mResolver;
     nsCOMPtr<nsIIDNService>   mIDN;
 
     // mLock protects access to mResolver and mIPv4OnlyDomains
-    PRLock                   *mLock;
+    mozilla::Mutex            mLock;
 
     // mIPv4OnlyDomains is a comma-separated list of domains for which only
     // IPv4 DNS lookups are performed. This allows the user to disable IPv6 on
     // a per-domain basis and work around broken DNS servers. See bug 68796.
     nsAdoptingCString         mIPv4OnlyDomains;
     PRBool                    mDisableIPv6;
     PRBool                    mDisablePrefetch;
+    PRBool                    mFirstTime;
 };
--- a/netwerk/dns/nsHostResolver.cpp
+++ b/netwerk/dns/nsHostResolver.cpp
@@ -48,31 +48,31 @@
 #define RES_RETRY_ON_FAILURE
 #endif
 
 #include <stdlib.h>
 #include "nsHostResolver.h"
 #include "nsNetError.h"
 #include "nsISupportsBase.h"
 #include "nsISupportsUtils.h"
-#include "nsAutoLock.h"
 #include "nsAutoPtr.h"
 #include "pratom.h"
 #include "prthread.h"
 #include "prerror.h"
-#include "prcvar.h"
 #include "prtime.h"
 #include "prlong.h"
 #include "prlog.h"
 #include "pldhash.h"
 #include "plstr.h"
 #include "nsURLHelper.h"
 
 #include "mozilla/FunctionTimer.h"
 
+using namespace mozilla;
+
 //----------------------------------------------------------------------------
 
 // Use a persistent thread pool in order to avoid spinning up new threads all the time.
 // In particular, thread creation results in a res_init() call from libc which is 
 // quite expensive.
 //
 // The pool dynamically grows between 0 and MAX_RESOLVER_THREADS in size. New requests
 // go first to an idle thread. If that cannot be found and there are fewer than MAX_RESOLVER_THREADS
@@ -176,36 +176,28 @@ private:
 // this macro filters out any flags that are not used when constructing the
 // host key.  the significant flags are those that would affect the resulting
 // host record (i.e., the flags that are passed down to PR_GetAddrInfoByName).
 #define RES_KEY_FLAGS(_f) ((_f) & nsHostResolver::RES_CANON_NAME)
 
 nsresult
 nsHostRecord::Create(const nsHostKey *key, nsHostRecord **result)
 {
-    PRLock *lock = PR_NewLock();
-    if (!lock)
-        return NS_ERROR_OUT_OF_MEMORY;
-
     size_t hostLen = strlen(key->host) + 1;
     size_t size = hostLen + sizeof(nsHostRecord);
 
     nsHostRecord *rec = (nsHostRecord*) ::operator new(size);
-    if (!rec) {
-        PR_DestroyLock(lock);
-        return NS_ERROR_OUT_OF_MEMORY;
-    }
 
     rec->host = ((char *) rec) + sizeof(nsHostRecord);
     rec->flags = key->flags;
     rec->af = key->af;
 
     rec->_refc = 1; // addref
     NS_LOG_ADDREF(rec, 1, "nsHostRecord", sizeof(nsHostRecord));
-    rec->addr_info_lock = lock;
+    rec->addr_info_lock = new Mutex("nsHostRecord.addr_info_lock");
     rec->addr_info = nsnull;
     rec->addr_info_gencnt = 0;
     rec->addr = nsnull;
     rec->expiration = NowInMinutes();
     rec->resolving = PR_FALSE;
     rec->onQueue = PR_FALSE;
     rec->usingAnyThread = PR_FALSE;
     PR_INIT_CLIST(rec);
@@ -214,20 +206,17 @@ nsHostRecord::Create(const nsHostKey *ke
     memcpy((char *) rec->host, key->host, hostLen);
 
     *result = rec;
     return NS_OK;
 }
 
 nsHostRecord::~nsHostRecord()
 {
-    if (addr_info_lock)
-        PR_DestroyLock(addr_info_lock);
-    if (addr_info)
-        PR_FreeAddrInfo(addr_info);
+    delete addr_info_lock;
     if (addr)
         free(addr);
 }
 
 //----------------------------------------------------------------------------
 
 struct nsHostDBEnt : PLDHashEntryHdr
 {
@@ -325,18 +314,18 @@ HostDB_RemoveEntry(PLDHashTable *table,
 }
 
 //----------------------------------------------------------------------------
 
 nsHostResolver::nsHostResolver(PRUint32 maxCacheEntries,
                                PRUint32 maxCacheLifetime)
     : mMaxCacheEntries(maxCacheEntries)
     , mMaxCacheLifetime(maxCacheLifetime)
-    , mLock(nsnull)
-    , mIdleThreadCV(nsnull)
+    , mLock("nsHostResolver.mLock")
+    , mIdleThreadCV(mLock, "nsHostResolver.mIdleThreadCV")
     , mNumIdleThreads(0)
     , mThreadCount(0)
     , mActiveAnyThreadCount(0)
     , mEvictionQSize(0)
     , mPendingCount(0)
     , mShutdown(PR_TRUE)
 {
     mCreationTime = PR_Now();
@@ -346,38 +335,24 @@ nsHostResolver::nsHostResolver(PRUint32 
     PR_INIT_CLIST(&mEvictionQ);
 
     mLongIdleTimeout  = PR_SecondsToInterval(LongIdleTimeoutSeconds);
     mShortIdleTimeout = PR_SecondsToInterval(ShortIdleTimeoutSeconds);
 }
 
 nsHostResolver::~nsHostResolver()
 {
-    if (mIdleThreadCV)
-        PR_DestroyCondVar(mIdleThreadCV);
-
-    if (mLock)
-        nsAutoLock::DestroyLock(mLock);
-
     PL_DHashTableFinish(&mDB);
 }
 
 nsresult
 nsHostResolver::Init()
 {
     NS_TIME_FUNCTION;
 
-    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);
 
     mShutdown = PR_FALSE;
 
 #if defined(HAVE_RES_NINIT)
     // We want to make sure the system is using the correct resolver settings,
     // so we force it to reload those settings whenever we startup a subsequent
     // nsHostResolver instance.  We assume that there is no reason to do this
@@ -413,29 +388,29 @@ nsHostResolver::Shutdown()
 
     PRCList pendingQHigh, pendingQMed, pendingQLow, evictionQ;
     PR_INIT_CLIST(&pendingQHigh);
     PR_INIT_CLIST(&pendingQMed);
     PR_INIT_CLIST(&pendingQLow);
     PR_INIT_CLIST(&evictionQ);
 
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
         
         mShutdown = PR_TRUE;
 
         MoveCList(mHighQ, pendingQHigh);
         MoveCList(mMediumQ, pendingQMed);
         MoveCList(mLowQ, pendingQLow);
         MoveCList(mEvictionQ, evictionQ);
         mEvictionQSize = 0;
         mPendingCount = 0;
         
         if (mNumIdleThreads)
-            PR_NotifyAllCondVar(mIdleThreadCV);
+            mIdleThreadCV.NotifyAll();
         
         // empty host database
         PL_DHashTableEnumerate(&mDB, HostDB_RemoveEntry, nsnull);
     }
     
     ClearPendingQueue(&pendingQHigh);
     ClearPendingQueue(&pendingQMed);
     ClearPendingQueue(&pendingQLow);
@@ -507,17 +482,17 @@ nsHostResolver::ResolveHost(const char  
     if (!net_IsValidHostName(nsDependentCString(host)))
         return NS_ERROR_UNKNOWN_HOST;
 
     // if result is set inside the lock, then we need to issue the
     // callback before returning.
     nsRefPtr<nsHostRecord> result;
     nsresult status = NS_OK, rv = NS_OK;
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
 
         if (mShutdown)
             rv = NS_ERROR_NOT_INITIALIZED;
         else {
             PRNetAddr tempAddr;
 
             // unfortunately, PR_StringToNetAddr does not properly initialize
             // the output buffer in the case of IPv6 input.  see bug 223145.
@@ -597,17 +572,17 @@ nsHostResolver::ResolveHost(const char  
                         // Move from (low|med) to high.
                         MoveQueue(he->rec, mHighQ);
                         he->rec->flags = flags;
                         ConditionallyCreateThread(he->rec);
                     } else if (IsMediumPriority(flags) && IsLowPriority(he->rec->flags)) {
                         // Move from low to med.
                         MoveQueue(he->rec, mMediumQ);
                         he->rec->flags = flags;
-                        PR_NotifyCondVar(mIdleThreadCV);
+                        mIdleThreadCV.Notify();
                     }
                 }
             }
         }
     }
     if (result)
         callback->OnLookupComplete(this, result, status);
     return rv;
@@ -617,17 +592,17 @@ void
 nsHostResolver::DetachCallback(const char            *host,
                                PRUint16               flags,
                                PRUint16               af,
                                nsResolveHostCallback *callback,
                                nsresult               status)
 {
     nsRefPtr<nsHostRecord> rec;
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
 
         nsHostKey key = { host, flags, af };
         nsHostDBEnt *he = static_cast<nsHostDBEnt *>
                                      (PL_DHashTableOperate(&mDB, &key, PL_DHASH_LOOKUP));
         if (he && he->rec) {
             // walk list looking for |callback|... we cannot assume
             // that it will be there!
             PRCList *node = he->rec->callbacks.next;
@@ -648,17 +623,17 @@ nsHostResolver::DetachCallback(const cha
         callback->OnLookupComplete(this, rec, status);
 }
 
 nsresult
 nsHostResolver::ConditionallyCreateThread(nsHostRecord *rec)
 {
     if (mNumIdleThreads) {
         // wake up idle thread to process this lookup
-        PR_NotifyCondVar(mIdleThreadCV);
+        mIdleThreadCV.Notify();
     }
     else if ((mThreadCount < HighThreadThreshold) ||
              (IsHighPriority(rec->flags) && mThreadCount < MAX_RESOLVER_THREADS)) {
         // dispatch new worker thread
         NS_ADDREF_THIS(); // owning reference passed to thread
 
         mThreadCount++;
         PRThread *thr = PR_CreateThread(PR_SYSTEM_THREAD,
@@ -729,17 +704,17 @@ nsHostResolver::DeQueue(PRCList &aQ, nsH
 }
 
 PRBool
 nsHostResolver::GetHostToLookup(nsHostRecord **result)
 {
     PRBool timedOut = PR_FALSE;
     PRIntervalTime epoch, now, timeout;
     
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
 
     timeout = (mNumIdleThreads >= HighThreadThreshold) ? mShortIdleTimeout : mLongIdleTimeout;
     epoch = PR_IntervalNow();
 
     while (!mShutdown) {
         // remove next record from Q; hand over owning reference. Check high, then med, then low
         
         if (!PR_CLIST_IS_EMPTY(&mHighQ)) {
@@ -769,17 +744,17 @@ nsHostResolver::GetHostToLookup(nsHostRe
             break;
 
         // wait for one or more of the following to occur:
         //  (1) the pending queue has a host record to process
         //  (2) the shutdown flag has been set
         //  (3) the thread has been idle for too long
         
         mNumIdleThreads++;
-        PR_WaitCondVar(mIdleThreadCV, timeout);
+        mIdleThreadCV.Wait(timeout);
         mNumIdleThreads--;
         
         now = PR_IntervalNow();
         
         if ((PRIntervalTime)(now - epoch) >= timeout)
             timedOut = PR_TRUE;
         else {
             // It is possible that PR_WaitCondVar() was interrupted and returned early,
@@ -798,29 +773,30 @@ nsHostResolver::GetHostToLookup(nsHostRe
 void
 nsHostResolver::OnLookupComplete(nsHostRecord *rec, nsresult status, PRAddrInfo *result)
 {
     // get the list of pending callbacks for this lookup, and notify
     // them that the lookup is complete.
     PRCList cbs;
     PR_INIT_CLIST(&cbs);
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
 
         // grab list of callbacks to notify
         MoveCList(rec->callbacks, cbs);
 
         // update record fields.  We might have a rec->addr_info already if a
         // previous lookup result expired and we're reresolving it..
         PRAddrInfo  *old_addr_info;
-        PR_Lock(rec->addr_info_lock);
-        old_addr_info = rec->addr_info;
-        rec->addr_info = result;
-        rec->addr_info_gencnt++;
-        PR_Unlock(rec->addr_info_lock);
+        {
+            MutexAutoLock lock(*rec->addr_info_lock);
+            old_addr_info = rec->addr_info;
+            rec->addr_info = result;
+            rec->addr_info_gencnt++;
+        }
         if (old_addr_info)
             PR_FreeAddrInfo(old_addr_info);
         rec->expiration = NowInMinutes();
         if (result) {
             rec->expiration += mMaxCacheLifetime;
             rec->negative = PR_FALSE;
         }
         else {
--- a/netwerk/dns/nsHostResolver.h
+++ b/netwerk/dns/nsHostResolver.h
@@ -35,20 +35,21 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef nsHostResolver_h__
 #define nsHostResolver_h__
 
 #include "nscore.h"
 #include "nsAtomicRefcnt.h"
-#include "prcvar.h"
 #include "prclist.h"
 #include "prnetdb.h"
 #include "pldhash.h"
+#include "mozilla/CondVar.h"
+#include "mozilla/Mutex.h"
 #include "nsISupportsImpl.h"
 
 class nsHostResolver;
 class nsHostRecord;
 class nsResolveHostCallback;
 
 /* XXX move this someplace more generic */
 #define NS_DECL_REFCOUNTED_THREADSAFE(classname)                             \
@@ -80,16 +81,18 @@ struct nsHostKey
     PRUint16    af;
 };
 
 /**
  * nsHostRecord - ref counted object type stored in host resolver cache.
  */
 class nsHostRecord : public PRCList, public nsHostKey
 {
+    typedef mozilla::Mutex Mutex;
+
 public:
     NS_DECL_REFCOUNTED_THREADSAFE(nsHostRecord)
 
     /* instantiates a new host record */
     static nsresult Create(const nsHostKey *key, nsHostRecord **record);
 
     /* a fully resolved host record has either a non-null |addr_info| or |addr|
      * field.  if |addr_info| is null, it implies that the |host| is an IP
@@ -103,17 +106,17 @@ public:
     /* the lock protects |addr_info| and |addr_info_gencnt| because they
      * are mutable and accessed by the resolver worker thread and the
      * nsDNSService2 class.  |addr| doesn't change after it has been
      * assigned a value.  only the resolver worker thread modifies
      * nsHostRecord (and only in nsHostResolver::OnLookupComplete);
      * the other threads just read it.  therefore the resolver worker
      * thread doesn't need to lock when reading |addr_info|.
      */
-    PRLock      *addr_info_lock;
+    Mutex       *addr_info_lock;
     int          addr_info_gencnt; /* generation count of |addr_info| */
     PRAddrInfo  *addr_info;
     PRNetAddr   *addr;
     PRBool       negative;   /* True if this record is a cache of a failed lookup.
                                 Negative cache entries are valid just like any other
                                 (though never for more than 60 seconds), but a use
                                 of that negative entry forces an asynchronous refresh. */
 
@@ -166,16 +169,19 @@ public:
                                   nsresult        status) = 0;
 };
 
 /**
  * nsHostResolver - an asynchronous host name resolver.
  */
 class nsHostResolver
 {
+    typedef mozilla::CondVar CondVar;
+    typedef mozilla::Mutex Mutex;
+
 public:
     /**
      * host resolver instances are reference counted.
      */
     NS_DECL_REFCOUNTED_THREADSAFE(nsHostResolver)
 
     /**
      * creates an addref'd instance of a nsHostResolver object.
@@ -242,18 +248,18 @@ private:
     nsresult ConditionallyCreateThread(nsHostRecord *rec);
     
     static void  MoveQueue(nsHostRecord *aRec, PRCList &aDestQ);
     
     static void ThreadFunc(void *);
 
     PRUint32      mMaxCacheEntries;
     PRUint32      mMaxCacheLifetime;
-    PRLock       *mLock;
-    PRCondVar    *mIdleThreadCV; // non-null if idle thread
+    Mutex         mLock;
+    CondVar       mIdleThreadCV;
     PRUint32      mNumIdleThreads;
     PRUint32      mThreadCount;
     PRUint32      mActiveAnyThreadCount;
     PLDHashTable  mDB;
     PRCList       mHighQ;
     PRCList       mMediumQ;
     PRCList       mLowQ;
     PRCList       mEvictionQ;
--- a/netwerk/protocol/ftp/nsFTPChannel.h
+++ b/netwerk/protocol/ftp/nsFTPChannel.h
@@ -50,17 +50,16 @@
 #include "nsCOMPtr.h"
 #include "nsIProtocolHandler.h"
 #include "nsIProgressEventSink.h"
 #include "nsIInterfaceRequestor.h"
 #include "nsIInterfaceRequestorUtils.h"
 #include "nsFtpConnectionThread.h"
 #include "netCore.h"
 #include "nsIStreamListener.h"
-#include "nsAutoLock.h"
 #include "nsIFTPChannel.h"
 #include "nsIUploadChannel.h"
 #include "nsIProxyInfo.h"
 #include "nsIProxiedChannel.h"
 #include "nsIResumableChannel.h"
 #include "nsHashPropertyBag.h"
 #include "nsFtpProtocolHandler.h"
 
--- a/netwerk/protocol/ftp/nsFtpConnectionThread.h
+++ b/netwerk/protocol/ftp/nsFtpConnectionThread.h
@@ -55,17 +55,16 @@
 #include "prnetdb.h"
 #include "prtime.h"
 #include "nsString.h"
 #include "nsIFTPChannel.h"
 #include "nsIProtocolHandler.h"
 #include "nsCOMPtr.h"
 #include "nsIAsyncInputStream.h"
 #include "nsIOutputStream.h"
-#include "nsAutoLock.h"
 #include "nsAutoPtr.h"
 #include "nsIPrompt.h"
 #include "nsITransport.h"
 #include "nsIProxyInfo.h"
 
 #include "nsFtpControlConnection.h"
 
 #include "nsICacheEntryDescriptor.h"
--- a/netwerk/protocol/ftp/nsFtpControlConnection.h
+++ b/netwerk/protocol/ftp/nsFtpControlConnection.h
@@ -42,17 +42,16 @@
 #include "nsCOMPtr.h"
 
 #include "nsIURI.h"
 #include "nsIStreamListener.h"
 #include "nsIRequest.h"
 #include "nsISocketTransport.h"
 #include "nsIOutputStream.h"
 #include "nsIAsyncInputStream.h"
-#include "nsAutoLock.h"
 #include "nsAutoPtr.h"
 #include "nsString.h"
 
 class nsIProxyInfo;
 class nsITransportEventSink;
 
 class nsFtpControlConnectionListener : public nsISupports {
 public:
--- a/netwerk/protocol/http/nsHttp.cpp
+++ b/netwerk/protocol/http/nsHttp.cpp
@@ -33,18 +33,18 @@
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsHttp.h"
-#include "nsAutoLock.h"
 #include "pldhash.h"
+#include "mozilla/Mutex.h"
 #include "nsCRT.h"
 #include "prbit.h"
 
 #if defined(PR_LOGGING)
 PRLogModuleInfo *gHttpLog = nsnull;
 #endif
 
 // define storage for all atoms
@@ -55,28 +55,30 @@ PRLogModuleInfo *gHttpLog = nsnull;
 // find out how many atoms we have
 #define HTTP_ATOM(_name, _value) Unused_ ## _name,
 enum {
 #include "nsHttpAtomList.h"
     NUM_HTTP_ATOMS
 };
 #undef HTTP_ATOM
 
+using namespace mozilla;
+
 // we keep a linked list of atoms allocated on the heap for easy clean up when
 // the atom table is destroyed.  The structure and value string are allocated
 // as one contiguous block.
 
 struct HttpHeapAtom {
     struct HttpHeapAtom *next;
     char                 value[1];
 };
 
 static struct PLDHashTable  sAtomTable = {0};
 static struct HttpHeapAtom *sHeapAtoms = nsnull;
-static PRLock              *sLock = nsnull;
+static Mutex               *sLock = nsnull;
 
 HttpHeapAtom *
 NewHeapAtom(const char *value) {
     int len = strlen(value);
 
     HttpHeapAtom *a =
         reinterpret_cast<HttpHeapAtom *>(malloc(sizeof(*a) + len));
     if (!a)
@@ -124,19 +126,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 = nsAutoLock::NewLock("nsHttp::sLock");
-        if (!sLock)
-            return NS_ERROR_OUT_OF_MEMORY;
+        sLock = new Mutex("nsHttp.sLock");
     }
 
     // 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),
                            NUM_HTTP_ATOMS + 10)) {
         sAtomTable.ops = nsnull;
@@ -174,31 +174,31 @@ nsHttp::DestroyAtomTable()
 
     while (sHeapAtoms) {
         HttpHeapAtom *next = sHeapAtoms->next;
         free(sHeapAtoms);
         sHeapAtoms = next;
     }
 
     if (sLock) {
-        nsAutoLock::DestroyLock(sLock);
+        delete sLock;
         sLock = nsnull;
     }
 }
 
 // this function may be called from multiple threads
 nsHttpAtom
 nsHttp::ResolveAtom(const char *str)
 {
     nsHttpAtom atom = { nsnull };
 
     if (!str || !sAtomTable.ops)
         return atom;
 
-    nsAutoLock lock(sLock);
+    MutexAutoLock lock(*sLock);
 
     PLDHashEntryStub *stub = reinterpret_cast<PLDHashEntryStub *>
                                              (PL_DHashTableOperate(&sAtomTable, str, PL_DHASH_ADD));
     if (!stub)
         return atom;  // out of memory
 
     if (stub->key) {
         atom._val = reinterpret_cast<const char *>(stub->key);
--- a/netwerk/protocol/http/nsHttpActivityDistributor.cpp
+++ b/netwerk/protocol/http/nsHttpActivityDistributor.cpp
@@ -33,20 +33,21 @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsHttpActivityDistributor.h"
 #include "nsIChannel.h"
 #include "nsCOMPtr.h"
 #include "nsAutoPtr.h"
-#include "nsAutoLock.h"
 #include "nsNetUtil.h"
 #include "nsThreadUtils.h"
 
+using namespace mozilla;
+
 class nsHttpActivityEvent : public nsRunnable
 {
 public:
     nsHttpActivityEvent(nsISupports *aHttpChannel,
                         PRUint32 aActivityType,
                         PRUint32 aActivitySubtype,
                         PRTime aTimestamp,
                         PRUint64 aExtraSizeData,
@@ -86,37 +87,35 @@ private:
     nsCOMArray<nsIHttpActivityObserver> mObservers;
 };
 
 NS_IMPL_THREADSAFE_ISUPPORTS2(nsHttpActivityDistributor,
                               nsIHttpActivityDistributor,
                               nsIHttpActivityObserver)
 
 nsHttpActivityDistributor::nsHttpActivityDistributor()
-    : mLock(nsnull)
+    : mLock("nsHttpActivityDistributor.mLock")
 {
 }
 
 nsHttpActivityDistributor::~nsHttpActivityDistributor()
 {
-    if (mLock)
-        nsAutoLock::DestroyLock(mLock);
 }
 
 NS_IMETHODIMP
 nsHttpActivityDistributor::ObserveActivity(nsISupports *aHttpChannel,
                                            PRUint32 aActivityType,
                                            PRUint32 aActivitySubtype,
                                            PRTime aTimestamp,
                                            PRUint64 aExtraSizeData,
                                            const nsACString & aExtraStringData)
 {
     nsRefPtr<nsIRunnable> event;
     {
-        nsAutoLock lock(mLock);
+        MutexAutoLock lock(mLock);
 
         if (!mObservers.Count())
             return NS_OK;
 
         event = new nsHttpActivityEvent(aHttpChannel, aActivityType,
                                         aActivitySubtype, aTimestamp,
                                         aExtraSizeData, aExtraStringData,
                                         &mObservers);
@@ -124,46 +123,34 @@ nsHttpActivityDistributor::ObserveActivi
     NS_ENSURE_TRUE(event, NS_ERROR_OUT_OF_MEMORY);
     return NS_DispatchToMainThread(event);
 }
 
 NS_IMETHODIMP
 nsHttpActivityDistributor::GetIsActive(PRBool *isActive)
 {
     NS_ENSURE_ARG_POINTER(isActive);
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
     *isActive = !!mObservers.Count();
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsHttpActivityDistributor::AddObserver(nsIHttpActivityObserver *aObserver)
 {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
 
     if (!mObservers.AppendObject(aObserver))
         return NS_ERROR_OUT_OF_MEMORY;
 
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsHttpActivityDistributor::RemoveObserver(nsIHttpActivityObserver *aObserver)
 {
-    nsAutoLock lock(mLock);
+    MutexAutoLock lock(mLock);
 
     if (!mObservers.RemoveObject(aObserver))
         return NS_ERROR_FAILURE;
 
     return NS_OK;
 }
-
-nsresult
-nsHttpActivityDistributor::Init()
-{
-    NS_ENSURE_TRUE(!mLock, NS_ERROR_ALREADY_INITIALIZED);
-
-    mLock = nsAutoLock::NewLock("nsHttpActivityDistributor::mLock");
-    if (!mLock)
-        return NS_ERROR_OUT_OF_MEMORY;
-
-    return NS_OK;
-}
--- a/netwerk/protocol/http/nsHttpActivityDistributor.h
+++ b/netwerk/protocol/http/nsHttpActivityDistributor.h
@@ -34,27 +34,26 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef nsHttpActivityDistributor_h__
 #define nsHttpActivityDistributor_h__
 
 #include "nsIHttpActivityObserver.h"
 #include "nsCOMArray.h"
-#include "prlock.h"
+#include "mozilla/Mutex.h"
 
 class nsHttpActivityDistributor : public nsIHttpActivityDistributor
 {
 public:
     NS_DECL_ISUPPORTS
     NS_DECL_NSIHTTPACTIVITYOBSERVER
     NS_DECL_NSIHTTPACTIVITYDISTRIBUTOR
 
     nsHttpActivityDistributor();
     virtual ~nsHttpActivityDistributor();
-    nsresult Init();
 
 protected:
     nsCOMArray<nsIHttpActivityObserver> mObservers;
-    PRLock       *mLock;
+    mozilla::Mutex mLock;
 };
 
 #endif // nsHttpActivityDistributor_h__
--- a/netwerk/protocol/http/nsHttpConnection.cpp
+++ b/netwerk/protocol/http/nsHttpConnection.cpp
@@ -45,17 +45,16 @@
 #include "nsIOService.h"
 #include "nsISocketTransportService.h"
 #include "nsISocketTransport.h"
 #include "nsIServiceManager.h"
 #include "nsISSLSocketControl.h"
 #include "nsStringStream.h"
 #include "netCore.h"
 #include "nsNetCID.h"
-#include "nsAutoLock.h"
 #include "prmem.h"
 
 #ifdef DEBUG
 // defined by the socket transport service while active
 extern PRThread *gSocketThread;
 #endif
 
 static NS_DEFINE_CID(kSocketTransportServiceCID, NS_SOCKETTRANSPORTSERVICE_CID);
--- a/netwerk/protocol/http/nsHttpConnection.h
+++ b/netwerk/protocol/http/nsHttpConnection.h
@@ -40,17 +40,16 @@
 #define nsHttpConnection_h__
 
 #include "nsHttp.h"
 #include "nsHttpConnectionInfo.h"
 #include "nsAHttpConnection.h"
 #include "nsAHttpTransaction.h"
 #include "nsXPIDLString.h"
 #include "nsCOMPtr.h"
-#include "prlock.h"
 #include "nsAutoPtr.h"
 
 #include "nsIStreamListener.h"
 #include "nsISocketTransport.h"
 #include "nsIAsyncInputStream.h"
 #include "nsIAsyncOutputStream.h"
 #include "nsIInterfaceRequestor.h"
 
--- a/netwerk/protocol/http/nsHttpConnectionMgr.cpp
+++ b/netwerk/protocol/http/nsHttpConnectionMgr.cpp
@@ -35,25 +35,26 @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsHttpConnectionMgr.h"
 #include "nsHttpConnection.h"
 #include "nsHttpPipeline.h"
 #include "nsHttpHandler.h"
-#include "nsAutoLock.h"
 #include "nsNetCID.h"
 #include "nsCOMPtr.h"
 #include "nsNetUtil.h"
 
 #include "nsIServiceManager.h"
 
 #include "nsIObserverService.h"
 
+using namespace mozilla;
+
 // defined by the socket transport service while active
 extern PRThread *gSocketThread;
 
 static NS_DEFINE_CID(kSocketTransportServiceCID, NS_SOCKETTRANSPORTSERVICE_CID);
 
 //-----------------------------------------------------------------------------
 
 
@@ -75,36 +76,33 @@ InsertTransactionSorted(nsTArray<nsHttpT
     }
     pendingQ.InsertElementAt(0, trans);
 }
 
 //-----------------------------------------------------------------------------
 
 nsHttpConnectionMgr::nsHttpConnectionMgr()
     : mRef(0)
-    , mMonitor(nsAutoMonitor::NewMonitor("nsHttpConnectionMgr"))
+    , mMonitor("nsHttpConnectionMgr.mMonitor")
     , mMaxConns(0)
     , mMaxConnsPerHost(0)
     , mMaxConnsPerProxy(0)
     , mMaxPersistConnsPerHost(0)
     , mMaxPersistConnsPerProxy(0)
     , mIsShuttingDown(PR_FALSE)
     , mNumActiveConns(0)
     , mNumIdleConns(0)
     , mTimeOfNextWakeUp(LL_MAXUINT)
 {
     LOG(("Creating nsHttpConnectionMgr @%x\n", this));
 }
 
 nsHttpConnectionMgr::~nsHttpConnectionMgr()
 {
     LOG(("Destroying nsHttpConnectionMgr @%x\n", this));
- 
-    if (mMonitor)
-        nsAutoMonitor::DestroyMonitor(mMonitor);
 }
 
 nsresult
 nsHttpConnectionMgr::EnsureSocketThreadTargetIfOnline()
 {
     nsresult rv;
     nsCOMPtr<nsIEventTarget> sts;
     nsCOMPtr<nsIIOService> ioService = do_GetIOService(&rv);
@@ -112,17 +110,17 @@ nsHttpConnectionMgr::EnsureSocketThreadT
         PRBool offline = PR_TRUE;
         ioService->GetOffline(&offline);
 
         if (!offline) {
             sts = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
         }
     }
 
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
 
     // do nothing if already initialized or if we've shut down
     if (mSocketThreadTarget || mIsShuttingDown)
         return NS_OK;
 
     mSocketThreadTarget = sts;
 
     return rv;
@@ -135,17 +133,17 @@ nsHttpConnectionMgr::Init(PRUint16 maxCo
                           PRUint16 maxPersistConnsPerHost,
                           PRUint16 maxPersistConnsPerProxy,
                           PRUint16 maxRequestDelay,
                           PRUint16 maxPipelinedRequests)
 {
     LOG(("nsHttpConnectionMgr::Init\n"));
 
     {
-        nsAutoMonitor mon(mMonitor);
+        MonitorAutoEnter mon(mMonitor);
 
         mMaxConns = maxConns;
         mMaxConnsPerHost = maxConnsPerHost;
         mMaxConnsPerProxy = maxConnsPerProxy;
         mMaxPersistConnsPerHost = maxPersistConnsPerHost;
         mMaxPersistConnsPerProxy = maxPersistConnsPerProxy;
         mMaxRequestDelay = maxRequestDelay;
         mMaxPipelinedRequests = maxPipelinedRequests;
@@ -156,17 +154,17 @@ nsHttpConnectionMgr::Init(PRUint16 maxCo
     return EnsureSocketThreadTargetIfOnline();
 }
 
 nsresult
 nsHttpConnectionMgr::Shutdown()
 {
     LOG(("nsHttpConnectionMgr::Shutdown\n"));
 
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
 
     // do nothing if already shutdown
     if (!mSocketThreadTarget)
         return NS_OK;
 
     nsresult rv = PostEvent(&nsHttpConnectionMgr::OnMsgShutdown);
 
     // release our reference to the STS to prevent further events
@@ -189,17 +187,17 @@ nsresult
 nsHttpConnectionMgr::PostEvent(nsConnEventHandler handler, PRInt32 iparam, void *vparam)
 {
     // This object doesn't get reinitialized if the offline state changes, so our
     // socket thread target might be uninitialized if we were offline when this
     // object was being initialized, and we go online later on.  This call takes
     // care of initializing the socket thread target if that's the case.
     EnsureSocketThreadTargetIfOnline();
 
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
 
     nsresult rv;
     if (!mSocketThreadTarget) {
         NS_WARNING("cannot post event if not initialized");
         rv = NS_ERROR_NOT_INITIALIZED;
     }
     else {
         nsRefPtr<nsIRunnable> event = new nsConnEvent(this, handler, iparam, vparam);
@@ -314,17 +312,17 @@ nsresult
 nsHttpConnectionMgr::GetSocketThreadTarget(nsIEventTarget **target)
 {
     // This object doesn't get reinitialized if the offline state changes, so our
     // socket thread target might be uninitialized if we were offline when this
     // object was being initialized, and we go online later on.  This call takes
     // care of initializing the socket thread target if that's the case.
     EnsureSocketThreadTargetIfOnline();
 
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
     NS_IF_ADDREF(*target = mSocketThreadTarget);
     return NS_OK;
 }
 
 void
 nsHttpConnectionMgr::AddTransactionToPipeline(nsHttpPipeline *pipeline)
 {
     LOG(("nsHttpConnectionMgr::AddTransactionToPipeline [pipeline=%x]\n", pipeline));
@@ -872,17 +870,17 @@ nsHttpConnectionMgr::ProcessNewTransacti
 void
 nsHttpConnectionMgr::OnMsgShutdown(PRInt32, void *)
 {
     LOG(("nsHttpConnectionMgr::OnMsgShutdown\n"));
 
     mCT.Reset(ShutdownPassCB, this);
 
     // signal shutdown complete
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
     mon.Notify();
 }
 
 void
 nsHttpConnectionMgr::OnMsgNewTransaction(PRInt32 priority, void *param)
 {
     LOG(("nsHttpConnectionMgr::OnMsgNewTransaction [trans=%p]\n", param));
 
--- a/netwerk/protocol/http/nsHttpConnectionMgr.h
+++ b/netwerk/protocol/http/nsHttpConnectionMgr.h
@@ -41,17 +41,17 @@
 
 #include "nsHttpConnectionInfo.h"
 #include "nsHttpConnection.h"
 #include "nsHttpTransaction.h"
 #include "nsTArray.h"
 #include "nsThreadUtils.h"
 #include "nsHashtable.h"
 #include "nsAutoPtr.h"
-#include "prmon.h"
+#include "mozilla/Monitor.h"
 
 #include "nsIObserver.h"
 #include "nsITimer.h"
 
 class nsHttpPipeline;
 
 //-----------------------------------------------------------------------------
 
@@ -182,17 +182,17 @@ private:
         nsHttpConnection *mConn;
     };
 
     //-------------------------------------------------------------------------
     // NOTE: these members may be accessed from any thread (use mMonitor)
     //-------------------------------------------------------------------------
 
     PRInt32                      mRef;
-    PRMonitor                   *mMonitor;
+    mozilla::Monitor             mMonitor;
     nsCOMPtr<nsIEventTarget>     mSocketThreadTarget;
 
     // connection limits
     PRUint16 mMaxConns;
     PRUint16 mMaxConnsPerHost;
     PRUint16 mMaxConnsPerProxy;
     PRUint16 mMaxPersistConnsPerHost;
     PRUint16 mMaxPersistConnsPerProxy;
--- a/netwerk/protocol/http/nsHttpHandler.cpp
+++ b/netwerk/protocol/http/nsHttpHandler.cpp
@@ -64,17 +64,16 @@
 #include "nsIPrefService.h"
 #include "nsIPrefBranch2.h"
 #include "nsIPrefLocalizedString.h"
 #include "nsISocketProviderService.h"
 #include "nsISocketProvider.h"
 #include "nsPrintfCString.h"
 #include "nsCOMPtr.h"
 #include "nsNetCID.h"
-#include "nsAutoLock.h"
 #include "prprf.h"
 #include "nsReadableUtils.h"
 #include "nsQuickSort.h"
 #include "nsNetUtil.h"
 #include "nsIOService.h"
 #include "nsAsyncRedirectVerifyHelper.h"
 #include "nsSocketTransportService2.h"
 
--- a/netwerk/protocol/http/nsHttpPipeline.cpp
+++ b/netwerk/protocol/http/nsHttpPipeline.cpp
@@ -42,17 +42,16 @@
 #include "nsHttpHandler.h"
 #include "nsIOService.h"
 #include "nsIRequest.h"
 #include "nsISocketTransport.h"
 #include "nsIStringStream.h"
 #include "nsIPipe.h"
 #include "nsCOMPtr.h"
 #include "nsComponentManagerUtils.h"
-#include "nsAutoLock.h"
 
 #ifdef DEBUG
 #include "prthread.h"
 // defined by the socket transport service while active
 extern PRThread *gSocketThread;
 #endif
 
 //-----------------------------------------------------------------------------
--- a/netwerk/protocol/http/nsHttpTransaction.cpp
+++ b/netwerk/protocol/http/nsHttpTransaction.cpp
@@ -48,17 +48,16 @@
 #include "nsHttpConnection.h"
 #include "nsHttpRequestHead.h"
 #include "nsHttpResponseHead.h"
 #include "nsHttpChunkedDecoder.h"
 #include "nsTransportUtils.h"
 #include "nsNetUtil.h"
 #include "nsProxyRelease.h"
 #include "nsIOService.h"
-#include "nsAutoLock.h"
 #include "nsAtomicRefcnt.h"
 
 #include "nsISeekableStream.h"
 #include "nsISocketTransport.h"
 #include "nsMultiplexInputStream.h"
 #include "nsStringStream.h"
 
 #include "nsComponentManagerUtils.h" // do_CreateInstance
--- a/netwerk/protocol/res/nsResProtocolHandler.cpp
+++ b/netwerk/protocol/res/nsResProtocolHandler.cpp
@@ -38,17 +38,16 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifdef MOZ_IPC
 #include "mozilla/chrome/RegistryMessageUtils.h"
 #endif
 
 #include "nsResProtocolHandler.h"
-#include "nsAutoLock.h"
 #include "nsIURL.h"
 #include "nsIIOService.h"
 #include "nsIServiceManager.h"
 #include "nsILocalFile.h"
 #include "prenv.h"
 #include "prmem.h"
 #include "prprf.h"
 #include "nsXPIDLString.h"
--- a/netwerk/wifi/nsWifiMonitor.cpp
+++ b/netwerk/wifi/nsWifiMonitor.cpp
@@ -38,66 +38,64 @@
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsCOMPtr.h"
 #include "nsComponentManagerUtils.h"
 #include "nsServiceManagerUtils.h"
 #include "nsThreadUtils.h"
 #include "nsXPCOM.h"
 #include "nsXPCOMCID.h"
-#include "nsAutoLock.h"
 #include "nsIObserver.h"
 #include "nsIObserverService.h"
 #include "nsWifiMonitor.h"
 
 #include "nsIProxyObjectManager.h"
 #include "nsServiceManagerUtils.h"
 #include "nsComponentManagerUtils.h"
 #include "mozilla/Services.h"
 
+using namespace mozilla;
+
 #if defined(PR_LOGGING)
 PRLogModuleInfo *gWifiMonitorLog;
 #endif
 
 NS_IMPL_THREADSAFE_ISUPPORTS3(nsWifiMonitor,
                               nsIRunnable,
                               nsIObserver,
                               nsIWifiMonitor)
 
 nsWifiMonitor::nsWifiMonitor()
 : mKeepGoing(PR_TRUE)
+, mMonitor("nsWifiMonitor.mMonitor")
 {
 #if defined(PR_LOGGING)
   gWifiMonitorLog = PR_NewLogModule("WifiMonitor");
 #endif
 
-  mMonitor = nsAutoMonitor::NewMonitor("nsWifiMonitor");
-
   nsCOMPtr<nsIObserverService> obsSvc = mozilla::services::GetObserverService();
   if (obsSvc)
     obsSvc->AddObserver(this, "xpcom-shutdown", PR_FALSE);
 
   LOG(("@@@@@ wifimonitor created\n"));
 }
 
 nsWifiMonitor::~nsWifiMonitor()
 {
-  if (mMonitor)
-    nsAutoMonitor::DestroyMonitor(mMonitor);
 }
 
 NS_IMETHODIMP
 nsWifiMonitor::Observe(nsISupports *subject, const char *topic,
                      const PRUnichar *data)
 {
   if (!strcmp(topic, "xpcom-shutdown")) {
     LOG(("Shutting down\n"));
     mKeepGoing = PR_FALSE;
 
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
     mon.Notify();
   }
   return NS_OK;
 }
 
 
 NS_IMETHODIMP nsWifiMonitor::StartWatching(nsIWifiListener *aListener)
 {
@@ -106,17 +104,17 @@ NS_IMETHODIMP nsWifiMonitor::StartWatchi
 
   nsresult rv = NS_OK;
   if (!mThread) {
     rv = NS_NewThread(getter_AddRefs(mThread), this);
     if (NS_FAILED(rv))
       return rv;
   }
 
-  nsAutoMonitor mon(mMonitor);
+  MonitorAutoEnter mon(mMonitor);
 
   mKeepGoing = PR_TRUE;
 
   mListeners.AppendElement(nsWifiListener(aListener));
 
   // tell ourselves that we have a new watcher.
   mon.Notify();
   return NS_OK;
@@ -124,17 +122,17 @@ NS_IMETHODIMP nsWifiMonitor::StartWatchi
 
 NS_IMETHODIMP nsWifiMonitor::StopWatching(nsIWifiListener *aListener)
 {
   if (!aListener)
     return NS_ERROR_NULL_POINTER;
 
   LOG(("removing listener\n"));
 
-  nsAutoMonitor mon(mMonitor);
+  MonitorAutoEnter mon(mMonitor);
 
   for (PRUint32 i = 0; i < mListeners.Length(); i++) {
 
     if (mListeners[i].mListener == aListener) {
       mListeners.RemoveElementAt(i);
       break;
     }
   }
--- a/netwerk/wifi/nsWifiMonitor.h
+++ b/netwerk/wifi/nsWifiMonitor.h
@@ -35,22 +35,21 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsIWifiMonitor.h"
 #include "nsCOMPtr.h"
 #include "nsAutoPtr.h"
-#include "nsAutoLock.h"
 #include "nsIThread.h"
 #include "nsIRunnable.h"
 #include "nsCOMArray.h"
 #include "nsIWifiMonitor.h"
-#include "prmon.h"
+#include "mozilla/Monitor.h"
 #include "prlog.h"
 #include "nsIObserver.h"
 #include "nsTArray.h"
 
 #ifndef __nsWifiMonitor__
 #define __nsWifiMonitor__
 
 #if defined(PR_LOGGING)
@@ -93,13 +92,13 @@ class nsWifiMonitor : nsIRunnable, nsIWi
   nsresult DoScanOld();
 #endif
 
   PRBool mKeepGoing;
   nsCOMPtr<nsIThread> mThread;
 
   nsTArray<nsWifiListener> mListeners;
 
-  PRMonitor* mMonitor;
+  mozilla::Monitor mMonitor;
 
 };
 
 #endif
--- a/netwerk/wifi/nsWifiScannerMac.cpp
+++ b/netwerk/wifi/nsWifiScannerMac.cpp
@@ -48,16 +48,18 @@
 #include "nsWifiMonitor.h"
 #include "nsWifiAccessPoint.h"
 
 #include "nsIProxyObjectManager.h"
 #include "nsServiceManagerUtils.h"
 #include "nsComponentManagerUtils.h"
 #include "nsIMutableArray.h"
 
+using namespace mozilla;
+
 // defined in osx_corewlan.mm
 // basically relaces accesspoints in the passed reference
 // it lives in a separate file so that we can use objective c.
 extern nsresult GetAccessPointsFromWLAN(nsCOMArray<nsWifiAccessPoint> &accessPoints);
 
 nsresult
 nsWifiMonitor::DoScanWithCoreWLAN()
 {
@@ -70,17 +72,17 @@ nsWifiMonitor::DoScanWithCoreWLAN()
     nsresult rv = GetAccessPointsFromWLAN(accessPoints);
     if (NS_FAILED(rv))
       return rv;
 
     PRBool accessPointsChanged = !AccessPointsEqual(accessPoints, lastAccessPoints);
     nsCOMArray<nsIWifiListener> currentListeners;
 
     {
-      nsAutoMonitor mon(mMonitor);
+      MonitorAutoEnter mon(mMonitor);
 
       for (PRUint32 i = 0; i < mListeners.Length(); i++) {
         if (!mListeners[i].mHasSentData || accessPointsChanged) {
           mListeners[i].mHasSentData = PR_TRUE;
           currentListeners.AppendObject(mListeners[i].mListener);
         }
       }
     }
@@ -120,17 +122,17 @@ nsWifiMonitor::DoScanWithCoreWLAN()
       }
 
       nsMemory::Free(result);
     }
 
     // wait for some reasonable amount of time.  pref?
     LOG(("waiting on monitor\n"));
 
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
     mon.Wait(PR_SecondsToInterval(60));
   }
   while (mKeepGoing);
 
   return NS_OK;
 }
 
 nsresult
@@ -205,17 +207,17 @@ nsWifiMonitor::DoScanOld()
 
       accessPoints.AppendObject(ap);
     }
 
     PRBool accessPointsChanged = !AccessPointsEqual(accessPoints, lastAccessPoints);
     nsCOMArray<nsIWifiListener> currentListeners;
 
     {
-      nsAutoMonitor mon(mMonitor);
+      MonitorAutoEnter mon(mMonitor);
 
       for (PRUint32 i = 0; i < mListeners.Length(); i++) {
         if (!mListeners[i].mHasSentData || accessPointsChanged) {
           mListeners[i].mHasSentData = PR_TRUE;
           currentListeners.AppendObject(mListeners[i].mListener);
         }
       }
     }
@@ -256,17 +258,17 @@ nsWifiMonitor::DoScanOld()
       }
 
       nsMemory::Free(result);
     }
 
     // wait for some reasonable amount of time.  pref?
     LOG(("waiting on monitor\n"));
 
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
     mon.Wait(PR_SecondsToInterval(60));
   }
   while (mKeepGoing);
 
   (*WirelessDetach_function_)(wifi_context_);
 
   dlclose(apple_80211_library);
 
--- a/netwerk/wifi/nsWifiScannerUnix.cpp
+++ b/netwerk/wifi/nsWifiScannerUnix.cpp
@@ -36,26 +36,25 @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "iwlib.h"
 
 #include "dlfcn.h"
 
-#include "nsAutoPtr.h"
 #include "nsWifiMonitor.h"
 #include "nsWifiAccessPoint.h"
 
 #include "nsIProxyObjectManager.h"
 #include "nsServiceManagerUtils.h"
 #include "nsComponentManagerUtils.h"
 #include "nsIMutableArray.h"
 
-
+using namespace mozilla;
 
 
 typedef int (*iw_open_t)(void);
 
 typedef void (*iw_enum_t)(int	skfd,
 			  iw_enum_handler fn,
 			  char *args[],
 			  int count);
@@ -166,17 +165,17 @@ nsWifiMonitor::DoScan()
     accessPoints.Clear();
 
     (*iw_enum)(skfd, &scan_wifi, args, 1);
 
     PRBool accessPointsChanged = !AccessPointsEqual(accessPoints, lastAccessPoints);
     nsCOMArray<nsIWifiListener> currentListeners;
 
     {
-      nsAutoMonitor mon(mMonitor);
+      MonitorAutoEnter mon(mMonitor);
 
       for (PRUint32 i = 0; i < mListeners.Length(); i++) {
         if (!mListeners[i].mHasSentData || accessPointsChanged) {
           mListeners[i].mHasSentData = PR_TRUE;
           currentListeners.AppendObject(mListeners[i].mListener);
         }
       }
     }
@@ -216,16 +215,16 @@ nsWifiMonitor::DoScan()
         }
       }
 
       nsMemory::Free(result);
     }
 
     LOG(("waiting on monitor\n"));
 
-    nsAutoMonitor mon(mMonitor);
+    MonitorAutoEnter mon(mMonitor);
     mon.Wait(PR_SecondsToInterval(60));
   }
 
   iw_sockets_close(skfd);
 
   return NS_OK;
 }
--- a/netwerk/wifi/nsWifiScannerWin.cpp
+++ b/netwerk/wifi/nsWifiScannerWin.cpp
@@ -41,25 +41,26 @@
 
 #include "windows.h"
 #include "wlanapi.h"
 
 #include <ntddndis.h>
 #include "winioctl.h"
 #include "stdlib.h"
 
-#include "nsAutoPtr.h"
 #include "nsWifiMonitor.h"
 #include "nsWifiAccessPoint.h"
 
 #include "nsIProxyObjectManager.h"
 #include "nsServiceManagerUtils.h"
 #include "nsComponentManagerUtils.h"
 #include "nsIMutableArray.h"
 
+using namespace mozilla;
+
 nsresult
 nsWifiMonitor::DoScan()
 {
     HINSTANCE wlan_library = LoadLibrary("Wlanapi.dll");
     if (!wlan_library)
       return NS_ERROR_NOT_AVAILABLE;
 
     WlanOpenHandleFunction WlanOpenHandle = (WlanOpenHandleFunction) GetProcAddress(wlan_library, "WlanOpenHandle");
@@ -148,17 +149,17 @@ nsWifiMonitor::DoScan()
       // Close the handle.
       (*WlanCloseHandle)(wlan_handle, NULL);
 
 
       PRBool accessPointsChanged = !AccessPointsEqual(accessPoints, lastAccessPoints);
       nsCOMArray<nsIWifiListener> currentListeners;
 
       {
-        nsAutoMonitor mon(mMonitor);
+        MonitorAutoEnter mon(mMonitor);
 
         for (PRUint32 i = 0; i < mListeners.Length(); i++) {
           if (!mListeners[i].mHasSentData || accessPointsChanged) {
             mListeners[i].mHasSentData = PR_TRUE;
             currentListeners.AppendObject(mListeners[i].mListener);
           }
         }
       }
@@ -196,15 +197,15 @@ nsWifiMonitor::DoScan()
         }
 
         nsMemory::Free(result);
       }
 
       // wait for some reasonable amount of time.  pref?
       LOG(("waiting on monitor\n"));
 
-      nsAutoMonitor mon(mMonitor);
+      MonitorAutoEnter mon(mMonitor);
       mon.Wait(PR_SecondsToInterval(60));
     }
     while (mKeepGoing);
 
     return NS_OK;
 }
--- a/parser/htmlparser/src/nsParser.cpp
+++ b/parser/htmlparser/src/nsParser.cpp
@@ -49,17 +49,16 @@
 #include "nsICacheEntryDescriptor.h"
 #include "nsICharsetAlias.h"
 #include "nsICharsetConverterManager.h"
 #include "nsIInputStream.h"
 #include "CNavDTD.h"
 #include "prenv.h"
 #include "prlock.h"
 #include "prcvar.h"
-#include "nsAutoLock.h"
 #include "nsParserCIID.h"
 #include "nsReadableUtils.h"
 #include "nsCOMPtr.h"
 #include "nsExpatDriver.h"
 #include "nsIServiceManager.h"
 #include "nsICategoryManager.h"
 #include "nsISupportsPrimitives.h"
 #include "nsIFragmentContentSink.h"
@@ -68,16 +67,20 @@
 #include "nsIDocument.h"
 #include "nsNetUtil.h"
 #include "nsScriptLoader.h"
 #include "nsDataHashtable.h"
 #include "nsIThreadPool.h"
 #include "nsXPCOMCIDInternal.h"
 #include "nsMimeTypes.h"
 #include "nsViewSourceHTML.h"
+#include "mozilla/CondVar.h"
+#include "mozilla/Mutex.h"
+
+using namespace mozilla;
 
 #define NS_PARSER_FLAG_PARSER_ENABLED         0x00000002
 #define NS_PARSER_FLAG_OBSERVERS_ENABLED      0x00000004
 #define NS_PARSER_FLAG_PENDING_CONTINUE_EVENT 0x00000008
 #define NS_PARSER_FLAG_CAN_INTERRUPT          0x00000010
 #define NS_PARSER_FLAG_FLUSH_TOKENS           0x00000020
 #define NS_PARSER_FLAG_CAN_TOKENIZE           0x00000040
 
@@ -193,18 +196,18 @@ public:
 private:
   Type *mHoldee;
   Reaper mReaper;
 };
 
 class nsSpeculativeScriptThread : public nsIRunnable {
 public:
   nsSpeculativeScriptThread()
-    : mLock(nsAutoLock::DestroyLock),
-      mCVar(PR_DestroyCondVar),
+    : mLock("nsSpeculativeScriptThread.mLock"),
+      mCVar(mLock, "nsSpeculativeScriptThread.mCVar"),
       mKeepParsing(PR_FALSE),
       mCurrentlyParsing(PR_FALSE),
       mNumConsumed(0),
       mContext(nsnull),
       mTerminated(PR_FALSE) {
   }
 
   ~nsSpeculativeScriptThread() {
@@ -263,18 +266,18 @@ private:
 
   void FlushURIs();
 
   // These members are only accessed on the speculatively parsing thread.
   nsTokenAllocator mTokenAllocator;
 
   // The following members are shared across the main thread and the
   // speculatively parsing thread.
-  Holder<PRLock> mLock;
-  Holder<PRCondVar> mCVar;
+  Mutex mLock;
+  CondVar mCVar;
 
   volatile PRBool mKeepParsing;
   volatile PRBool mCurrentlyParsing;
   nsRefPtr<nsHTMLTokenizer> mTokenizer;
   nsAutoPtr<nsScanner> mScanner;
 
   enum { kBatchPrefetchURIs = 5 };
   nsAutoTArray<PrefetchEntry, kBatchPrefetchURIs> mURIs;
@@ -407,20 +410,20 @@ nsSpeculativeScriptThread::Run()
     // gathered so far so we don't end up waiting for the parser's current
     // load to finish.
     if (!mURIs.IsEmpty()) {
       FlushURIs();
     }
   }
 
   {
-    nsAutoLock al(mLock.get());
+    MutexAutoLock al(mLock);
 
     mCurrentlyParsing = PR_FALSE;
-    PR_NotifyCondVar(mCVar.get());
+    mCVar.Notify();
   }
   return NS_OK;
 }
 
 nsresult
 nsSpeculativeScriptThread::StartParsing(nsParser *aParser)
 {
   NS_ASSERTION(NS_IsMainThread(), "Called on the wrong thread");
@@ -437,27 +440,17 @@ nsSpeculativeScriptThread::StartParsing(
 
   nsCOMPtr<nsIDocument> doc = do_QueryInterface(sink->GetTarget());
   if (!doc) {
     return NS_OK;
   }
 
   nsAutoString toScan;
   CParserContext *context = aParser->PeekContext();
-  if (!mLock.get()) {
-    mLock = nsAutoLock::NewLock("nsSpeculativeScriptThread::mLock");
-    if (!mLock.get()) {
-      return NS_ERROR_OUT_OF_MEMORY;
-    }
-
-    mCVar = PR_NewCondVar(mLock.get());
-    if (!mCVar.get()) {
-      return NS_ERROR_OUT_OF_MEMORY;
-    }
-
+  if (!mTokenizer) {
     if (!mPreloadedURIs.Init(15)) {
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
     mTokenizer = new nsHTMLTokenizer(context->mDTDMode, context->mDocType,
                                      context->mParserCommand, 0);
     if (!mTokenizer) {
       return NS_ERROR_OUT_OF_MEMORY;
@@ -514,27 +507,22 @@ nsSpeculativeScriptThread::StartParsing(
   return aParser->ThreadPool()->Dispatch(this, NS_DISPATCH_NORMAL);
 }
 
 void
 nsSpeculativeScriptThread::StopParsing(PRBool /*aFromDocWrite*/)
 {
   NS_ASSERTION(NS_IsMainThread(), "Can't stop parsing from another thread");
 
-  if (!mLock.get()) {
-    // If we bailed early out of StartParsing, don't do anything.
-    return;
-  }
-
   {
-    nsAutoLock al(mLock.get());
+    MutexAutoLock al(mLock);
 
     mKeepParsing = PR_FALSE;
     if (mCurrentlyParsing) {
-      PR_WaitCondVar(mCVar.get(), PR_INTERVAL_NO_TIMEOUT);
+      mCVar.Wait();
       NS_ASSERTION(!mCurrentlyParsing, "Didn't actually stop parsing?");
     }
   }
 
   // The thread is now idle.
   if (mTerminated) {
     // If we're terminated, then we need to ensure that we release our document
     // and tokenizer here on the main thread so that our last reference to them
--- a/security/manager/boot/src/nsSecureBrowserUIImpl.cpp
+++ b/security/manager/boot/src/nsSecureBrowserUIImpl.cpp
@@ -80,17 +80,18 @@
 #include "nsISecurityWarningDialogs.h"
 #include "nsISecurityInfoProvider.h"
 #include "nsIProxyObjectManager.h"
 #include "imgIRequest.h"
 #include "nsThreadUtils.h"
 #include "nsNetUtil.h"
 #include "nsNetCID.h"
 #include "nsCRT.h"
-#include "nsAutoLock.h"
+
+using namespace mozilla;
 
 #define SECURITY_STRING_BUNDLE_URL "chrome://pipnss/locale/security.properties"
 
 #define IS_SECURE(state) ((state & 0xFFFF) == STATE_IS_SECURE)
 
 #if defined(PR_LOGGING)
 //
 // Log module for nsSecureBrowserUI logging...
@@ -154,48 +155,46 @@ class nsAutoAtomic {
     PRInt32 &mI;
 
   private:
     nsAutoAtomic(); // not accessible
 };
 #endif
 
 nsSecureBrowserUIImpl::nsSecureBrowserUIImpl()
-  : mNotifiedSecurityState(lis_no_security)
+  : mMonitor("nsSecureBrowserUIImpl.mMonitor")
+  , mNotifiedSecurityState(lis_no_security)
   , mNotifiedToplevelIsEV(PR_FALSE)
   , mNewToplevelSecurityState(STATE_IS_INSECURE)
   , mNewToplevelIsEV(PR_FALSE)
   , mNewToplevelSecurityStateKnown(PR_TRUE)
   , mIsViewSource(PR_FALSE)
   , mSubRequestsHighSecurity(0)
   , mSubRequestsLowSecurity(0)
   , mSubRequestsBrokenSecurity(0)
   , mSubRequestsNoSecurity(0)
 #ifdef DEBUG
   , mOnStateLocationChangeReentranceDetection(0)
 #endif
 {
-  mMonitor = nsAutoMonitor::NewMonitor("security.secureBrowserUIImplMonitor");
   mTransferringRequests.ops = nsnull;
   ResetStateTracking();
   
 #if defined(PR_LOGGING)
   if (!gSecureDocLog)
     gSecureDocLog = PR_NewLogModule("nsSecureBrowserUI");
 #endif /* PR_LOGGING */
 }
 
 nsSecureBrowserUIImpl::~nsSecureBrowserUIImpl()
 {
   if (mTransferringRequests.ops) {
     PL_DHashTableFinish(&mTransferringRequests);
     mTransferringRequests.ops = nsnull;
   }
-  if (mMonitor)
-    nsAutoMonitor::DestroyMonitor(mMonitor);
 }
 
 NS_IMPL_THREADSAFE_ISUPPORTS6(nsSecureBrowserUIImpl,
                               nsISecureBrowserUI,
                               nsIWebProgressListener,
                               nsIFormSubmitObserver,
                               nsIObserver,
                               nsISupportsWeakReference,
@@ -273,17 +272,17 @@ nsSecureBrowserUIImpl::Init(nsIDOMWindow
 
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsSecureBrowserUIImpl::GetState(PRUint32* aState)
 {
-  nsAutoMonitor lock(mMonitor);
+  MonitorAutoEnter lock(mMonitor);
   return MapInternalToExternalState(aState, mNotifiedSecurityState, mNotifiedToplevelIsEV);
 }
 
 // static
 already_AddRefed<nsISupports> 
 nsSecureBrowserUIImpl::ExtractSecurityInfo(nsIRequest* aRequest)
 {
   nsISupports *retval = nsnull; 
@@ -337,17 +336,17 @@ nsSecureBrowserUIImpl::MapInternalToExte
 
 NS_IMETHODIMP
 nsSecureBrowserUIImpl::GetTooltipText(nsAString& aText)
 {
   lockIconState state;
   nsXPIDLString tooltip;
 
   {
-    nsAutoMonitor lock(mMonitor);
+    MonitorAutoEnter lock(mMonitor);
     state = mNotifiedSecurityState;
     tooltip = mInfoTooltip;
   }
 
   if (state == lis_mixed_security)
   {
     GetBundleString(NS_LITERAL_STRING("SecurityButtonMixedContentTooltipText").get(),
                     aText);
@@ -456,17 +455,17 @@ nsSecureBrowserUIImpl::Notify(nsIDOMHTML
   {
     NS_WARNING("If you see this and can explain why it should be allowed, note in Bug 332324");
     *cancelSubmit = PR_TRUE;
     return NS_OK;
   }
 
   nsCOMPtr<nsIDOMWindow> window;
   {
-    nsAutoMonitor lock(mMonitor);
+    MonitorAutoEnter lock(mMonitor);
     window = do_QueryReferent(mWindow);
     NS_ASSERTION(window, "Window has gone away?!");
   }
 
   PRBool isChild;
   IsChildOfDomWindow(window, postingWindow, &isChild);
   
   // This notify call is not for our window, ignore it.
@@ -492,17 +491,17 @@ nsSecureBrowserUIImpl::OnProgressChange(
                                         PRInt32 aMaxTotalProgress)
 {
   NS_NOTREACHED("notification excluded in AddProgressListener(...)");
   return NS_OK;
 }
 
 void nsSecureBrowserUIImpl::ResetStateTracking()
 {
-  nsAutoMonitor lock(mMonitor);
+  MonitorAutoEnter lock(mMonitor);
 
   mInfoTooltip.Truncate();
   mDocumentRequestsInProgress = 0;
   if (mTransferringRequests.ops) {
     PL_DHashTableFinish(&mTransferringRequests);
     mTransferringRequests.ops = nsnull;
   }
   PL_DHashTableInit(&mTransferringRequests, &gMapOps, nsnull,
@@ -554,17 +553,17 @@ nsSecureBrowserUIImpl::EvaluateAndUpdate
         }
       }
     }
 
   // assume temp_NewToplevelSecurityState was set in this scope!
   // see code that is directly above
 
   {
-    nsAutoMonitor lock(mMonitor);
+    MonitorAutoEnter lock(mMonitor);
     mNewToplevelSecurityStateKnown = PR_TRUE;
     mNewToplevelSecurityState = temp_NewToplevelSecurityState;
     mNewToplevelIsEV = temp_NewToplevelIsEV;
     if (updateStatus) {
       mSSLStatus = temp_SSLStatus;
     }
     if (updateTooltip) {
       mInfoTooltip = temp_InfoTooltip;
@@ -587,17 +586,17 @@ nsSecureBrowserUIImpl::EvaluateAndUpdate
 void
 nsSecureBrowserUIImpl::UpdateSubrequestMembers(nsISupports *securityInfo)
 {
   // For wyciwyg channels in subdocuments we only update our
   // subrequest state members.
   PRUint32 reqState = GetSecurityStateFromSecurityInfo(securityInfo);
 
   // the code above this line should run without a lock
-  nsAutoMonitor lock(mMonitor);
+  MonitorAutoEnter lock(mMonitor);
 
   if (reqState & STATE_IS_SECURE) {
     if (reqState & STATE_SECURE_LOW || reqState & STATE_SECURE_MED) {
       PR_LOG(gSecureDocLog, PR_LOG_DEBUG,
              ("SecureUI:%p: OnStateChange: subreq LOW\n", this));
       ++mSubRequestsLowSecurity;
     } else {
       PR_LOG(gSecureDocLog, PR_LOG_DEBUG,
@@ -720,29 +719,29 @@ nsSecureBrowserUIImpl::OnStateChange(nsI
   aWebProgress->GetDOMWindow(getter_AddRefs(windowForProgress));
 
   nsCOMPtr<nsIDOMWindow> window;
   PRBool isViewSource;
 
   nsCOMPtr<nsINetUtil> ioService;
 
   {
-    nsAutoMonitor lock(mMonitor);
+    MonitorAutoEnter lock(mMonitor);
     window = do_QueryReferent(mWindow);
     NS_ASSERTION(window, "Window has gone away?!");
     isViewSource = mIsViewSource;
     ioService = mIOService;
   }
 
   if (!ioService)
   {
     ioService = do_GetService(NS_IOSERVICE_CONTRACTID);
     if (ioService)
     {
-      nsAutoMonitor lock(mMonitor);
+      MonitorAutoEnter lock(mMonitor);
       mIOService = ioService;
     }
   }
 
   PRBool isNoContentResponse = PR_FALSE;
   nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aRequest);
   if (httpChannel) 
   {
@@ -1009,30 +1008,30 @@ nsSecureBrowserUIImpl::OnStateChange(nsI
 
   if (aProgressStateFlags & STATE_TRANSFERRING
       &&
       aProgressStateFlags & STATE_IS_REQUEST)
   {
     // The listing of a request in mTransferringRequests
     // means, there has already been data transfered.
 
-    nsAutoMonitor lock(mMonitor);
+    MonitorAutoEnter lock(mMonitor);
     PL_DHashTableOperate(&mTransferringRequests, aRequest, PL_DHASH_ADD);
     
     return NS_OK;
   }
 
   PRBool requestHasTransferedData = PR_FALSE;
 
   if (aProgressStateFlags & STATE_STOP
       &&
       aProgressStateFlags & STATE_IS_REQUEST)
   {
-    { /* scope for the nsAutoMonitor */
-      nsAutoMonitor lock(mMonitor);
+    { /* scope for the MonitorAutoEnter */
+      MonitorAutoEnter lock(mMonitor);
       PLDHashEntryHdr *entry = PL_DHashTableOperate(&mTransferringRequests, aRequest, PL_DHASH_LOOKUP);
       if (PL_DHASH_ENTRY_IS_BUSY(entry))
       {
         PL_DHashTableOperate(&mTransferringRequests, aRequest, PL_DHASH_REMOVE);
 
         requestHasTransferedData = PR_TRUE;
       }
     }
@@ -1080,17 +1079,17 @@ nsSecureBrowserUIImpl::OnStateChange(nsI
     nsCOMPtr<nsIAssociatedContentSecurity> prevContentSecurity;
 
     PRInt32 newSubHigh = 0;
     PRInt32 newSubLow = 0;
     PRInt32 newSubBroken = 0;
     PRInt32 newSubNo = 0;
 
     {
-      nsAutoMonitor lock(mMonitor);
+      MonitorAutoEnter lock(mMonitor);
       inProgress = (mDocumentRequestsInProgress!=0);
 
       if (allowSecurityStateChange && !inProgress)
       {
         saveSubHigh = mSubRequestsHighSecurity;
         saveSubLow = mSubRequestsLowSecurity;
         saveSubBroken = mSubRequestsBrokenSecurity;
         saveSubNo = mSubRequestsNoSecurity;
@@ -1150,17 +1149,17 @@ nsSecureBrowserUIImpl::OnStateChange(nsI
           newContentSecurity->GetCountSubRequestsLowSecurity(&newSubLow);
           newContentSecurity->GetCountSubRequestsBrokenSecurity(&newSubBroken);
           newContentSecurity->GetCountSubRequestsNoSecurity(&newSubNo);
         }
       }
     }
 
     {
-      nsAutoMonitor lock(mMonitor);
+      MonitorAutoEnter lock(mMonitor);
 
       if (allowSecurityStateChange && !inProgress)
       {
         ResetStateTracking();
         mSubRequestsHighSecurity = newSubHigh;
         mSubRequestsLowSecurity = newSubLow;
         mSubRequestsBrokenSecurity = newSubBroken;
         mSubRequestsNoSecurity = newSubNo;
@@ -1186,17 +1185,17 @@ nsSecureBrowserUIImpl::OnStateChange(nsI
       isToplevelProgress
       &&
       loadFlags & nsIChannel::LOAD_DOCUMENT_URI)
   {
     PRInt32 temp_DocumentRequestsInProgress;
     nsCOMPtr<nsISecurityEventSink> temp_ToplevelEventSink;
 
     {
-      nsAutoMonitor lock(mMonitor);
+      MonitorAutoEnter lock(mMonitor);
       temp_DocumentRequestsInProgress = mDocumentRequestsInProgress;
       if (allowSecurityStateChange)
       {
         temp_ToplevelEventSink = mToplevelEventSink;
       }
     }
 
     if (temp_DocumentRequestsInProgress <= 0)
@@ -1214,17 +1213,17 @@ nsSecureBrowserUIImpl::OnStateChange(nsI
     {
       if (allowSecurityStateChange)
       {
         ObtainEventSink(channel, temp_ToplevelEventSink);
       }
     }
 
     {
-      nsAutoMonitor lock(mMonitor);
+      MonitorAutoEnter lock(mMonitor);
       if (allowSecurityStateChange)
       {
         mToplevelEventSink = temp_ToplevelEventSink;
       }
       --mDocumentRequestsInProgress;
     }
 
     if (allowSecurityStateChange && requestHasTransferedData) {
@@ -1259,17 +1258,17 @@ nsSecureBrowserUIImpl::OnStateChange(nsI
       // At this point, we are learning about the security state of a sub-document.
       // We must not update the security state based on the sub content,
       // if the new top level state is not yet known.
       //
       // We skip updating the security state in this case.
 
       PRBool temp_NewToplevelSecurityStateKnown;
       {
-        nsAutoMonitor lock(mMonitor);
+        MonitorAutoEnter lock(mMonitor);
         temp_NewToplevelSecurityStateKnown = mNewToplevelSecurityStateKnown;
       }
 
       if (temp_NewToplevelSecurityStateKnown)
         return UpdateSecurityState(aRequest, PR_FALSE, PR_FALSE, PR_FALSE);
     }
 
     return NS_OK;
@@ -1305,17 +1304,17 @@ nsresult nsSecureBrowserUIImpl::UpdateSe
   return rv;
 }
 
 // must not fail, by definition, only trivial assignments
 // or string operations are allowed
 // returns true if our overall state has changed and we must send out notifications
 PRBool nsSecureBrowserUIImpl::UpdateMyFlags(PRBool &showWarning, lockIconState &warnSecurityState)
 {
-  nsAutoMonitor lock(mMonitor);
+  MonitorAutoEnter lock(mMonitor);
   PRBool mustTellTheWorld = PR_FALSE;
 
   lockIconState newSecurityState;
 
   if (mNewToplevelSecurityState & STATE_IS_SECURE)
   {
     if (mNewToplevelSecurityState & STATE_SECURE_LOW
         ||
@@ -1455,17 +1454,17 @@ nsresult nsSecureBrowserUIImpl::TellTheW
                                              lockIconState warnSecurityState, 
                                              nsIRequest* aRequest)
 {
   nsCOMPtr<nsISecurityEventSink> temp_ToplevelEventSink;
   lockIconState temp_NotifiedSecurityState;
   PRBool temp_NotifiedToplevelIsEV;
 
   {
-    nsAutoMonitor lock(mMonitor);
+    MonitorAutoEnter lock(mMonitor);
     temp_ToplevelEventSink = mToplevelEventSink;
     temp_NotifiedSecurityState = mNotifiedSecurityState;
     temp_NotifiedToplevelIsEV = mNotifiedToplevelIsEV;
   }
 
   if (temp_ToplevelEventSink)
   {
     PRUint32 newState = STATE_IS_INSECURE;
@@ -1542,17 +1541,17 @@ nsSecureBrowserUIImpl::OnLocationChange(
              ("SecureUI:%p: OnLocationChange: view-source\n", this));
     }
 
     updateIsViewSource = PR_TRUE;
     temp_IsViewSource = vs;
   }
 
   {
-    nsAutoMonitor lock(mMonitor);
+    MonitorAutoEnter lock(mMonitor);
     if (updateIsViewSource) {
       mIsViewSource = temp_IsViewSource;
     }
     mCurrentURI = aLocation;
     window = do_QueryReferent(mWindow);
     NS_ASSERTION(window, "Window has gone away?!");
   }
 
@@ -1590,17 +1589,17 @@ nsSecureBrowserUIImpl::OnLocationChange(
   // At this point, we are learning about the security state of a sub-document.
   // We must not update the security state based on the sub content, if the new
   // top level state is not yet known.
   //
   // We skip updating the security state in this case.
 
   PRBool temp_NewToplevelSecurityStateKnown;
   {
-    nsAutoMonitor lock(mMonitor);
+    MonitorAutoEnter lock(mMonitor);
     temp_NewToplevelSecurityStateKnown = mNewToplevelSecurityStateKnown;
   }
 
   if (temp_NewToplevelSecurityStateKnown)
     return UpdateSecurityState(aRequest, PR_TRUE, PR_FALSE, PR_FALSE);
 
   return NS_OK;
 }
@@ -1641,17 +1640,17 @@ nsSecureBrowserUIImpl::OnSecurityChange(
 }
 
 // nsISSLStatusProvider methods
 NS_IMETHODIMP
 nsSecureBrowserUIImpl::GetSSLStatus(nsISupports** _result)
 {
   NS_ENSURE_ARG_POINTER(_result);
 
-  nsAutoMonitor lock(mMonitor);
+  MonitorAutoEnter lock(mMonitor);
 
   switch (mNotifiedSecurityState)
   {
     case lis_mixed_security:
     case lis_low_security:
     case lis_high_security:
       break;
 
@@ -1693,17 +1692,17 @@ nsSecureBrowserUIImpl::IsURLJavaScript(n
 
 void
 nsSecureBrowserUIImpl::GetBundleString(const PRUnichar* name,
                                        nsAString &outString)
 {
   nsCOMPtr<nsIStringBundle> temp_StringBundle;
 
   {
-    nsAutoMonitor lock(mMonitor);
+    MonitorAutoEnter lock(mMonitor);
     temp_StringBundle = mStringBundle;
   }
 
   if (temp_StringBundle && name) {
     PRUnichar *ptrv = nsnull;
     if (NS_SUCCEEDED(temp_StringBundle->GetStringFromName(name,
                                                           &ptrv)))
       outString = ptrv;
@@ -1837,17 +1836,17 @@ ConfirmEnteringSecure()
 {
   nsCOMPtr<nsISecurityWarningDialogs> dialogs;
 
   GetNSSDialogs(getter_AddRefs(dialogs));
   if (!dialogs) return PR_FALSE;  // Should this allow PR_TRUE for unimplemented?
 
   nsCOMPtr<nsIDOMWindow> window;
   {
-    nsAutoMonitor lock(mMonitor);
+    MonitorAutoEnter lock(mMonitor);
     window = do_QueryReferent(mWindow);
     NS_ASSERTION(window, "Window has gone away?!");
   }
 
   nsCOMPtr<nsIInterfaceRequestor> ctx = new nsUIContext(window);
 
   PRBool confirms;
   dialogs->ConfirmEnteringSecure(ctx, &confirms);
@@ -1860,17 +1859,17 @@ ConfirmEnteringWeak()
 {
   nsCOMPtr<nsISecurityWarningDialogs> dialogs;
 
   GetNSSDialogs(getter_AddRefs(dialogs));
   if (!dialogs) return PR_FALSE;  // Should this allow PR_TRUE for unimplemented?
 
   nsCOMPtr<nsIDOMWindow> window;
   {
-    nsAutoMonitor lock(mMonitor);
+    MonitorAutoEnter lock(mMonitor);
     window = do_QueryReferent(mWindow);
     NS_ASSERTION(window, "Window has gone away?!");
   }
 
   nsCOMPtr<nsIInterfaceRequestor> ctx = new nsUIContext(window);
 
   PRBool confirms;
   dialogs->ConfirmEnteringWeak(ctx, &confirms);
@@ -1883,17 +1882,17 @@ ConfirmLeavingSecure()
 {
   nsCOMPtr<nsISecurityWarningDialogs> dialogs;
 
   GetNSSDialogs(getter_AddRefs(dialogs));
   if (!dialogs) return PR_FALSE;  // Should this allow PR_TRUE for unimplemented?
 
   nsCOMPtr<nsIDOMWindow> window;
   {
-    nsAutoMonitor lock(mMonitor);
+    MonitorAutoEnter lock(mMonitor);
     window = do_QueryReferent(mWindow);
     NS_ASSERTION(window, "Window has gone away?!");
   }
 
   nsCOMPtr<nsIInterfaceRequestor> ctx = new nsUIContext(window);
 
   PRBool confirms;
   dialogs->ConfirmLeavingSecure(ctx, &confirms);
@@ -1906,17 +1905,17 @@ ConfirmMixedMode()
 {
   nsCOMPtr<nsISecurityWarningDialogs> dialogs;
 
   GetNSSDialogs(getter_AddRefs(dialogs));
   if (!dialogs) return PR_FALSE;  // Should this allow PR_TRUE for unimplemented?
 
   nsCOMPtr<nsIDOMWindow> window;
   {
-    nsAutoMonitor lock(mMonitor);
+    MonitorAutoEnter lock(mMonitor);
     window = do_QueryReferent(mWindow);
     NS_ASSERTION(window, "Window has gone away?!");
   }
 
   nsCOMPtr<nsIInterfaceRequestor> ctx = new nsUIContext(window);
 
   PRBool confirms;
   dialogs->ConfirmMixedMode(ctx, &confirms);
@@ -1936,17 +1935,17 @@ ConfirmPostToInsecure()
 
   nsCOMPtr<nsISecurityWarningDialogs> dialogs;
 
   GetNSSDialogs(getter_AddRefs(dialogs));
   if (!dialogs) return PR_FALSE;  // Should this allow PR_TRUE for unimplemented?
 
   nsCOMPtr<nsIDOMWindow> window;
   {
-    nsAutoMonitor lock(mMonitor);
+    MonitorAutoEnter lock(mMonitor);
     window = do_QueryReferent(mWindow);
     NS_ASSERTION(window, "Window has gone away?!");
   }
 
   nsCOMPtr<nsIInterfaceRequestor> ctx = new nsUIContext(window);
 
   PRBool result;
 
@@ -1968,17 +1967,17 @@ ConfirmPostToInsecureFromSecure()
 
   nsCOMPtr<nsISecurityWarningDialogs> dialogs;
 
   GetNSSDialogs(getter_AddRefs(dialogs));
   if (!dialogs) return PR_FALSE;  // Should this allow PR_TRUE for unimplemented?
 
   nsCOMPtr<nsIDOMWindow> window;
   {
-    nsAutoMonitor lock(mMonitor);
+    MonitorAutoEnter lock(mMonitor);
     window = do_QueryReferent(mWindow);
     NS_ASSERTION(window, "Window has gone away?!");
   }
 
   nsCOMPtr<nsIInterfaceRequestor> ctx = new nsUIContext(window);
 
   PRBool result;
 
--- a/security/manager/boot/src/nsSecureBrowserUIImpl.h
+++ b/security/manager/boot/src/nsSecureBrowserUIImpl.h
@@ -37,16 +37,17 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef nsSecureBrowserUIImpl_h_
 #define nsSecureBrowserUIImpl_h_
 
+#include "mozilla/Monitor.h"
 #include "nsCOMPtr.h"
 #include "nsXPIDLString.h"
 #include "nsString.h"
 #include "nsIObserver.h"
 #include "nsIDOMElement.h"
 #include "nsIDOMWindow.h"
 #include "nsIDOMHTMLFormElement.h"
 #include "nsIStringBundle.h"
@@ -55,17 +56,16 @@
 #include "nsIWebProgressListener.h"
 #include "nsIFormSubmitObserver.h"
 #include "nsIURI.h"
 #include "nsISecurityEventSink.h"
 #include "nsWeakReference.h"
 #include "nsISSLStatusProvider.h"
 #include "nsIAssociatedContentSecurity.h"
 #include "pldhash.h"
-#include "prmon.h"
 #include "nsINetUtil.h"
 
 class nsITransportSecurityInfo;
 class nsISecurityWarningDialogs;
 class nsIChannel;
 
 #define NS_SECURE_BROWSER_UI_CID \
 { 0xcc75499a, 0x1dd1, 0x11b2, {0x8a, 0x82, 0xca, 0x41, 0x0a, 0xc9, 0x07, 0xb8}}
@@ -92,17 +92,17 @@ public:
   NS_DECL_NSISSLSTATUSPROVIDER
 
   NS_IMETHOD Notify(nsIDOMHTMLFormElement* formNode, nsIDOMWindowInternal* window,
                     nsIURI *actionURL, PRBool* cancelSubmit);
   NS_IMETHOD NotifyInvalidSubmit(nsIDOMHTMLFormElement* formNode,
                                  nsIArray* invalidElements) { return NS_OK; };
   
 protected:
-  PRMonitor *mMonitor;
+  mozilla::Monitor mMonitor;
   
   nsWeakPtr mWindow;
   nsCOMPtr<nsINetUtil> mIOService;
   nsCOMPtr<nsIStringBundle> mStringBundle;
   nsCOMPtr<nsIURI> mCurrentURI;
   nsCOMPtr<nsISecurityEventSink> mToplevelEventSink;
   
   enum lockIconState {
--- a/security/manager/ssl/src/nsCertOverrideService.cpp
+++ b/security/manager/ssl/src/nsCertOverrideService.cpp
@@ -47,27 +47,28 @@
 #include "nsNetUtil.h"
 #include "nsILineInputStream.h"
 #include "nsIObserver.h"
 #include "nsIObserverService.h"
 #include "nsISupportsPrimitives.h"
 #include "nsPromiseFlatString.h"
 #include "nsProxiedService.h"
 #include "nsStringBuffer.h"
-#include "nsAutoLock.h"
 #include "nsAutoPtr.h"
 #include "nspr.h"
 #include "pk11pub.h"
 #include "certdb.h"
 #include "sechash.h"
 #include "ssl.h" // For SSL_ClearSessionCache
 
 #include "nsNSSCleaner.h"
 NSSCleanupAutoPtrClass(CERTCertificate, CERT_DestroyCertificate)
 
+using namespace mozilla;
+
 static const char kCertOverrideFileName[] = "cert_override.txt";
 
 void
 nsCertOverride::convertBitsToString(OverrideBits ob, nsACString &str)
 {
   str.Truncate();
 
   if (ob & ob_Mismatch)
@@ -114,24 +115,22 @@ nsCertOverride::convertStringToBits(cons
 }
 
 NS_IMPL_THREADSAFE_ISUPPORTS3(nsCertOverrideService, 
                               nsICertOverrideService,
                               nsIObserver,
                               nsISupportsWeakReference)
 
 nsCertOverrideService::nsCertOverrideService()
+  : monitor("nsCertOverrideService.monitor")
 {
-  monitor = nsAutoMonitor::NewMonitor("security.certOverrideServiceMonitor");
 }
 
 nsCertOverrideService::~nsCertOverrideService()
 {
-  if (monitor)
-    nsAutoMonitor::DestroyMonitor(monitor);
 }
 
 nsresult
 nsCertOverrideService::Init()
 {
   if (!mSettingsTable.Init())
     return NS_ERROR_OUT_OF_MEMORY;
 
@@ -175,50 +174,50 @@ nsCertOverrideService::Observe(nsISuppor
                                const char      *aTopic,
                                const PRUnichar *aData)
 {
   // check the topic
   if (!nsCRT::strcmp(aTopic, "profile-before-change")) {
     // The profile is about to change,
     // or is going away because the application is shutting down.
 
-    nsAutoMonitor lock(monitor);
+    MonitorAutoEnter lock(monitor);
 
     if (!nsCRT::strcmp(aData, NS_LITERAL_STRING("shutdown-cleanse").get())) {
       RemoveAllFromMemory();
       // delete the storage file
       if (mSettingsFile) {
         mSettingsFile->Remove(PR_FALSE);
       }
     } else {
       RemoveAllFromMemory();
     }
 
   } else if (!nsCRT::strcmp(aTopic, "profile-do-change")) {
     // The profile has already changed.
     // Now read from the new profile location.
     // we also need to update the cached file location
 
-    nsAutoMonitor lock(monitor);
+    MonitorAutoEnter lock(monitor);
 
     nsresult rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(mSettingsFile));
     if (NS_SUCCEEDED(rv)) {
       mSettingsFile->AppendNative(NS_LITERAL_CSTRING(kCertOverrideFileName));
     }
     Read();
 
   }
 
   return NS_OK;
 }
 
 void
 nsCertOverrideService::RemoveAllFromMemory()
 {
-  nsAutoMonitor lock(monitor);
+  MonitorAutoEnter lock(monitor);
   mSettingsTable.Clear();
 }
 
 PR_STATIC_CALLBACK(PLDHashOperator)
 RemoveTemporariesCallback(nsCertOverrideEntry *aEntry,
                           void *aArg)
 {
   if (aEntry && aEntry->mSettings.mIsTemporary) {
@@ -228,26 +227,26 @@ RemoveTemporariesCallback(nsCertOverride
 
   return PL_DHASH_NEXT;
 }
 
 void
 nsCertOverrideService::RemoveAllTemporaryOverrides()
 {
   {
-    nsAutoMonitor lock(monitor);
+    MonitorAutoEnter lock(monitor);
     mSettingsTable.EnumerateEntries(RemoveTemporariesCallback, nsnull);
     // no need to write, as temporaries are never written to disk
   }
 }
 
 nsresult
 nsCertOverrideService::Read()
 {
-  nsAutoMonitor lock(monitor);
+  MonitorAutoEnter lock(monitor);
 
   nsresult rv;
   nsCOMPtr<nsIInputStream> fileInputStream;
   rv = NS_NewLocalFileInputStream(getter_AddRefs(fileInputStream), mSettingsFile);
   if (NS_FAILED(rv)) {
     return rv;
   }
 
@@ -356,17 +355,17 @@ WriteEntryCallback(nsCertOverrideEntry *
   }
 
   return PL_DHASH_NEXT;
 }
 
 nsresult
 nsCertOverrideService::Write()
 {
-  nsAutoMonitor lock(monitor);
+  MonitorAutoEnter lock(monitor);
 
   if (!mSettingsFile) {
     return NS_ERROR_NULL_POINTER;
   }
 
   nsresult rv;
   nsCOMPtr<nsIOutputStream> fileOutputStream;
   rv = NS_NewSafeLocalFileOutputStream(getter_AddRefs(fileOutputStream),
@@ -550,17 +549,17 @@ nsCertOverrideService::RememberValidityO
       ++dbkey_walk) {
     char c = *dbkey_walk;
     if (c == '\r' || c == '\n') {
       *dbkey_walk = ' ';
     }
   }
 
   {
-    nsAutoMonitor lock(monitor);
+    MonitorAutoEnter lock(monitor);
     AddEntryToList(aHostName, aPort,
                    aTemporary ? aCert : nsnull,
                      // keep a reference to the cert for temporary overrides
                    aTemporary, 
                    mDottedOidForStoringNewHashes, fpStr, 
                    (nsCertOverride::OverrideBits)aOverrideBits, 
                    nsDependentCString(dbkey));
     Write();
@@ -589,17 +588,17 @@ nsCertOverrideService::HasMatchingOverri
   *_retval = PR_FALSE;
   *aOverrideBits = nsCertOverride::ob_None;
 
   nsCAutoString hostPort;
   GetHostWithPort(aHostName, aPort, hostPort);
   nsCertOverride settings;
 
   {
-    nsAutoMonitor lock(monitor);
+    MonitorAutoEnter lock(monitor);
     nsCertOverrideEntry *entry = mSettingsTable.GetEntry(hostPort.get());
   
     if (!entry)
       return NS_OK;
   
     settings = entry->mSettings; // copy
   }
 
@@ -636,17 +635,17 @@ nsCertOverrideService::GetValidityOverri
   *_found = PR_FALSE;
   *aOverrideBits = nsCertOverride::ob_None;
 
   nsCAutoString hostPort;
   GetHostWithPort(aHostName, aPort, hostPort);
   nsCertOverride settings;
 
   {
-    nsAutoMonitor lock(monitor);
+    MonitorAutoEnter lock(monitor);
     nsCertOverrideEntry *entry = mSettingsTable.GetEntry(hostPort.get());
   
     if (entry) {
       *_found = PR_TRUE;
       settings = entry->mSettings; // copy
     }
   }
 
@@ -668,17 +667,17 @@ nsCertOverrideService::AddEntryToList(co
                                       const nsACString &fingerprint,
                                       nsCertOverride::OverrideBits ob,
                                       const nsACString &dbKey)
 {
   nsCAutoString hostPort;
   GetHostWithPort(aHostName, aPort, hostPort);
 
   {
-    nsAutoMonitor lock(monitor);
+    MonitorAutoEnter lock(monitor);
     nsCertOverrideEntry *entry = mSettingsTable.PutEntry(hostPort.get());
 
     if (!entry) {
       NS_ERROR("can't insert a null entry!");
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
     entry->mHostWithPort = hostPort;
@@ -703,17 +702,17 @@ nsCertOverrideService::ClearValidityOver
   if (aPort == 0 &&
       aHostName.EqualsLiteral("all:temporary-certificates")) {
     RemoveAllTemporaryOverrides();
     return NS_OK;
   }
   nsCAutoString hostPort;
   GetHostWithPort(aHostName, aPort, hostPort);
   {
-    nsAutoMonitor lock(monitor);
+    MonitorAutoEnter lock(monitor);
     mSettingsTable.RemoveEntry(hostPort.get());
     Write();
   }
   SSL_ClearSessionCache();
   return NS_OK;
 }
 
 NS_IMETHODIMP
@@ -833,17 +832,17 @@ nsCertOverrideService::IsCertUsedForOver
   cai.cert = aCert;
   cai.aCheckTemporaries = aCheckTemporaries;
   cai.aCheckPermanents = aCheckPermanents;
   cai.counter = 0;
   cai.mOidTagForStoringNewHashes = mOidTagForStoringNewHashes;
   cai.mDottedOidForStoringNewHashes = mDottedOidForStoringNewHashes;
 
   {
-    nsAutoMonitor lock(monitor);
+    MonitorAutoEnter lock(monitor);
     mSettingsTable.EnumerateEntries(FindMatchingCertCallback, &cai);
   }
   *_retval = cai.counter;
   return NS_OK;
 }
 
 struct nsCertAndPointerAndCallback
 {
@@ -899,17 +898,17 @@ nsCertOverrideService::EnumerateCertOver
   nsCertAndPointerAndCallback capac;
   capac.cert = aCert;
   capac.userdata = aUserData;
   capac.enumerator = enumerator;
   capac.mOidTagForStoringNewHashes = mOidTagForStoringNewHashes;
   capac.mDottedOidForStoringNewHashes = mDottedOidForStoringNewHashes;
 
   {
-    nsAutoMonitor lock(monitor);
+    MonitorAutoEnter lock(monitor);
     mSettingsTable.EnumerateEntries(EnumerateCertOverridesCallback, &capac);
   }
   return NS_OK;
 }
 
 void
 nsCertOverrideService::GetHostWithPort(const nsACString & aHostName, PRInt32 aPort, nsACString& _retval)
 {
--- a/security/manager/ssl/src/nsCertOverrideService.h
+++ b/security/manager/ssl/src/nsCertOverrideService.h
@@ -36,22 +36,22 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef __NSCERTOVERRIDESERVICE_H__
 #define __NSCERTOVERRIDESERVICE_H__
 
+#include "mozilla/Monitor.h"
 #include "nsICertOverrideService.h"
 #include "nsTHashtable.h"
 #include "nsIObserver.h"
 #include "nsString.h"
 #include "nsIFile.h"
-#include "prmon.h"
 #include "secoidt.h"
 #include "nsWeakReference.h"
 
 class nsCertOverride
 {
 public:
 
   enum OverrideBits { ob_None=0, ob_Untrusted=1, ob_Mismatch=2,
@@ -185,17 +185,17 @@ public:
                                   void *aUserData);
 
     // Concates host name and the port number. If the port number is -1 then
     // port 443 is automatically used. This method ensures there is always a port
     // number separated with colon.
     static void GetHostWithPort(const nsACString & aHostName, PRInt32 aPort, nsACString& _retval);
 
 protected:
-    PRMonitor *monitor;
+    mozilla::Monitor monitor;
     nsCOMPtr<nsIFile> mSettingsFile;
     nsTHashtable<nsCertOverrideEntry> mSettingsTable;
 
     SECOidTag mOidTagForStoringNewHashes;
     nsCString mDottedOidForStoringNewHashes;
 
     void RemoveAllFromMemory();
     nsresult Read();
--- a/security/manager/ssl/src/nsCertVerificationThread.cpp
+++ b/security/manager/ssl/src/nsCertVerificationThread.cpp
@@ -31,20 +31,21 @@
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsMemory.h"
-#include "nsAutoLock.h"
 #include "nsAutoPtr.h"
 #include "nsCertVerificationThread.h"
 
+using namespace mozilla;
+
 nsCertVerificationThread *nsCertVerificationThread::verification_thread_singleton;
 
 NS_IMPL_THREADSAFE_ISUPPORTS1(nsCertVerificationResult, nsICertVerificationResult)
 
 void nsCertVerificationJob::Run()
 {
   if (!mListener || !mCert)
     return;
@@ -110,54 +111,54 @@ nsCertVerificationThread::~nsCertVerific
 nsresult nsCertVerificationThread::addJob(nsBaseVerificationJob *aJob)
 {
   if (!aJob || !verification_thread_singleton)
     return NS_ERROR_FAILURE;
   
   if (!verification_thread_singleton->mThreadHandle)
     return NS_ERROR_OUT_OF_MEMORY;
 
-  nsAutoLock threadLock(verification_thread_singleton->mMutex);
+  MutexAutoLock threadLock(verification_thread_singleton->mMutex);
 
   verification_thread_singleton->mJobQ.Push(aJob);
-  PR_NotifyAllCondVar(verification_thread_singleton->mCond);
+  verification_thread_singleton->mCond.NotifyAll();
   
   return NS_OK;
 }
 
 void nsCertVerificationThread::Run(void)
 {
   while (PR_TRUE) {
 
     nsBaseVerificationJob *job = nsnull;
 
     {
-      nsAutoLock threadLock(verification_thread_singleton->mMutex);
+      MutexAutoLock threadLock(verification_thread_singleton->mMutex);
       
       while (!mExitRequested && (0 == verification_thread_singleton->mJobQ.GetSize())) {
         // no work to do ? let's wait a moment
 
-        PR_WaitCondVar(mCond, PR_INTERVAL_NO_TIMEOUT);
+        mCond.Wait();
       }
       
       if (mExitRequested)
         break;
       
       job = static_cast<nsBaseVerificationJob*>(mJobQ.PopFront());
     }
 
     if (job)
     {
       job->Run();
       delete job;
     }
   }
   
   {
-    nsAutoLock threadLock(verification_thread_singleton->mMutex);
+    MutexAutoLock threadLock(verification_thread_singleton->mMutex);
 
     while (verification_thread_singleton->mJobQ.GetSize()) {
       nsCertVerificationJob *job = 
         static_cast<nsCertVerificationJob*>(mJobQ.PopFront());
       delete job;
     }
   }
 }
--- a/security/manager/ssl/src/nsClientAuthRemember.cpp
+++ b/security/manager/ssl/src/nsClientAuthRemember.cpp
@@ -43,40 +43,40 @@
 #include "nsCRT.h"
 #include "nsNetUtil.h"
 #include "nsIObserverService.h"
 #include "nsNetUtil.h"
 #include "nsISupportsPrimitives.h"
 #include "nsPromiseFlatString.h"
 #include "nsProxiedService.h"
 #include "nsStringBuffer.h"
-#include "nsAutoLock.h"
 #include "nspr.h"
 #include "pk11pub.h"
 #include "certdb.h"
 #include "sechash.h"
 #include "ssl.h" // For SSL_ClearSessionCache
 
 #include "nsNSSCleaner.h"
+
+using namespace mozilla;
+
 NSSCleanupAutoPtrClass(CERTCertificate, CERT_DestroyCertificate)
 
 NS_IMPL_THREADSAFE_ISUPPORTS2(nsClientAuthRememberService, 
                               nsIObserver,
                               nsISupportsWeakReference)
 
 nsClientAuthRememberService::nsClientAuthRememberService()
+  : monitor("nsClientAuthRememberService.monitor")
 {
-  monitor = nsAutoMonitor::NewMonitor("security.clientAuthRememberServiceMonitor");
 }
 
 nsClientAuthRememberService::~nsClientAuthRememberService()
 {
   RemoveAllFromMemory();
-  if (monitor)
-    nsAutoMonitor::DestroyMonitor(monitor);
 }
 
 nsresult
 nsClientAuthRememberService::Init()
 {
   if (!mSettingsTable.Init())
     return NS_ERROR_OUT_OF_MEMORY;
 
@@ -105,26 +105,26 @@ nsClientAuthRememberService::Observe(nsI
                                const char      *aTopic,
                                const PRUnichar *aData)
 {
   // check the topic
   if (!nsCRT::strcmp(aTopic, "profile-before-change")) {
     // The profile is about to change,
     // or is going away because the application is shutting down.
 
-    nsAutoMonitor lock(monitor);
+    MonitorAutoEnter lock(monitor);
     RemoveAllFromMemory();
   }
 
   return NS_OK;
 }
 
 void nsClientAuthRememberService::ClearRememberedDecisions()
 {
-  nsAutoMonitor lock(monitor);
+  MonitorAutoEnter lock(monitor);
   RemoveAllFromMemory();
 }
 
 void
 nsClientAuthRememberService::RemoveAllFromMemory()
 {
   mSettingsTable.Clear();
 }
@@ -160,17 +160,17 @@ nsClientAuthRememberService::RememberDec
     return NS_ERROR_INVALID_ARG;
 
   nsCAutoString fpStr;
   nsresult rv = GetCertFingerprintByOidTag(aServerCert, SEC_OID_SHA256, fpStr);
   if (NS_FAILED(rv))
     return rv;
 
   {
-    nsAutoMonitor lock(monitor);
+    MonitorAutoEnter lock(monitor);
     if (aClientCert) {
       nsNSSCertificate pipCert(aClientCert);
       char *dbkey = NULL;
       rv = pipCert.GetDbKey(&dbkey);
       if (NS_SUCCEEDED(rv) && dbkey) {
         AddEntryToList(aHostName, fpStr, 
                        nsDependentCString(dbkey));
       }
@@ -206,17 +206,17 @@ nsClientAuthRememberService::HasRemember
   if (NS_FAILED(rv))
     return rv;
 
   nsCAutoString hostCert;
   GetHostWithCert(aHostName, fpStr, hostCert);
   nsClientAuthRemember settings;
 
   {
-    nsAutoMonitor lock(monitor);
+    MonitorAutoEnter lock(monitor);
     nsClientAuthRememberEntry *entry = mSettingsTable.GetEntry(hostCert.get());
     if (!entry)
       return NS_OK;
     settings = entry->mSettings; // copy
   }
 
   aCertDBKey = settings.mDBKey;
   *_retval = PR_TRUE;
@@ -228,17 +228,17 @@ nsClientAuthRememberService::AddEntryToL
                                       const nsACString &fingerprint,
                                       const nsACString &db_key)
 
 {
   nsCAutoString hostCert;
   GetHostWithCert(aHostName, fingerprint, hostCert);
 
   {
-    nsAutoMonitor lock(monitor);
+    MonitorAutoEnter lock(monitor);
     nsClientAuthRememberEntry *entry = mSettingsTable.PutEntry(hostCert.get());
 
     if (!entry) {
       NS_ERROR("can't insert a null entry!");
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
     entry->mHostWithCert = hostCert;
--- a/security/manager/ssl/src/nsClientAuthRemember.h
+++ b/security/manager/ssl/src/nsClientAuthRemember.h
@@ -35,24 +35,24 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef __NSCLIENTAUTHREMEMBER_H__
 #define __NSCLIENTAUTHREMEMBER_H__
 
+#include "mozilla/Monitor.h"
 #include "nsTHashtable.h"
 #include "nsIObserver.h"
 #include "nsIX509Cert.h"
 #include "nsAutoPtr.h"
 #include "nsNSSCertificate.h"
 #include "nsString.h"
 #include "nsWeakReference.h"
-#include "prmon.h"
 
 class nsClientAuthRemember
 {
 public:
 
   nsClientAuthRemember()
   {
   }
@@ -158,17 +158,17 @@ public:
                             CERTCertificate *aServerCert, CERTCertificate *aClientCert);
   nsresult HasRememberedDecision(const nsACString & aHostName, 
                                  CERTCertificate *aServerCert, 
                                  nsACString & aCertDBKey, PRBool *_retval);
 
   void ClearRememberedDecisions();
 
 protected:
-    PRMonitor *monitor;
+    mozilla::Monitor monitor;
     nsTHashtable<nsClientAuthRememberEntry> mSettingsTable;
 
     void RemoveAllFromMemory();
     nsresult AddEntryToList(const nsACString &host, 
                             const nsACString &server_fingerprint,
                             const nsACString &db_key);
 };
 
--- a/security/manager/ssl/src/nsKeygenThread.cpp
+++ b/security/manager/ssl/src/nsKeygenThread.cpp
@@ -39,85 +39,81 @@
 #include "pk11func.h"
 #include "nsCOMPtr.h"
 #include "nsProxiedService.h"
 #include "nsThreadUtils.h"
 #include "nsKeygenThread.h"
 #include "nsIObserver.h"
 #include "nsNSSShutDown.h"
 
+using namespace mozilla;
+
 NS_IMPL_THREADSAFE_ISUPPORTS1(nsKeygenThread, nsIKeygenThread)
 
 
 nsKeygenThread::nsKeygenThread()
-:mutex(nsnull),
+:mutex("nsKeygenThread.mutex"),
  iAmRunning(PR_FALSE),
  keygenReady(PR_FALSE),
  statusDialogClosed(PR_FALSE),
  alreadyReceivedParams(PR_FALSE),
  privateKey(nsnull),
  publicKey(nsnull),
  slot(nsnull),
  keyGenMechanism(0),
  params(nsnull),
  isPerm(PR_FALSE),
  isSensitive(PR_FALSE),
  wincx(nsnull),
  threadHandle(nsnull)
 {
-  mutex = PR_NewLock();
 }
 
 nsKeygenThread::~nsKeygenThread()
 {
-  if (mutex) {
-    PR_DestroyLock(mutex);
-  }
 }
 
 void nsKeygenThread::SetParams(
     PK11SlotInfo *a_slot,
     PRUint32 a_keyGenMechanism,
     void *a_params,
     PRBool a_isPerm,
     PRBool a_isSensitive,
     void *a_wincx )
 {
   nsNSSShutDownPreventionLock locker;
-  PR_Lock(mutex);
+  MutexAutoLock lock(mutex);
  
     if (!alreadyReceivedParams) {
       alreadyReceivedParams = PR_TRUE;
       if (a_slot) {
         slot = PK11_ReferenceSlot(a_slot);
       }
       else {
         slot = nsnull;
       }
       keyGenMechanism = a_keyGenMechanism;
       params = a_params;
       isPerm = a_isPerm;
       isSensitive = a_isSensitive;
       wincx = a_wincx;
     }
-
-  PR_Unlock(mutex);
 }
 
 nsresult nsKeygenThread::GetParams(
     SECKEYPrivateKey **a_privateKey,
     SECKEYPublicKey **a_publicKey)
 {
   if (!a_privateKey || !a_publicKey) {
     return NS_ERROR_FAILURE;
   }
 
   nsresult rv;
-  
-  PR_Lock(mutex);
+
+  MutexAutoLock lock(mutex);
   
     // GetParams must not be called until thread creator called
     // Join on this thread.
     NS_ASSERTION(keygenReady, "logic error in nsKeygenThread::GetParams");
 
     if (keygenReady) {
       *a_privateKey = privateKey;
       *a_publicKey = publicKey;
@@ -126,118 +122,105 @@ nsresult nsKeygenThread::GetParams(
       publicKey = 0;
       
       rv = NS_OK;
     }
     else {
       rv = NS_ERROR_FAILURE;
     }
   
-  PR_Unlock(mutex);
-  
   return rv;
 }
 
 static void PR_CALLBACK nsKeygenThreadRunner(void *arg)
 {
   nsKeygenThread *self = static_cast<nsKeygenThread *>(arg);
   self->Run();
 }
 
 nsresult nsKeygenThread::StartKeyGeneration(nsIObserver* aObserver)
 {
-  if (!mutex)
-    return NS_OK;
-
   if (!aObserver)
     return NS_OK;
 
   nsCOMPtr<nsIObserver> obs;
   NS_GetProxyForObject( NS_PROXY_TO_MAIN_THREAD,
                         NS_GET_IID(nsIObserver),
                         aObserver,
                         NS_PROXY_SYNC | NS_PROXY_ALWAYS,
                         getter_AddRefs(obs));
 
-  PR_Lock(mutex);
+  MutexAutoLock lock(mutex);
 
     if (iAmRunning || keygenReady) {
-      PR_Unlock(mutex);
       return NS_OK;
     }
 
     observer.swap(obs);
 
     iAmRunning = PR_TRUE;
 
     threadHandle = PR_CreateThread(PR_USER_THREAD, nsKeygenThreadRunner, static_cast<void*>(this), 
       PR_PRIORITY_NORMAL, PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
 
     // bool thread_started_ok = (threadHandle != nsnull);
     // we might want to return "thread started ok" to caller in the future
     NS_ASSERTION(threadHandle, "Could not create nsKeygenThreadRunner thread\n");
-
-  PR_Unlock(mutex);
   
   return NS_OK;
 }
 
 nsresult nsKeygenThread::UserCanceled(PRBool *threadAlreadyClosedDialog)
 {
   if (!threadAlreadyClosedDialog)
     return NS_OK;
 
   *threadAlreadyClosedDialog = PR_FALSE;
 
-  if (!mutex)
-    return NS_OK;
-
-  PR_Lock(mutex);
+  MutexAutoLock lock(mutex);
   
     if (keygenReady)
       *threadAlreadyClosedDialog = statusDialogClosed;
 
     // User somehow closed the dialog, but we will not cancel.
     // Bad luck, we told him not do, and user still has to wait.
     // However, we remember that it's closed and will not close
     // it again to avoid problems.
     statusDialogClosed = PR_TRUE;
 
-  PR_Unlock(mutex);
-
   return NS_OK;
 }
 
 void nsKeygenThread::Run(void)
 {
   nsNSSShutDownPreventionLock locker;
   PRBool canGenerate = PR_FALSE;
 
-  PR_Lock(mutex);
-
+  {
+    MutexAutoLock lock(mutex);
     if (alreadyReceivedParams) {
       canGenerate = PR_TRUE;
       keygenReady = PR_FALSE;
     }
-
-  PR_Unlock(mutex);
+  }
 
   if (canGenerate)
     privateKey = PK11_GenerateKeyPair(slot, keyGenMechanism,
                                          params, &publicKey,
                                          isPerm, isSensitive, wincx);
   
   // This call gave us ownership over privateKey and publicKey.
   // But as the params structure is owner by our caller,
   // we effectively transferred ownership to the caller.
   // As long as key generation can't be canceled, we don't need 
   // to care for cleaning this up.
 
   nsCOMPtr<nsIObserver> obs;
-  PR_Lock(mutex);
+  {
+    MutexAutoLock lock(mutex);
 
     keygenReady = PR_TRUE;
     iAmRunning = PR_FALSE;
 
     // forget our parameters
     if (slot) {
       PK11_FreeSlot(slot);
       slot = 0;
@@ -245,18 +228,17 @@ void nsKeygenThread::Run(void)
     keyGenMechanism = 0;
     params = 0;
     wincx = 0;
 
     if (!statusDialogClosed)
       obs = observer;
 
     observer = nsnull;
-
-  PR_Unlock(mutex);
+  }
 
   if (obs)
     obs->Observe(nsnull, "keygen-finished", nsnull);
 }
 
 void nsKeygenThread::Join()
 {
   if (!threadHandle)
--- a/security/manager/ssl/src/nsKeygenThread.h
+++ b/security/manager/ssl/src/nsKeygenThread.h
@@ -37,25 +37,26 @@
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef _NSKEYGENTHREAD_H_
 #define _NSKEYGENTHREAD_H_
 
 #include "keyhi.h"
 #include "nspr.h"
 
+#include "mozilla/Mutex.h"
 #include "nsIKeygenThread.h"
 #include "nsCOMPtr.h"
 
 class nsIObserver;
 
 class nsKeygenThread : public nsIKeygenThread
 {
 private:
-  PRLock *mutex;
+  mozilla::Mutex mutex;
   
   nsCOMPtr<nsIObserver> observer;
 
   PRBool iAmRunning;
   PRBool keygenReady;
   PRBool statusDialogClosed;
   PRBool alreadyReceivedParams;
 
--- a/security/manager/ssl/src/nsNSSCallbacks.cpp
+++ b/security/manager/ssl/src/nsNSSCallbacks.cpp
@@ -59,29 +59,30 @@
 #include "nsIInterfaceRequestorUtils.h"
 #include "nsProtectedAuthThread.h"
 #include "nsITokenDialogs.h"
 #include "nsCRT.h"
 #include "nsNSSShutDown.h"
 #include "nsIUploadChannel.h"
 #include "nsSSLThread.h"
 #include "nsThreadUtils.h"
-#include "nsAutoLock.h"
 #include "nsIThread.h"
 #include "nsIWindowWatcher.h"
 #include "nsIPrompt.h"
 #include "nsProxyRelease.h"
 #include "nsIConsoleService.h"
 
 #include "ssl.h"
 #include "cert.h"
 #include "ocsp.h"
 #include "nssb64.h"
 #include "secerr.h"
 
+using namespace mozilla;
+
 static NS_DEFINE_CID(kNSSComponentCID, NS_NSSCOMPONENT_CID);
 NSSCleanupAutoPtrClass(CERTCertificate, CERT_DestroyCertificate)
 
 #ifdef PR_LOGGING
 extern PRLogModuleInfo* gPIPNSSLog;
 #endif
 
 class nsHTTPDownloadEvent : public nsRunnable {
@@ -367,21 +368,18 @@ nsNSSHttpRequestSession::internal_send_r
   {
     acceptableResultSize = *http_response_data_len;
     *http_response_data_len = 0;
   }
   
   if (!mListener)
     return SECFailure;
 
-  if (NS_FAILED(mListener->InitLocks()))
-    return SECFailure;
-
-  PRLock *waitLock = mListener->mLock;
-  PRCondVar *waitCondition = mListener->mCondition;
+  Mutex& waitLock = mListener->mLock;
+  CondVar& waitCondition = mListener->mCondition;
   volatile PRBool &waitFlag = mListener->mWaitFlag;
   waitFlag = PR_TRUE;
 
   nsRefPtr<nsHTTPDownloadEvent> event = new nsHTTPDownloadEvent;
   if (!event)
     return SECFailure;
 
   event->mListener = mListener;
@@ -393,17 +391,17 @@ nsNSSHttpRequestSession::internal_send_r
   {
     event->mResponsibleForDoneSignal = PR_FALSE;
     return SECFailure;
   }
 
   PRBool request_canceled = PR_FALSE;
 
   {
-    nsAutoLock locker(waitLock);
+    MutexAutoLock locker(waitLock);
 
     const PRIntervalTime start_time = PR_IntervalNow();
     PRIntervalTime wait_interval;
 
     PRBool running_on_main_thread = NS_IsMainThread();
     if (running_on_main_thread)
     {
       // let's process events quickly
@@ -421,22 +419,21 @@ nsNSSHttpRequestSession::internal_send_r
       if (running_on_main_thread)
       {
         // Networking runs on the main thread, which we happen to block here.
         // Processing events will allow the OCSP networking to run while we 
         // are waiting. Thanks a lot to Darin Fisher for rewriting the 
         // thread manager. Thanks a lot to Christian Biesinger who
         // made me aware of this possibility. (kaie)
 
-        locker.unlock();
+        MutexAutoUnlock unlock(waitLock);
         NS_ProcessNextEvent(nsnull);
-        locker.lock();
       }
 
-      PR_WaitCondVar(waitCondition, wait_interval);
+      waitCondition.Wait(wait_interval);
       
       if (!waitFlag)
         break;
 
       if (!request_canceled)
       {
         PRBool wantExit = nsSSLThread::exitRequested();
         PRBool timeout = 
@@ -552,78 +549,53 @@ void nsNSSHttpInterface::registerHttpCli
 void nsNSSHttpInterface::unregisterHttpClient()
 {
   SEC_RegisterDefaultHttpClient(nsnull);
 }
 
 nsHTTPListener::nsHTTPListener()
 : mResultData(nsnull),
   mResultLen(0),
-  mLock(nsnull),
-  mCondition(nsnull),
+  mLock("nsHTTPListener.mLock"),
+  mCondition(mLock, "nsHTTPListener.mCondition"),
   mWaitFlag(PR_TRUE),
   mResponsibleForDoneSignal(PR_FALSE),
   mLoadGroup(nsnull),
   mLoadGroupOwnerThread(nsnull)
 {
 }
 
-nsresult nsHTTPListener::InitLocks()
-{
-  mLock = nsAutoLock::NewLock("nsHttpListener::mLock");
-  if (!mLock)
-    return NS_ERROR_OUT_OF_MEMORY;
-  
-  mCondition = PR_NewCondVar(mLock);
-  if (!mCondition)
-  {
-    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)
-    nsAutoLock::DestroyLock(mLock);
-
   if (mLoader) {
     nsCOMPtr<nsIThread> mainThread(do_GetMainThread());
     NS_ProxyRelease(mainThread, mLoader);
   }
 }
 
 NS_IMPL_THREADSAFE_ISUPPORTS1(nsHTTPListener, nsIStreamLoaderObserver)
 
 void
 nsHTTPListener::FreeLoadGroup(PRBool aCancelLoad)
 {
   nsILoadGroup *lg = nsnull;
 
-  if (mLock) {
-    nsAutoLock locker(mLock);
+  MutexAutoLock locker(mLock);
 
-    if (mLoadGroup) {
-      if (mLoadGroupOwnerThread != PR_GetCurrentThread()) {
-        NS_ASSERTION(PR_FALSE,
-          "attempt to access nsHTTPDownloadEvent::mLoadGroup on multiple threads, leaking it!");
-      }
-      else {
-        lg = mLoadGroup;
-        mLoadGroup = nsnull;
-      }
+  if (mLoadGroup) {
+    if (mLoadGroupOwnerThread != PR_GetCurrentThread()) {
+      NS_ASSERTION(PR_FALSE,
+                   "attempt to access nsHTTPDownloadEvent::mLoadGroup on multiple threads, leaking it!");
+    }
+    else {
+      lg = mLoadGroup;
+      mLoadGroup = nsnull;
     }
   }
 
   if (lg) {
     if (aCancelLoad) {
       lg->Cancel(NS_ERROR_ABORT);
     }
     NS_RELEASE(lg);
@@ -683,19 +655,19 @@ nsHTTPListener::OnStreamComplete(nsIStre
   return aStatus;
 }
 
 void nsHTTPListener::send_done_signal()
 {
   mResponsibleForDoneSignal = PR_FALSE;
 
   {
-    nsAutoLock locker(mLock);
+    MutexAutoLock locker(mLock);
     mWaitFlag = PR_FALSE;
-    PR_NotifyAllCondVar(mCondition);
+    mCondition.NotifyAll();
   }
 }
 
 static char*
 ShowProtectedAuthPrompt(PK11SlotInfo* slot, nsIInterfaceRequestor *ir)
 {
   char* protAuthRetVal = nsnull;
 
--- a/security/manager/ssl/src/nsNSSCallbacks.h
+++ b/security/manager/ssl/src/nsNSSCallbacks.h
@@ -40,16 +40,18 @@
 
 #ifndef _NSNSSCALLBACKS_H_
 #define _NSNSSCALLBACKS_H_
 
 #include "pk11func.h"
 #include "nspr.h"
 #include "ocspt.h"
 #include "nsIStreamLoader.h"
+#include "mozilla/CondVar.h"
+#include "mozilla/Mutex.h"
 
 char* PR_CALLBACK
 PK11PasswordPrompt(PK11SlotInfo *slot, PRBool retry, void* arg);
 
 void PR_CALLBACK HandshakeCallback(PRFileDesc *fd, void *client_data);
 SECStatus PR_CALLBACK AuthCertificateCallback(void* client_data, PRFileDesc* fd,
                                               PRBool checksig, PRBool isServer