--- a/content/media/nsBuiltinDecoderReader.h
+++ b/content/media/nsBuiltinDecoderReader.h
@@ -37,16 +37,17 @@
  *
  * ***** 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,33 +31,31 @@
  * 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
@@ -74,16 +72,19 @@ 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).
@@ -129,31 +130,34 @@ class nsMediaCache {
 public:
   friend class nsMediaCacheStream::BlockList;
   typedef nsMediaCacheStream::BlockList BlockList;
   enum {
     BLOCK_SIZE = nsMediaCacheStream::BLOCK_SIZE
   };
 
   nsMediaCache() : mNextResourceID(1),
-    mMonitor("nsMediaCache.mMonitor"),
+    mMonitor(nsAutoMonitor::NewMonitor("media.cache")),
     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
@@ -222,17 +226,17 @@ public:
 
 #ifdef DEBUG_VERIFY_CACHE
   // Verify invariants, especially block list invariants
   void Verify();
 #else
   void Verify() {}
 #endif
 
-  Monitor& GetMonitor() { return mMonitor; }
+  PRMonitor* Monitor() { 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) :
@@ -345,17 +349,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.
-  Monitor         mMonitor;
+  PRMonitor*      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.
@@ -540,16 +544,21 @@ 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
@@ -603,17 +612,17 @@ nsMediaCache::Flush()
     return;
 
   gMediaCache->FlushInternal();
 }
 
 void
 nsMediaCache::FlushInternal()
 {
-  MonitorAutoEnter mon(mMonitor);
+  nsAutoMonitor 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?");
@@ -658,17 +667,17 @@ InitMediaCache()
     gMediaCache = nsnull;
   }
 }
 
 nsresult
 nsMediaCache::ReadCacheFile(PRInt64 aOffset, void* aData, PRInt32 aLength,
                             PRInt32* aBytes)
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
 
   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;
@@ -680,17 +689,17 @@ nsMediaCache::ReadCacheFile(PRInt64 aOff
   mFDCurrentPos += amount;
   *aBytes = amount;
   return NS_OK;
 }
 
 nsresult
 nsMediaCache::ReadCacheFileAllBytes(PRInt64 aOffset, void* aData, PRInt32 aLength)
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
 
   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);
@@ -703,17 +712,17 @@ nsMediaCache::ReadCacheFileAllBytes(PRIn
     offset += bytes;
   }
   return NS_OK;
 }
 
 nsresult
 nsMediaCache::WriteCacheFile(PRInt64 aOffset, const void* aData, PRInt32 aLength)
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
 
   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;
@@ -744,17 +753,17 @@ static PRInt32 GetMaxBlocks()
   maxBlocks = PR_MAX(maxBlocks, 1);
   return PRInt32(PR_MIN(maxBlocks, PR_INT32_MAX));
 }
 
 PRInt32
 nsMediaCache::FindBlockForIncomingData(TimeStamp aNow,
                                        nsMediaCacheStream* aStream)
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
 
   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
@@ -787,17 +796,17 @@ nsMediaCache::BlockIsReusable(PRInt32 aB
   return PR_TRUE;
 }
 
 void
 nsMediaCache::AppendMostReusableBlock(BlockList* aBlockList,
                                       nsTArray<PRUint32>* aResult,
                                       PRInt32 aBlockIndexLimit)
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
 
   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
@@ -811,17 +820,17 @@ nsMediaCache::AppendMostReusableBlock(Bl
 }
 
 PRInt32
 nsMediaCache::FindReusableBlock(TimeStamp aNow,
                                 nsMediaCacheStream* aForStream,
                                 PRInt32 aForStreamBlock,
                                 PRInt32 aMaxSearchBlockIndex)
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
 
   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 =
@@ -905,17 +914,17 @@ nsMediaCache::GetBlockOwner(PRInt32 aBlo
       return &block->mOwners[i];
   }
   return nsnull;
 }
 
 void
 nsMediaCache::SwapBlocks(PRInt32 aBlockIndex1, PRInt32 aBlockIndex2)
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
 
   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.
@@ -985,17 +994,17 @@ nsMediaCache::AddBlockOwnerAsReadahead(P
   aStream->mBlocks[aStreamBlockIndex] = aBlockIndex;
   bo->mClass = READAHEAD_BLOCK;
   InsertReadaheadBlock(bo, aBlockIndex);
 }
 
 void
 nsMediaCache::FreeBlock(PRInt32 aBlock)
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
 
   Block* block = &mIndex[aBlock];
   if (block->mOwners.IsEmpty()) {
     // already free
     return;
   }
 
   LOG(PR_LOG_DEBUG, ("Released block %d", aBlock));
@@ -1008,17 +1017,17 @@ nsMediaCache::FreeBlock(PRInt32 aBlock)
   block->mOwners.Clear();
   mFreeBlocks.AddFirstBlock(aBlock);
   Verify();
 }
 
 TimeDuration
 nsMediaCache::PredictNextUse(TimeStamp aNow, PRInt32 aBlock)
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
   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];
@@ -1058,17 +1067,17 @@ nsMediaCache::PredictNextUse(TimeStamp a
     }
   }
   return result;
 }
 
 TimeDuration
 nsMediaCache::PredictNextUseForIncomingData(nsMediaCacheStream* aStream)
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
 
   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);
