--- 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(¤tThreadCount);
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;