@@ -1086,17 +1095,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;
 
   {
-    MonitorAutoEnter mon(mMonitor);
+    nsAutoMonitor mon(mMonitor);
     mUpdateQueued = PR_FALSE;
 #ifdef DEBUG
     mInUpdate = PR_TRUE;
 #endif
 
     PRInt32 maxBlocks = GetMaxBlocks();
     TimeStamp now = TimeStamp::Now();
 
@@ -1368,18 +1377,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.
-      MonitorAutoEnter mon(mMonitor);
-      stream->CloseInternal(mon);
+      nsAutoMonitor mon(mMonitor);
+      stream->CloseInternal(&mon);
     }
   }
 }
 
 class UpdateEvent : public nsRunnable
 {
 public:
   NS_IMETHOD Run()
@@ -1389,34 +1398,34 @@ public:
     }
     return NS_OK;
   }
 };
 
 void
 nsMediaCache::QueueUpdate()
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
 
   // 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()
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
 
   mFreeBlocks.Verify();
   for (PRUint32 i = 0; i < mStreams.Length(); ++i) {
     nsMediaCacheStream* stream = mStreams[i];
     stream->mReadaheadBlocks.Verify();
     stream->mPlayedBlocks.Verify();
     stream->mMetadataBlocks.Verify();
 
@@ -1438,17 +1447,17 @@ nsMediaCache::Verify()
   }
 }
 #endif
 
 void
 nsMediaCache::InsertReadaheadBlock(BlockOwner* aBlockOwner,
                                    PRInt32 aBlockIndex)
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
 
   // 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");
@@ -1464,17 +1473,17 @@ nsMediaCache::InsertReadaheadBlock(Block
   stream->mReadaheadBlocks.AddFirstBlock(aBlockIndex);
   Verify();
 }
 
 void
 nsMediaCache::AllocateAndWriteBlock(nsMediaCacheStream* aStream, const void* aData,
                                     nsMediaCacheStream::ReadMode aMode)
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
 
   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);
@@ -1542,39 +1551,39 @@ nsMediaCache::AllocateAndWriteBlock(nsMe
   QueueUpdate();
 }
 
 void
 nsMediaCache::OpenStream(nsMediaCacheStream* aStream)
 {
   NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
 
-  MonitorAutoEnter mon(mMonitor);
+  nsAutoMonitor 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");
 
-  MonitorAutoEnter mon(mMonitor);
+  nsAutoMonitor mon(mMonitor);
   LOG(PR_LOG_DEBUG, ("Stream %p closed", aStream));
   mStreams.RemoveElement(aStream);
 }
 
 void
 nsMediaCache::ReleaseStreamBlocks(nsMediaCacheStream* aStream)
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
 
   // 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) {
@@ -1604,17 +1613,17 @@ nsMediaCache::Truncate()
   }
 }
 
 void
 nsMediaCache::NoteBlockUsage(nsMediaCacheStream* aStream, PRInt32 aBlockIndex,
                              nsMediaCacheStream::ReadMode aMode,
                              TimeStamp aNow)
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
 
   if (aBlockIndex < 0) {
     // this block is not in the cache yet
     return;
   }
 
   BlockOwner* bo = GetBlockOwner(aBlockIndex, aStream);
   if (!bo) {
@@ -1636,17 +1645,17 @@ nsMediaCache::NoteBlockUsage(nsMediaCach
   GetListForBlock(bo)->AddFirstBlock(aBlockIndex);
   bo->mLastUseTime = aNow;
   Verify();
 }
 
 void
 nsMediaCache::NoteSeek(nsMediaCacheStream* aStream, PRInt64 aOldOffset)
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
 
   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,
@@ -1692,26 +1701,26 @@ nsMediaCache::NoteSeek(nsMediaCacheStrea
   }
 }
 
 void
 nsMediaCacheStream::NotifyDataLength(PRInt64 aLength)
 {
   NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
 
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
   mStreamLength = aLength;
 }
 
 void
 nsMediaCacheStream::NotifyDataStarted(PRInt64 aOffset)
 {
   NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
 
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
   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);
   }
@@ -1752,17 +1761,17 @@ nsMediaCacheStream::UpdatePrincipal(nsIP
 }
 
 void
 nsMediaCacheStream::NotifyDataReceived(PRInt64 aSize, const char* aData,
     nsIPrincipal* aPrincipal)
 {
   NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
 
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
   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) {
@@ -1821,17 +1830,17 @@ nsMediaCacheStream::NotifyDataReceived(P
   mon.NotifyAll();
 }
 
 void
 nsMediaCacheStream::NotifyDataEnded(nsresult aStatus)
 {
   NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
 
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
 
   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);
@@ -1859,113 +1868,113 @@ nsMediaCacheStream::~nsMediaCacheStream(
     gMediaCache->ReleaseStream(this);
     nsMediaCache::MaybeShutdown();
   }
 }
 
 void
 nsMediaCacheStream::SetSeekable(PRBool aIsSeekable)
 {
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
   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()
 {
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
   return mIsSeekable;
 }
 
 void
 nsMediaCacheStream::Close()
 {
   NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
 
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
-  CloseInternal(mon);
+  nsAutoMonitor mon(gMediaCache->Monitor());
+  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(MonitorAutoEnter& aMonitor)
+nsMediaCacheStream::CloseInternal(nsAutoMonitor* 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()
 {
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
   ++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()
 {
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
   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()
 {
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
   return mStreamLength;
 }
 
 PRInt64
 nsMediaCacheStream::GetNextCachedData(PRInt64 aOffset)
 {
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
   return GetNextCachedDataInternal(aOffset);
 }
 
 PRInt64
 nsMediaCacheStream::GetCachedDataEnd(PRInt64 aOffset)
 {
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
   return GetCachedDataEndInternal(aOffset);
 }
 
 PRBool
 nsMediaCacheStream::IsDataCachedToEndOfStream(PRInt64 aOffset)
 {
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
   if (mStreamLength < 0)
     return PR_FALSE;
   return GetCachedDataEndInternal(aOffset) >= mStreamLength;
 }
 
 PRInt64
 nsMediaCacheStream::GetCachedDataEndInternal(PRInt64 aOffset)
 {
-  gMediaCache->GetMonitor().AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(gMediaCache->Monitor());
   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
@@ -1978,17 +1987,17 @@ nsMediaCacheStream::GetCachedDataEndInte
     result = PR_MIN(result, mStreamLength);
   }
   return PR_MAX(result, aOffset);
 }
 
 PRInt64
 nsMediaCacheStream::GetNextCachedDataInternal(PRInt64 aOffset)
 {
-  gMediaCache->GetMonitor().AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(gMediaCache->Monitor());
   if (aOffset == mStreamLength)
     return -1;
 
   PRUint32 startBlockIndex = aOffset/BLOCK_SIZE;
   PRUint32 channelBlockIndex = mChannelOffset/BLOCK_SIZE;
 
   if (startBlockIndex == channelBlockIndex &&
       aOffset < mChannelOffset) {
@@ -2025,40 +2034,40 @@ nsMediaCacheStream::GetNextCachedDataInt
 
   NS_NOTREACHED("Should return in loop");
   return -1;
 }
 
 void
 nsMediaCacheStream::SetReadMode(ReadMode aMode)
 {
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
   if (aMode == mCurrentMode)
     return;
   mCurrentMode = aMode;
   gMediaCache->QueueUpdate();
 }
 
 void
 nsMediaCacheStream::SetPlaybackRate(PRUint32 aBytesPerSecond)
 {
   NS_ASSERTION(aBytesPerSecond > 0, "Zero playback rate not allowed");
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
   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");
 
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
   if (mClosed)
     return NS_ERROR_FAILURE;
 
   PRInt64 oldOffset = mStreamOffset;
   switch (aWhence) {
   case PR_SEEK_END:
     if (mStreamLength < 0)
       return NS_ERROR_FAILURE;
@@ -2082,26 +2091,26 @@ nsMediaCacheStream::Seek(PRInt32 aWhence
   return NS_OK;
 }
 
 PRInt64
 nsMediaCacheStream::Tell()
 {
   NS_ASSERTION(!NS_IsMainThread(), "Don't call on main thread");
 
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
   return mStreamOffset;
 }
 
 nsresult
 nsMediaCacheStream::Read(char* aBuffer, PRUint32 aCount, PRUint32* aBytes)
 {
   NS_ASSERTION(!NS_IsMainThread(), "Don't call on main thread");
 
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
   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 =
@@ -2176,17 +2185,17 @@ nsMediaCacheStream::Read(char* aBuffer, 
   return NS_OK;
 }
 
 nsresult
 nsMediaCacheStream::ReadFromCache(char* aBuffer,
                                   PRInt64 aOffset,
                                   PRInt64 aCount)
 {
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
   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);
@@ -2254,17 +2263,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
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
 
   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;
@@ -2284,17 +2293,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.
-  MonitorAutoEnter mon(gMediaCache->GetMonitor());
+  nsAutoMonitor mon(gMediaCache->Monitor());
 
   // 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,23 +35,21 @@
  * 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
@@ -206,18 +204,16 @@ 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
@@ -428,17 +424,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(MonitorAutoEnter& aMonitor);
+  void CloseInternal(nsAutoMonitor* 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,27 +42,26 @@
 #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
@@ -71,36 +70,42 @@ using namespace mozilla;
 // 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("nsMediaDecoder.mVideoUpdateLock"),
+  mVideoUpdateLock(nsnull),
   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;
-  return PR_TRUE;
+  mVideoUpdateLock = nsAutoLock::NewLock("nsMediaDecoder::mVideoUpdateLock");
+
+  return mVideoUpdateLock != nsnull;
 }
 
 void nsMediaDecoder::Shutdown()
 {
   StopProgress();
   mElement = nsnull;
 }
 
@@ -132,17 +137,17 @@ void nsMediaDecoder::Invalidate()
 {
   if (!mElement)
     return;
 
   nsIFrame* frame = mElement->GetPrimaryFrame();
   PRBool invalidateFrame = PR_FALSE;
 
   {
-    MutexAutoLock lock(mVideoUpdateLock);
+    nsAutoLock 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
@@ -248,17 +253,17 @@ void nsMediaDecoder::FireTimeUpdate()
   mElement->FireTimeUpdate(PR_TRUE);
 }
 
 void nsMediaDecoder::SetVideoData(const gfxIntSize& aSize,
                                   float aPixelAspectRatio,
                                   Image* aImage,
                                   TimeStamp aTarget)
 {
-  MutexAutoLock lock(mVideoUpdateLock);
+  nsAutoLock lock(mVideoUpdateLock);
 
   if (mRGBWidth != aSize.width || mRGBHeight != aSize.height ||
       mPixelAspectRatio != aPixelAspectRatio) {
     mRGBWidth = aSize.width;
     mRGBHeight = aSize.height;
     mPixelAspectRatio = aPixelAspectRatio;
     mSizeChanged = PR_TRUE;
   }
@@ -277,17 +282,17 @@ void nsMediaDecoder::SetVideoData(const 
     }
   }
 
   mPaintTarget = aTarget;
 }
 
 double nsMediaDecoder::GetFrameDelay()
 {
-  MutexAutoLock lock(mVideoUpdateLock);
+  nsAutoLock 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,17 +43,16 @@
 #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,
@@ -85,17 +84,16 @@ 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.
@@ -438,17 +436,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.
-  Mutex mVideoUpdateLock;
+  PRLock* 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,35 +56,38 @@
 #include "nsDOMError.h"
 #include "nsICachingChannel.h"
 #include "nsURILoader.h"
 #include "nsIAsyncVerifyRedirectCallback.h"
 
 #define HTTP_OK_CODE 200
 #define HTTP_PARTIAL_RESPONSE_CODE 206
 
-using namespace mozilla;
+using mozilla::TimeStamp;
 
 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("nsMediaChannelStream.mLock"),
+    mLock(nsAutoLock::NewLock("media.channel.stream")),
     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.
@@ -263,17 +266,17 @@ nsMediaChannelStream::OnStartRequest(nsI
     PRBool fromCache = PR_FALSE;
     rv = cc->IsFromCache(&fromCache);
     if (NS_SUCCEEDED(rv) && !fromCache) {
       cc->SetCacheAsFile(PR_TRUE);
     }
   }
 
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock 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();
@@ -289,17 +292,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?");
 
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock 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
@@ -375,17 +378,17 @@ nsMediaChannelStream::CopySegmentToCache
 nsresult
 nsMediaChannelStream::OnDataAvailable(nsIRequest* aRequest,
                                       nsIInputStream* aStream,
                                       PRUint32 aCount)
 {
   NS_ASSERTION(mChannel.get() == aRequest, "Wrong channel!");
 
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock lock(mLock);
     mChannelStatistics.AddBytes(aCount);
   }
 
   CopySegmentClosure closure;
   nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
   if (secMan && mChannel) {
     secMan->GetChannelPrincipal(mChannel, getter_AddRefs(closure.mPrincipal));
   }
@@ -404,16 +407,18 @@ 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)
@@ -539,17 +544,17 @@ nsMediaStream* nsMediaChannelStream::Clo
   return stream;
 }
 
 void nsMediaChannelStream::CloseChannel()
 {
   NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
 
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock lock(mLock);
     mChannelStatistics.Stop(TimeStamp::Now());
   }
 
   if (mListener) {
     mListener->Revoke();
     mListener = nsnull;
   }
 
@@ -618,17 +623,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) {
       {
-        MutexAutoLock lock(mLock);
+        nsAutoLock lock(mLock);
         mChannelStatistics.Stop(TimeStamp::Now());
       }
       mChannel->Suspend();
       element->DownloadSuspended();
     }
   }
 
   ++mSuspendCount;
@@ -646,17 +651,17 @@ void nsMediaChannelStream::Resume()
   }
 
   NS_ASSERTION(mSuspendCount > 0, "Resume without previous Suspend!");
   --mSuspendCount;
   if (mSuspendCount == 0) {
     if (mChannel) {
       // Just wake up our existing channel
       {
-        MutexAutoLock lock(mLock);
+        nsAutoLock 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 {
@@ -752,17 +757,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;
     {
-      MutexAutoLock lock(mLock);
+      nsAutoLock lock(mLock);
       NS_ASSERTION(mCacheSuspendCount > 0, "CacheClientSeek(aResume=true) without previous CacheClientSuspend!");
       --mCacheSuspendCount;
     }
   }
 
   nsresult rv = RecreateChannel();
   if (NS_FAILED(rv))
     return rv;
@@ -770,31 +775,31 @@ nsMediaChannelStream::CacheClientSeek(PR
   mOffset = aOffset;
   return OpenChannel(nsnull);
 }
 
 nsresult
 nsMediaChannelStream::CacheClientSuspend()
 {
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock lock(mLock);
     ++mCacheSuspendCount;
   }
   Suspend(PR_FALSE);
 
   mDecoder->NotifySuspendedStatusChanged();
   return NS_OK;
 }
 
 nsresult
 nsMediaChannelStream::CacheClientResume()
 {
   Resume();
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock lock(mLock);
     NS_ASSERTION(mCacheSuspendCount > 0, "CacheClientResume without previous CacheClientSuspend!");
     --mCacheSuspendCount;
   }
 
   mDecoder->NotifySuspendedStatusChanged();
   return NS_OK;
 }
 
@@ -814,24 +819,24 @@ PRBool
 nsMediaChannelStream::IsDataCachedToEndOfStream(PRInt64 aOffset)
 {
   return mCacheStream.IsDataCachedToEndOfStream(aOffset);
 }
 
 PRBool
 nsMediaChannelStream::IsSuspendedByCache()
 {
-  MutexAutoLock lock(mLock);
+  nsAutoLock lock(mLock);
   return mCacheSuspendCount > 0;
 }
 
 PRBool
 nsMediaChannelStream::IsSuspended()
 {
-  MutexAutoLock lock(mLock);
+  nsAutoLock lock(mLock);
   return mSuspendCount > 0;
 }
 
 void
 nsMediaChannelStream::SetReadMode(nsMediaCacheStream::ReadMode aMode)
 {
   mCacheStream.SetReadMode(aMode);
 }
@@ -852,36 +857,39 @@ void
 nsMediaChannelStream::Unpin()
 {
   mCacheStream.Unpin();
 }
 
 double
 nsMediaChannelStream::GetDownloadRate(PRPackedBool* aIsReliable)
 {
-  MutexAutoLock lock(mLock);
+  nsAutoLock 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("nsMediaFileStream.mLock")
+    mLock(nsAutoLock::NewLock("media.file.stream"))
   {
   }
   ~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();
@@ -922,17 +930,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.
-  Mutex mLock;
+  PRLock* 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;
@@ -1028,17 +1036,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");
 
-  MutexAutoLock lock(mLock);
+  nsAutoLock lock(mLock);
   if (mChannel) {
     mChannel->Cancel(NS_ERROR_PARSED_DATA_CACHED);
     mChannel = nsnull;
     mInput = nsnull;
     mSeekable = nsnull;
   }
 
   return NS_OK;
@@ -1074,17 +1082,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)
 {
-  MutexAutoLock lock(mLock);
+  nsAutoLock 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;
@@ -1103,37 +1111,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)
 {
-  MutexAutoLock lock(mLock);
+  nsAutoLock 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");
 
-  MutexAutoLock lock(mLock);
+  nsAutoLock 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");
 
-  MutexAutoLock lock(mLock);
+  nsAutoLock 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,18 +339,16 @@ 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
@@ -465,14 +463,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
-  Mutex               mLock;
+  PRLock* mLock;
   nsChannelStatistics mChannelStatistics;
   PRUint32            mCacheSuspendCount;
 };
 
 #endif

--- a/dom/src/threads/nsDOMThreadService.cpp
+++ b/dom/src/threads/nsDOMThreadService.cpp
@@ -54,16 +54,17 @@
 #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"
@@ -76,18 +77,16 @@
 #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
 
@@ -368,17 +367,17 @@ public:
     ClearQueue();
   }
 
   void PutRunnable(nsIRunnable* aRunnable,
                    PRIntervalTime aTimeoutInterval,
                    PRBool aClearQueue) {
     NS_ASSERTION(aRunnable, "Null pointer!");
 
-    gDOMThreadService->mMonitor.AssertCurrentThreadIn();
+    PR_ASSERT_CURRENT_THREAD_IN_MONITOR(gDOMThreadService->mMonitor);
 
     if (NS_LIKELY(!aTimeoutInterval)) {
       NS_ADDREF(aRunnable);
       mRunnables.Push(aRunnable);
     }
     else {
       NS_ASSERTION(!mCloseRunnable, "More than one close runnable?!");
       if (aClearQueue) {
@@ -461,17 +460,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);
         }
 
-        MonitorAutoEnter mon(gDOMThreadService->mMonitor);
+        nsAutoMonitor mon(gDOMThreadService->mMonitor);
         killWorkerWhenDone = mKillWorkerWhenDone;
         gDOMThreadService->WorkerComplete(this);
         mon.NotifyAll();
       }
     }
 
     if (killWorkerWhenDone) {
       nsCOMPtr<nsIRunnable> runnable = new nsDOMWorkerKillRunnable(mWorker);
@@ -491,17 +490,17 @@ protected:
       // Loop until all the runnables are dead.
     }
   }
 
   void RunQueue(JSContext* aCx, PRBool* aCloseRunnableSet) {
     while (1) {
       nsCOMPtr<nsIRunnable> runnable;
       {
-        MonitorAutoEnter mon(gDOMThreadService->mMonitor);
+        nsAutoMonitor mon(gDOMThreadService->mMonitor);
 
         runnable = dont_AddRef((nsIRunnable*)mRunnables.PopFront());
 
         if (!runnable && mCloseRunnable) {
           PRIntervalTime expirationTime;
           if (mCloseTimeoutInterval == PR_INTERVAL_NO_TIMEOUT) {
             expirationTime = mCloseTimeoutInterval;
           }
@@ -568,17 +567,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 (;;) {
-      MonitorAutoEnter mon(worker->Pool()->GetMonitor());
+      nsAutoMonitor mon(worker->Pool()->Monitor());
 
       // 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();
@@ -724,17 +723,17 @@ DOMWorkerErrorReporter(JSContext* aCx,
   }
 }
 
 /*******************************************************************************
  * nsDOMThreadService
  */
 
 nsDOMThreadService::nsDOMThreadService()
-: mMonitor("nsDOMThreadServer.mMonitor"),
+: mMonitor(nsnull),
   mNavigatorStringsLoaded(PR_FALSE)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 #ifdef PR_LOGGING
   if (!gDOMThreadsLog) {
     gDOMThreadsLog = PR_NewLogModule("nsDOMThreads");
   }
 #endif
@@ -743,16 +742,20 @@ 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()
@@ -779,16 +782,19 @@ 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);
@@ -879,17 +885,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);
 
   {
-    MonitorAutoEnter mon(mMonitor);
+    nsAutoMonitor mon(mMonitor);
 
     NS_ASSERTION(!mPools.Count(), "Live workers left!");
     mPools.Clear();
 
     NS_ASSERTION(!mSuspendedWorkers.Length(), "Suspended workers left!");
     mSuspendedWorkers.Clear();
   }
 
@@ -944,17 +950,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;
   {
-    MonitorAutoEnter mon(mMonitor);
+    nsAutoMonitor 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);
@@ -967,17 +973,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!");
 
-    MonitorAutoEnter mon(mMonitor);
+    nsAutoMonitor 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);
 
@@ -995,45 +1001,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'!");
 
-  MonitorAutoEnter mon(mMonitor);
+  nsAutoMonitor mon(mMonitor);
 
   nsRefPtr<nsDOMWorkerRunnable> workerRunnable;
   if (mWorkersInProgress.Get(aWorker, getter_AddRefs(workerRunnable))) {
     workerRunnable->SetCloseRunnableTimeout(aTimeoutInterval);
   }
 }
 
 void
 nsDOMThreadService::WorkerComplete(nsDOMWorkerRunnable* aRunnable)
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
 
 #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)
 {
-  MonitorAutoEnter mon(mMonitor);
+  nsAutoMonitor 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!");
     }
@@ -1080,49 +1086,49 @@ nsDOMThreadService::CreateJSContext()
 
   return cx.forget();
 }
 
 already_AddRefed<nsDOMWorkerPool>
 nsDOMThreadService::GetPoolForGlobal(nsIScriptGlobalObject* aGlobalObject,
                                      PRBool aRemove)
 {
-  MonitorAutoEnter mon(mMonitor);
+  nsAutoMonitor mon(mMonitor);
 
   nsRefPtr<nsDOMWorkerPool> pool;
   mPools.Get(aGlobalObject, getter_AddRefs(pool));
 
   if (aRemove) {
     mPools.Remove(aGlobalObject);
   }
 
   return pool.forget();
 }
 
 void
 nsDOMThreadService::TriggerOperationCallbackForPool(nsDOMWorkerPool* aPool)
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
 
   // 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)
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
 
   PRUint32 count = mSuspendedWorkers.Length();
   if (!count) {
     // Nothing to do here.
     return;
   }
 
   nsTArray<nsDOMWorkerRunnable*> others(count);
@@ -1156,59 +1162,59 @@ nsDOMThreadService::RescheduleSuspendedW
 
 void
 nsDOMThreadService::CancelWorkersForGlobal(nsIScriptGlobalObject* aGlobalObject)
 {
   nsRefPtr<nsDOMWorkerPool> pool = GetPoolForGlobal(aGlobalObject, PR_TRUE);
   if (pool) {
     pool->Cancel();
 
-    MonitorAutoEnter mon(mMonitor);
+    nsAutoMonitor 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();
 
-    MonitorAutoEnter mon(mMonitor);
+    nsAutoMonitor 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();
 
-    MonitorAutoEnter mon(mMonitor);
+    nsAutoMonitor mon(mMonitor);
 
     TriggerOperationCallbackForPool(pool);
     RescheduleSuspendedWorkerForPool(pool);
   }
 }
 
 void
 nsDOMThreadService::NoteEmptyPool(nsDOMWorkerPool* aPool)
 {
   NS_ASSERTION(aPool, "Null pointer!");
 
-  MonitorAutoEnter mon(mMonitor);
+  nsAutoMonitor mon(mMonitor);
   mPools.Remove(aPool->ScriptGlobalObject());
 }
 
 void
 nsDOMThreadService::TimeoutReady(nsDOMWorkerTimeout* aTimeout)
 {
   nsRefPtr<nsDOMWorkerTimeoutRunnable> runnable =
     new nsDOMWorkerTimeoutRunnable(aTimeout);
@@ -1217,17 +1223,17 @@ nsDOMThreadService::TimeoutReady(nsDOMWo
   Dispatch(aTimeout->GetWorker(), runnable);
 }
 
 nsresult
 nsDOMThreadService::ChangeThreadPoolMaxThreads(PRInt16 aDelta)
 {
   NS_ENSURE_ARG(aDelta == 1 || aDelta == -1);
 
-  MonitorAutoEnter mon(mMonitor);
+  nsAutoMonitor 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!");
@@ -1255,17 +1261,17 @@ nsDOMThreadService::ChangeThreadPoolMaxT
 }
 
 void
 nsDOMThreadService::NoteThreadsafeContractId(const nsACString& aContractId,
                                              PRBool aIsThreadsafe)
 {
   NS_ASSERTION(!aContractId.IsEmpty(), "Empty contract id!");
 
-  MonitorAutoEnter mon(mMonitor);
+  nsAutoMonitor mon(mMonitor);
 
 #ifdef DEBUG
   {
     PRBool isThreadsafe;
     if (mThreadsafeContractIDs.Get(aContractId, &isThreadsafe)) {
       NS_ASSERTION(aIsThreadsafe == isThreadsafe, "Inconsistent threadsafety!");
     }
   }
@@ -1276,17 +1282,17 @@ nsDOMThreadService::NoteThreadsafeContra
   }
 }
 
 ThreadsafeStatus
 nsDOMThreadService::GetContractIdThreadsafeStatus(const nsACString& aContractId)
 {
   NS_ASSERTION(!aContractId.IsEmpty(), "Empty contract id!");
 
-  MonitorAutoEnter mon(mMonitor);
+  nsAutoMonitor mon(mMonitor);
 
   PRBool isThreadsafe;
   if (mThreadsafeContractIDs.Get(aContractId, &isThreadsafe)) {
     return isThreadsafe ? Threadsafe : NotThreadsafe;
   }
 
   return Unknown;
 }
@@ -1387,17 +1393,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;
     }
 
-    MonitorAutoEnter mon(mMonitor);
+    nsAutoMonitor 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!");
@@ -1416,17 +1422,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) {
     {
-      MonitorAutoEnter mon(mMonitor);
+      nsAutoMonitor mon(mMonitor);
       mJSContexts.RemoveElement(cx);
     }
 
     JSContext* pushedCx;
     gThreadJSContextStack->Pop(&pushedCx);
     NS_ASSERTION(pushedCx == cx, "Popped the wrong context!");
 
     gThreadJSContextStack->SetSafeJSContext(nsnull);
@@ -1462,17 +1468,17 @@ nsDOMThreadService::RegisterWorker(nsDOM
     nsCOMPtr<nsIScriptGlobalObject> newGlobal(do_QueryInterface(innerWindow));
     NS_ENSURE_TRUE(newGlobal, NS_ERROR_NO_INTERFACE);
 
     aGlobalObject = newGlobal;
   }
 
   nsRefPtr<nsDOMWorkerPool> pool;
   {
-    MonitorAutoEnter mon(mMonitor);
+    nsAutoMonitor mon(mMonitor);
 
     if (!mThreadPool) {
       // Shutting down!
       return NS_ERROR_ILLEGAL_DURING_SHUTDOWN;
     }
 
     mPools.Get(aGlobalObject, getter_AddRefs(pool));
   }
@@ -1511,17 +1517,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);
 
-    MonitorAutoEnter mon(mMonitor);
+    nsAutoMonitor 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.
-  mozilla::Monitor mMonitor;
+  PRMonitor* 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,16 +43,17 @@
 #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"
@@ -64,18 +65,16 @@
 #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),
@@ -1347,17 +1346,17 @@ nsDOMWorkerFeature::Release()
 NS_IMPL_QUERY_INTERFACE0(nsDOMWorkerFeature)
 
 nsDOMWorker::nsDOMWorker(nsDOMWorker* aParent,
                          nsIXPConnectWrappedNative* aParentWN,
                          WorkerPrivilegeModel aPrivilegeModel)
 : mParent(aParent),
   mParentWN(aParentWN),
   mPrivilegeModel(aPrivilegeModel),
-  mLock("nsDOMWorker.mLock"),
+  mLock(nsnull),
   mInnerScope(nsnull),
   mGlobal(NULL),
   mNextTimeoutId(0),
   mFeatureSuspendDepth(0),
   mWrappedNative(nsnull),
   mErrorHandlerRecursionCount(0),
   mStatus(eRunning),
   mExpirationTime(0),
@@ -1371,16 +1370,20 @@ 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);
@@ -1492,31 +1495,31 @@ nsDOMWorker::PreCreate(nsISupports* aObj
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDOMWorker::PostCreate(nsIXPConnectWrappedNative* aWrapper,
                         JSContext* /* aCx */,
                         JSObject* /* aObj */)
 {
-  MutexAutoLock lock(mLock);
+  nsAutoLock 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;
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock lock(mLock);
     canceled = mStatus == eKilled;
   }
 
   if (!canceled) {
     nsDOMWorkerMessageHandler::Trace(aTracer);
   }
 
   return NS_OK;
@@ -1529,17 +1532,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.
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock 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();
@@ -1664,16 +1667,19 @@ 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);
 
@@ -1722,17 +1728,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;
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock lock(mLock);
 
     NS_ASSERTION(mStatus != eCanceled, "Canceled more than once?!");
 
     if (mStatus == eKilled) {
       return;
     }
 
     DOMWorkerStatus oldStatus = mStatus;
@@ -1784,17 +1790,17 @@ nsDOMWorker::Kill()
   if (mKillTimer) {
     mKillTimer->Cancel();
     mKillTimer = nsnull;
   }
 
   PRUint32 count, index;
   nsAutoTArray<nsRefPtr<nsDOMWorkerFeature>, 20> features;
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock lock(mLock);
 
     if (mStatus == eKilled) {
       NS_ASSERTION(mFeatures.Length() == 0, "Features added after killed!");
       return;
     }
     mStatus = eKilled;
 
     count = mFeatures.Length();
@@ -1833,17 +1839,17 @@ nsDOMWorker::Kill()
 
 void
 nsDOMWorker::Suspend()
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 
   PRBool shouldSuspendFeatures;
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock lock(mLock);
     NS_ASSERTION(!mSuspended, "Suspended more than once!");
     shouldSuspendFeatures = !mSuspended;
     mSuspended = PR_TRUE;
   }
 
   if (shouldSuspendFeatures) {
     SuspendFeatures();
   }
@@ -1851,17 +1857,17 @@ nsDOMWorker::Suspend()
 
 void
 nsDOMWorker::Resume()
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 
   PRBool shouldResumeFeatures;
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock 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
@@ -1879,17 +1885,17 @@ nsDOMWorker::Resume()
     NS_DispatchToCurrentThread(mQueuedRunnables[index]);
   }
   mQueuedRunnables.Clear();
 }
 
 PRBool
 nsDOMWorker::IsCanceled()
 {
-  MutexAutoLock lock(mLock);
+  nsAutoLock lock(mLock);
   return IsCanceledNoLock();
 }
 
 PRBool
 nsDOMWorker::IsCanceledNoLock()
 {
   // If we haven't started the close process then we're not canceled.
   if (mStatus == eRunning) {
@@ -1913,24 +1919,24 @@ nsDOMWorker::IsCanceledNoLock()
          (mExpirationTime && mExpirationTime != PR_INTERVAL_NO_TIMEOUT &&
           mExpirationTime <= PR_IntervalNow()) ||
          (mStatus == eCanceled && NS_IsMainThread());
 }
 
 PRBool
 nsDOMWorker::IsClosing()
 {
-  MutexAutoLock lock(mLock);
+  nsAutoLock lock(mLock);
   return mStatus != eRunning;
 }
 
 PRBool
 nsDOMWorker::IsSuspended()
 {
-  MutexAutoLock lock(mLock);
+  nsAutoLock lock(mLock);
   return mSuspended;
 }
 
 nsresult
 nsDOMWorker::PostMessageInternal(PRBool aToInner)
 {
   nsIXPConnect* xpc = nsContentUtils::XPConnect();
   NS_ENSURE_TRUE(xpc, NS_ERROR_UNEXPECTED);
@@ -2192,34 +2198,34 @@ nsDOMWorker::SetPool(nsDOMWorkerPool* aP
   mPool = aPool;
 }
 
 already_AddRefed<nsIXPConnectWrappedNative>
 nsDOMWorker::GetWrappedNative()
 {
   nsCOMPtr<nsIXPConnectWrappedNative> wrappedNative;
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock 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);
 
-    MutexAutoLock lock(mLock);
+    nsAutoLock 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);
@@ -2242,34 +2248,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);
 
-    MutexAutoLock lock(mLock);
+    nsAutoLock 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;
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock 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;
@@ -2282,17 +2288,17 @@ nsDOMWorker::CancelTimeoutWithId(PRUint3
   }
 }
 
 void
 nsDOMWorker::SuspendFeatures()
 {
   nsAutoTArray<nsRefPtr<nsDOMWorkerFeature>, 20> features;
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock 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;
@@ -2311,17 +2317,17 @@ nsDOMWorker::SuspendFeatures()
   }
 }
 
 void
 nsDOMWorker::ResumeFeatures()
 {
   nsAutoTArray<nsRefPtr<nsDOMWorkerFeature>, 20> features;
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock lock(mLock);
 
     NS_ASSERTION(mFeatureSuspendDepth > 0, "Shouldn't happen!");
     if (--mFeatureSuspendDepth != 0) {
       return;
     }
 
     features.AppendElements(mFeatures);
   }
@@ -2372,30 +2378,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;
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock 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) {
-    MonitorAutoEnter mon(mPool->GetMonitor());
+    nsAutoMonitor mon(mPool->Monitor());
     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);
@@ -2419,17 +2425,17 @@ nsDOMWorker::FireCloseRunnable(PRInterva
   return nsDOMThreadService::get()->Dispatch(this, runnable, aTimeoutInterval,
                                              aClearQueue);
 }
 
 nsresult
 nsDOMWorker::Close()
 {
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock 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);
@@ -2437,17 +2443,17 @@ nsDOMWorker::Close()
 
   return NS_OK;
 }
 
 nsresult
 nsDOMWorker::TerminateInternal(PRBool aFromFinalize)
 {
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock 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
@@ -2484,31 +2490,31 @@ nsDOMWorker::GetParent()
   nsRefPtr<nsDOMWorker> parent(mParent);
   return parent.forget();
 }
 
 void
 nsDOMWorker::SetExpirationTime(PRIntervalTime aExpirationTime)
 {
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock 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()
 {
-  MutexAutoLock lock(mLock);
+  nsAutoLock lock(mLock);
   return mExpirationTime;
 }
 #endif
 
 // static
 JSObject*
 nsDOMWorker::ReadStructuredClone(JSContext* aCx,
                                  JSStructuredCloneReader* aReader,
@@ -2583,17 +2589,17 @@ nsDOMWorker::RemoveEventListener(const n
                                                         aUseCapture);
 }
 
 NS_IMETHODIMP
 nsDOMWorker::DispatchEvent(nsIDOMEvent* aEvent,
                            PRBool* _retval)
 {
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock 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;
@@ -2624,17 +2630,17 @@ nsDOMWorker::AddEventListener(const nsAS
 
 /**
  * See nsIWorker
  */
 NS_IMETHODIMP
 nsDOMWorker::PostMessage(/* JSObject aMessage */)
 {
   {
-    MutexAutoLock lock(mLock);
+    nsAutoLock 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,18 +138,16 @@ 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;
@@ -211,17 +209,17 @@ public:
   PRBool SetGlobalForContext(JSContext* aCx, nsLazyAutoRequest *aRequest, JSAutoEnterCompartment *aComp);
 
   void SetPool(nsDOMWorkerPool* aPool);
 
   nsDOMWorkerPool* Pool() {
     return mPool;
   }
 
-  Mutex& GetLock() {
+  PRLock* Lock() {
     return mLock;
   }
 
   already_AddRefed<nsIXPConnectWrappedNative> GetWrappedNative();
   already_AddRefed<nsDOMWorker> GetParent();
 
   nsDOMWorkerScope* GetInnerScope() {
     return mInnerScope;
@@ -349,17 +347,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;
 
-  Mutex mLock;
+  PRLock* 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,34 +45,33 @@
 #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("nsDOMWorkerPool.mMonitor"),
+  mMonitor(nsnull),
   mCanceled(PR_FALSE),
   mSuspended(PR_FALSE),
   mWindowID(aDocument ? aDocument->OuterWindowID() : 0)
 {
 }
 
 nsDOMWorkerPool::~nsDOMWorkerPool()
 {
@@ -85,37 +84,45 @@ 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;
 
   {
-    MonitorAutoEnter mon(mMonitor);
+    nsAutoMonitor mon(mMonitor);
 
     if (mCanceled) {
       return NS_ERROR_ABORT;
     }
 
     nsDOMWorker** newWorker = mWorkers.AppendElement(aWorker);
     NS_ENSURE_TRUE(newWorker, NS_ERROR_OUT_OF_MEMORY);
 
@@ -132,17 +139,17 @@ nsDOMWorkerPool::NoteWorker(nsDOMWorker*
 void
 nsDOMWorkerPool::NoteDyingWorker(nsDOMWorker* aWorker)
 {
   NS_ASSERTION(aWorker, "Null pointer!");
 
   PRBool removeFromThreadService = PR_FALSE;
 
   {
-    MonitorAutoEnter mon(mMonitor);
+    nsAutoMonitor mon(mMonitor);
 
     NS_ASSERTION(mWorkers.Contains(aWorker), "Worker from a different pool?!");
     mWorkers.RemoveElement(aWorker);
 
     if (!mCanceled && !mWorkers.Length()) {
       removeFromThreadService = PR_TRUE;
     }
   }
@@ -151,17 +158,17 @@ nsDOMWorkerPool::NoteDyingWorker(nsDOMWo
     nsRefPtr<nsDOMWorkerPool> kungFuDeathGrip(this);
     nsDOMThreadService::get()->NoteEmptyPool(this);
   }
 }
 
 void
 nsDOMWorkerPool::GetWorkers(nsTArray<nsDOMWorker*>& aArray)
 {
-  mMonitor.AssertCurrentThreadIn();
+  PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mMonitor);
   NS_ASSERTION(!aArray.Length(), "Should be empty!");
 
 #ifdef DEBUG
   nsDOMWorker** newWorkers =
 #endif
   aArray.AppendElements(mWorkers);
   NS_WARN_IF_FALSE(newWorkers, "Out of memory!");
 }
@@ -169,41 +176,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;
   {
-    MonitorAutoEnter mon(mMonitor);
+    nsAutoMonitor mon(mMonitor);
 
     mCanceled = PR_TRUE;
 
     GetWorkers(workers);
   }
 
   PRUint32 count = workers.Length();
   if (count) {
     for (PRUint32 index = 0; index < count; index++) {
       workers[index]->Cancel();
     }
-    MonitorAutoEnter mon(mMonitor);
+    nsAutoMonitor mon(mMonitor);
     mon.NotifyAll();
   }
 }
 
 void
 nsDOMWorkerPool::Suspend()
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 
   nsAutoTArray<nsDOMWorker*, 10> workers;
   {
-    MonitorAutoEnter mon(mMonitor);
+    nsAutoMonitor mon(mMonitor);
 
     NS_ASSERTION(!mSuspended, "Suspended more than once!");
     mSuspended = PR_TRUE;
 
     GetWorkers(workers);
   }
 
   PRUint32 count = workers.Length();
@@ -214,25 +221,25 @@ nsDOMWorkerPool::Suspend()
 
 void
 nsDOMWorkerPool::Resume()
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 
   nsAutoTArray<nsDOMWorker*, 10> workers;
   {
-    MonitorAutoEnter mon(mMonitor);
+    nsAutoMonitor 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();
     }
-    MonitorAutoEnter mon(mMonitor);
+    nsAutoMonitor mon(mMonitor);
     mon.NotifyAll();
   }
 }

--- a/dom/src/threads/nsDOMWorkerPool.h
+++ b/dom/src/threads/nsDOMWorkerPool.h
@@ -37,31 +37,29 @@
  *
  * ***** 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() {
@@ -76,17 +74,17 @@ public:
 
   void Cancel();
   void Suspend();
   void Resume();
 
   nsresult NoteWorker(nsDOMWorker* aWorker);
   void NoteDyingWorker(nsDOMWorker* aWorker);
 
-  Monitor& GetMonitor() {
+  PRMonitor* Monitor() {
     return mMonitor;
   }
 
   const PRUint64 WindowID() const {
     return mWindowID;
   }
 
 private:
@@ -102,17 +100,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.
-  Monitor mMonitor;
+  PRMonitor* mMonitor;
 
   PRPackedBool mCanceled;
   PRPackedBool mSuspended;
 
   const PRUint64 mWindowID;
 };
 
 #endif /* __NSDOMWORKERPOOL_H__ */