--- a/netwerk/base/public/nsAsyncRedirectVerifyHelper.h
+++ b/netwerk/base/public/nsAsyncRedirectVerifyHelper.h
@@ -21,17 +21,17 @@ class nsIChannel;
/**
* This class simplifies call of OnChannelRedirect of IOService and
* the sink bound with the channel being redirected while the result of
* redirect decision is returned through the callback.
*/
class nsAsyncRedirectVerifyHelper MOZ_FINAL : public nsIRunnable,
public nsIAsyncVerifyRedirectCallback
{
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIRUNNABLE
NS_DECL_NSIASYNCVERIFYREDIRECTCALLBACK
public:
nsAsyncRedirectVerifyHelper();
/*
* Calls AsyncOnChannelRedirect() on the given sink with the given
--- a/netwerk/base/src/BackgroundFileSaver.cpp
+++ b/netwerk/base/src/BackgroundFileSaver.cpp
@@ -703,21 +703,21 @@ BackgroundFileSaver::NotifySaveComplete(
}
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
//// BackgroundFileSaverOutputStream
-NS_IMPL_THREADSAFE_ISUPPORTS4(BackgroundFileSaverOutputStream,
- nsIBackgroundFileSaver,
- nsIOutputStream,
- nsIAsyncOutputStream,
- nsIOutputStreamCallback)
+NS_IMPL_ISUPPORTS4(BackgroundFileSaverOutputStream,
+ nsIBackgroundFileSaver,
+ nsIOutputStream,
+ nsIAsyncOutputStream,
+ nsIOutputStreamCallback)
BackgroundFileSaverOutputStream::BackgroundFileSaverOutputStream()
: BackgroundFileSaver()
, mAsyncWaitCallback(nullptr)
{
}
BackgroundFileSaverOutputStream::~BackgroundFileSaverOutputStream()
@@ -806,20 +806,20 @@ BackgroundFileSaverOutputStream::OnOutpu
asyncWaitCallback.swap(mAsyncWaitCallback);
return asyncWaitCallback->OnOutputStreamReady(this);
}
////////////////////////////////////////////////////////////////////////////////
//// BackgroundFileSaverStreamListener
-NS_IMPL_THREADSAFE_ISUPPORTS3(BackgroundFileSaverStreamListener,
- nsIBackgroundFileSaver,
- nsIRequestObserver,
- nsIStreamListener)
+NS_IMPL_ISUPPORTS3(BackgroundFileSaverStreamListener,
+ nsIBackgroundFileSaver,
+ nsIRequestObserver,
+ nsIStreamListener)
BackgroundFileSaverStreamListener::BackgroundFileSaverStreamListener()
: BackgroundFileSaver()
, mSuspensionLock("BackgroundFileSaverStreamListener.mSuspensionLock")
, mReceivedTooMuchData(false)
, mRequest(nullptr)
, mRequestSuspended(false)
{
@@ -970,18 +970,18 @@ BackgroundFileSaverStreamListener::Notif
}
}
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
//// DigestOutputStream
-NS_IMPL_THREADSAFE_ISUPPORTS1(DigestOutputStream,
- nsIOutputStream)
+NS_IMPL_ISUPPORTS1(DigestOutputStream,
+ nsIOutputStream)
DigestOutputStream::DigestOutputStream(nsIOutputStream* aStream,
PK11Context* aContext) :
mOutputStream(aStream)
, mDigestContext(aContext)
{
MOZ_ASSERT(mDigestContext, "Can't have null digest context");
MOZ_ASSERT(mOutputStream, "Can't have null output stream");
--- a/netwerk/base/src/BackgroundFileSaver.h
+++ b/netwerk/base/src/BackgroundFileSaver.h
@@ -266,17 +266,17 @@ private:
////////////////////////////////////////////////////////////////////////////////
//// BackgroundFileSaverOutputStream
class BackgroundFileSaverOutputStream : public BackgroundFileSaver
, public nsIAsyncOutputStream
, public nsIOutputStreamCallback
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIOUTPUTSTREAM
NS_DECL_NSIASYNCOUTPUTSTREAM
NS_DECL_NSIOUTPUTSTREAMCALLBACK
BackgroundFileSaverOutputStream();
protected:
virtual bool HasInfiniteBuffer() MOZ_OVERRIDE;
@@ -294,17 +294,17 @@ private:
////////////////////////////////////////////////////////////////////////////////
//// BackgroundFileSaverStreamListener. This class is instantiated by
// nsExternalHelperAppService, DownloadCore.jsm, and possibly others.
class BackgroundFileSaverStreamListener : public BackgroundFileSaver
, public nsIStreamListener
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIREQUESTOBSERVER
NS_DECL_NSISTREAMLISTENER
BackgroundFileSaverStreamListener();
protected:
virtual bool HasInfiniteBuffer() MOZ_OVERRIDE;
virtual nsAsyncCopyProgressFun GetProgressCallback() MOZ_OVERRIDE;
@@ -346,17 +346,17 @@ private:
// A wrapper around nsIOutputStream, so that we can compute hashes on the
// stream without copying and without polluting pristine NSS code with XPCOM
// interfaces.
class DigestOutputStream : public nsNSSShutDownObject,
public nsIOutputStream
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIOUTPUTSTREAM
// Constructor. Neither parameter may be null. The caller owns both.
DigestOutputStream(nsIOutputStream* outputStream, PK11Context* aContext);
~DigestOutputStream();
// We don't own any NSS objects here, so no need to clean up
void virtualDestroyNSSReference() { }
--- a/netwerk/base/src/Dashboard.cpp
+++ b/netwerk/base/src/Dashboard.cpp
@@ -8,17 +8,17 @@
#include "mozilla/net/HttpInfo.h"
#include "mozilla/dom/NetDashboardBinding.h"
#include "jsapi.h"
using mozilla::AutoSafeJSContext;
namespace mozilla {
namespace net {
-NS_IMPL_THREADSAFE_ISUPPORTS2(Dashboard, nsIDashboard, nsIDashboardEventNotifier)
+NS_IMPL_ISUPPORTS2(Dashboard, nsIDashboard, nsIDashboardEventNotifier)
using mozilla::dom::Sequence;
Dashboard::Dashboard()
{
mEnableLogging = false;
}
Dashboard::~Dashboard()
--- a/netwerk/base/src/Dashboard.h
+++ b/netwerk/base/src/Dashboard.h
@@ -19,17 +19,17 @@
namespace mozilla {
namespace net {
class Dashboard:
public nsIDashboard,
public nsIDashboardEventNotifier
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIDASHBOARD
NS_DECL_NSIDASHBOARDEVENTNOTIFIER
Dashboard();
private:
virtual ~Dashboard();
void GetSocketsDispatch();
--- a/netwerk/base/src/EventTokenBucket.cpp
+++ b/netwerk/base/src/EventTokenBucket.cpp
@@ -21,29 +21,29 @@ namespace net {
////////////////////////////////////////////
// EventTokenBucketCancelable
////////////////////////////////////////////
class TokenBucketCancelable : public nsICancelable
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSICANCELABLE
TokenBucketCancelable(class ATokenBucketEvent *event);
virtual ~TokenBucketCancelable() {}
void Fire();
private:
friend class EventTokenBucket;
ATokenBucketEvent *mEvent;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(TokenBucketCancelable, nsICancelable)
+NS_IMPL_ISUPPORTS1(TokenBucketCancelable, nsICancelable)
TokenBucketCancelable::TokenBucketCancelable(ATokenBucketEvent *event)
: mEvent(event)
{
}
NS_IMETHODIMP
TokenBucketCancelable::Cancel(nsresult reason)
@@ -63,17 +63,17 @@ TokenBucketCancelable::Fire()
mEvent = nullptr;
event->OnTokenBucketAdmitted();
}
////////////////////////////////////////////
// EventTokenBucket
////////////////////////////////////////////
-NS_IMPL_THREADSAFE_ISUPPORTS1(EventTokenBucket, nsITimerCallback)
+NS_IMPL_ISUPPORTS1(EventTokenBucket, nsITimerCallback)
// by default 1hz with no burst
EventTokenBucket::EventTokenBucket(uint32_t eventsPerSecond,
uint32_t burstSize)
: mUnitCost(kUsecPerSec)
, mMaxCredit(kUsecPerSec)
, mCredit(kUsecPerSec)
, mPaused(false)
--- a/netwerk/base/src/EventTokenBucket.h
+++ b/netwerk/base/src/EventTokenBucket.h
@@ -64,17 +64,17 @@ public:
virtual void OnTokenBucketAdmitted() = 0;
};
class TokenBucketCancelable;
class EventTokenBucket : public nsITimerCallback
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSITIMERCALLBACK
// This should be constructed on the main thread
EventTokenBucket(uint32_t eventsPerSecond, uint32_t burstSize);
virtual ~EventTokenBucket();
// These public methods are all meant to be called from the socket thread
void ClearCredits();
--- a/netwerk/base/src/ProxyAutoConfig.cpp
+++ b/netwerk/base/src/ProxyAutoConfig.cpp
@@ -244,17 +244,17 @@ static const char *sPacUtils =
// or reset.
static ProxyAutoConfig *sRunning = nullptr;
// The PACResolver is used for dnsResolve()
class PACResolver MOZ_FINAL : public nsIDNSListener
, public nsITimerCallback
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
PACResolver()
: mStatus(NS_ERROR_FAILURE)
{
}
// nsIDNSListener
NS_IMETHODIMP OnLookupComplete(nsICancelable *request,
@@ -281,17 +281,17 @@ public:
return NS_OK;
}
nsresult mStatus;
nsCOMPtr<nsICancelable> mRequest;
nsCOMPtr<nsIDNSRecord> mResponse;
nsCOMPtr<nsITimer> mTimer;
};
-NS_IMPL_THREADSAFE_ISUPPORTS2(PACResolver, nsIDNSListener, nsITimerCallback)
+NS_IMPL_ISUPPORTS2(PACResolver, nsIDNSListener, nsITimerCallback)
static
void PACLogToConsole(nsString &aMessage)
{
nsCOMPtr<nsIConsoleService> consoleService =
do_GetService(NS_CONSOLESERVICE_CONTRACTID);
if (!consoleService)
return;
--- a/netwerk/base/src/Tickler.cpp
+++ b/netwerk/base/src/Tickler.cpp
@@ -12,17 +12,17 @@
#ifdef MOZ_USE_WIFI_TICKLER
#include "AndroidBridge.h"
namespace mozilla {
namespace net {
-NS_IMPL_THREADSAFE_ISUPPORTS1(Tickler, nsISupportsWeakReference)
+NS_IMPL_ISUPPORTS1(Tickler, nsISupportsWeakReference)
Tickler::Tickler()
: mLock("Tickler::mLock")
, mActive(false)
, mCanceled(false)
, mEnabled(false)
, mDelay(16)
, mDuration(TimeDuration::FromMilliseconds(400))
@@ -185,17 +185,17 @@ void Tickler::StopTickler()
MOZ_ASSERT(mActive);
mTimer->Cancel();
mActive = false;
}
class TicklerTimer MOZ_FINAL : public nsITimerCallback
{
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSITIMERCALLBACK
TicklerTimer(Tickler *aTickler)
{
mTickler = do_GetWeakReference(aTickler);
}
~TicklerTimer() {};
@@ -224,17 +224,17 @@ void Tickler::SetIPV4Address(uint32_t ad
}
// argument should be in network byte order
void Tickler::SetIPV4Port(uint16_t port)
{
mAddr.inet.port = port;
}
-NS_IMPL_THREADSAFE_ISUPPORTS1(TicklerTimer, nsITimerCallback)
+NS_IMPL_ISUPPORTS1(TicklerTimer, nsITimerCallback)
NS_IMETHODIMP TicklerTimer::Notify(nsITimer *timer)
{
nsRefPtr<Tickler> tickler = do_QueryReferent(mTickler);
if (!tickler)
return NS_ERROR_FAILURE;
MutexAutoLock lock(tickler->mLock);
@@ -258,14 +258,14 @@ NS_IMETHODIMP TicklerTimer::Notify(nsITi
} // namespace mozilla::net
} // namespace mozilla
#else // not defined MOZ_USE_WIFI_TICKLER
namespace mozilla {
namespace net {
-NS_IMPL_THREADSAFE_ISUPPORTS0(Tickler)
+NS_IMPL_ISUPPORTS0(Tickler)
} // namespace mozilla::net
} // namespace mozilla
#endif // defined MOZ_USE_WIFI_TICKLER
--- a/netwerk/base/src/Tickler.h
+++ b/netwerk/base/src/Tickler.h
@@ -45,17 +45,17 @@ namespace net {
#define MOZ_USE_WIFI_TICKLER
#endif
#ifdef MOZ_USE_WIFI_TICKLER
class Tickler MOZ_FINAL : public nsSupportsWeakReference
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
// These methods are main thread only
Tickler();
~Tickler();
void Cancel();
nsresult Init();
void SetIPV4Address(uint32_t address);
void SetIPV4Port(uint16_t port);
@@ -92,17 +92,17 @@ private:
void StopTickler();
};
#else // not defined MOZ_USE_WIFI_TICKLER
class Tickler MOZ_FINAL : public nsISupports
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
Tickler() { }
~Tickler() { }
nsresult Init() { return NS_ERROR_NOT_IMPLEMENTED; }
void Cancel() { }
void SetIPV4Address(uint32_t) { };
void SetIPV4Port(uint16_t) { }
void Tickle() { }
--- a/netwerk/base/src/nsAsyncRedirectVerifyHelper.cpp
+++ b/netwerk/base/src/nsAsyncRedirectVerifyHelper.cpp
@@ -26,19 +26,19 @@ GetRedirectLog()
sLog = PR_NewLogModule("nsRedirect");
return sLog;
}
#define LOG(args) PR_LOG(GetRedirectLog(), PR_LOG_DEBUG, args)
#else
#define LOG(args)
#endif
-NS_IMPL_THREADSAFE_ISUPPORTS2(nsAsyncRedirectVerifyHelper,
- nsIAsyncVerifyRedirectCallback,
- nsIRunnable)
+NS_IMPL_ISUPPORTS2(nsAsyncRedirectVerifyHelper,
+ nsIAsyncVerifyRedirectCallback,
+ nsIRunnable)
class nsAsyncVerifyRedirectCallbackEvent : public nsRunnable {
public:
nsAsyncVerifyRedirectCallbackEvent(nsIAsyncVerifyRedirectCallback *cb,
nsresult result)
: mCallback(cb), mResult(result) {
}
--- a/netwerk/base/src/nsAsyncStreamCopier.cpp
+++ b/netwerk/base/src/nsAsyncStreamCopier.cpp
@@ -83,17 +83,17 @@ nsAsyncStreamCopier::OnAsyncCopyComplete
nsAsyncStreamCopier *self = (nsAsyncStreamCopier *) closure;
self->Complete(status);
NS_RELEASE(self); // addref'd in AsyncCopy
}
//-----------------------------------------------------------------------------
// nsISupports
-NS_IMPL_THREADSAFE_ISUPPORTS2(nsAsyncStreamCopier,
+NS_IMPL_ISUPPORTS2(nsAsyncStreamCopier,
nsIRequest,
nsIAsyncStreamCopier)
//-----------------------------------------------------------------------------
// nsIRequest
NS_IMETHODIMP
nsAsyncStreamCopier::GetName(nsACString &name)
--- a/netwerk/base/src/nsAsyncStreamCopier.h
+++ b/netwerk/base/src/nsAsyncStreamCopier.h
@@ -13,17 +13,17 @@
#include "nsStreamUtils.h"
#include "nsCOMPtr.h"
//-----------------------------------------------------------------------------
class nsAsyncStreamCopier : public nsIAsyncStreamCopier
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIREQUEST
NS_DECL_NSIASYNCSTREAMCOPIER
nsAsyncStreamCopier();
virtual ~nsAsyncStreamCopier();
//-------------------------------------------------------------------------
// these methods may be called on any thread
--- a/netwerk/base/src/nsBaseContentStream.cpp
+++ b/netwerk/base/src/nsBaseContentStream.cpp
@@ -27,18 +27,18 @@ nsBaseContentStream::DispatchCallback(bo
mCallbackTarget = nullptr;
callback->OnInputStreamReady(this);
}
//-----------------------------------------------------------------------------
// nsBaseContentStream::nsISupports
-NS_IMPL_THREADSAFE_ADDREF(nsBaseContentStream)
-NS_IMPL_THREADSAFE_RELEASE(nsBaseContentStream)
+NS_IMPL_ADDREF(nsBaseContentStream)
+NS_IMPL_RELEASE(nsBaseContentStream)
// We only support nsIAsyncInputStream when we are in non-blocking mode.
NS_INTERFACE_MAP_BEGIN(nsBaseContentStream)
NS_INTERFACE_MAP_ENTRY(nsIInputStream)
NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAsyncInputStream, mNonBlocking)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIInputStream)
NS_INTERFACE_MAP_END_THREADSAFE
--- a/netwerk/base/src/nsBaseContentStream.h
+++ b/netwerk/base/src/nsBaseContentStream.h
@@ -31,17 +31,17 @@
// base stream's CloseWithStatus (and Close) method will ensure that any
// pending callback is dispatched. It is the responsibility of the subclass
// to ensure that the pending callback is dispatched when it wants to have its
// ReadSegments method called again.
class nsBaseContentStream : public nsIAsyncInputStream
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIINPUTSTREAM
NS_DECL_NSIASYNCINPUTSTREAM
nsBaseContentStream(bool nonBlocking)
: mStatus(NS_OK)
, mNonBlocking(nonBlocking) {
}
--- a/netwerk/base/src/nsBufferedStreams.cpp
+++ b/netwerk/base/src/nsBufferedStreams.cpp
@@ -56,17 +56,17 @@ nsBufferedStream::nsBufferedStream()
{
}
nsBufferedStream::~nsBufferedStream()
{
Close();
}
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsBufferedStream, nsISeekableStream)
+NS_IMPL_ISUPPORTS1(nsBufferedStream, nsISeekableStream)
nsresult
nsBufferedStream::Init(nsISupports* stream, uint32_t bufferSize)
{
NS_ASSERTION(stream, "need to supply a stream");
NS_ASSERTION(mStream == nullptr, "already inited");
mStream = stream;
NS_IF_ADDREF(mStream);
--- a/netwerk/base/src/nsBufferedStreams.h
+++ b/netwerk/base/src/nsBufferedStreams.h
@@ -15,17 +15,17 @@
#include "nsCOMPtr.h"
#include "nsIIPCSerializableInputStream.h"
////////////////////////////////////////////////////////////////////////////////
class nsBufferedStream : public nsISeekableStream
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSISEEKABLESTREAM
nsBufferedStream();
virtual ~nsBufferedStream();
nsresult Close();
protected:
--- a/netwerk/base/src/nsDNSPrefetch.cpp
+++ b/netwerk/base/src/nsDNSPrefetch.cpp
@@ -74,17 +74,17 @@ nsDNSPrefetch::PrefetchMedium()
nsresult
nsDNSPrefetch::PrefetchHigh()
{
return Prefetch(0);
}
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsDNSPrefetch, nsIDNSListener)
+NS_IMPL_ISUPPORTS1(nsDNSPrefetch, nsIDNSListener)
NS_IMETHODIMP
nsDNSPrefetch::OnLookupComplete(nsICancelable *request,
nsIDNSRecord *rec,
nsresult status)
{
if (mStoreTiming)
mEndTimestamp = mozilla::TimeStamp::Now();
--- a/netwerk/base/src/nsDNSPrefetch.h
+++ b/netwerk/base/src/nsDNSPrefetch.h
@@ -14,17 +14,17 @@
#include "nsIDNSListener.h"
class nsIURI;
class nsIDNSService;
class nsDNSPrefetch MOZ_FINAL : public nsIDNSListener
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIDNSLISTENER
nsDNSPrefetch(nsIURI *aURI, bool storeTiming);
bool TimingsValid() const {
return !mStartTimestamp.IsNull() && !mEndTimestamp.IsNull();
}
// Only use the two timings if TimingsValid() returns true
const mozilla::TimeStamp& StartTimestamp() const { return mStartTimestamp; }
--- a/netwerk/base/src/nsDirectoryIndexStream.cpp
+++ b/netwerk/base/src/nsDirectoryIndexStream.cpp
@@ -183,17 +183,17 @@ nsDirectoryIndexStream::Create(nsIFile*
return rv;
}
*aResult = result;
NS_ADDREF(*aResult);
return NS_OK;
}
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsDirectoryIndexStream, nsIInputStream)
+NS_IMPL_ISUPPORTS1(nsDirectoryIndexStream, nsIInputStream)
// The below routines are proxied to the UI thread!
NS_IMETHODIMP
nsDirectoryIndexStream::Close()
{
mStatus = NS_BASE_STREAM_CLOSED;
return NS_OK;
}
--- a/netwerk/base/src/nsDirectoryIndexStream.h
+++ b/netwerk/base/src/nsDirectoryIndexStream.h
@@ -35,16 +35,16 @@ private:
public:
/**
* aDir will only be used on the calling thread.
*/
static nsresult
Create(nsIFile* aDir, nsIInputStream** aStreamResult);
// nsISupportsInterface
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
// nsIInputStream interface
NS_DECL_NSIINPUTSTREAM
};
#endif // nsDirectoryIndexStream_h__
--- a/netwerk/base/src/nsFileStreams.cpp
+++ b/netwerk/base/src/nsFileStreams.cpp
@@ -46,19 +46,19 @@ nsFileStreamBase::nsFileStreamBase()
{
}
nsFileStreamBase::~nsFileStreamBase()
{
Close();
}
-NS_IMPL_THREADSAFE_ISUPPORTS2(nsFileStreamBase,
- nsISeekableStream,
- nsIFileMetadata)
+NS_IMPL_ISUPPORTS2(nsFileStreamBase,
+ nsISeekableStream,
+ nsIFileMetadata)
NS_IMETHODIMP
nsFileStreamBase::Seek(int32_t whence, int64_t offset)
{
nsresult rv = DoPendingOpen();
NS_ENSURE_SUCCESS(rv, rv);
if (mFD == nullptr)
--- a/netwerk/base/src/nsFileStreams.h
+++ b/netwerk/base/src/nsFileStreams.h
@@ -24,17 +24,17 @@
////////////////////////////////////////////////////////////////////////////////
class nsFileStreamBase : public nsISeekableStream,
public nsIFileMetadata
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSISEEKABLESTREAM
NS_DECL_NSIFILEMETADATA
nsFileStreamBase();
virtual ~nsFileStreamBase();
protected:
nsresult Close();
--- a/netwerk/base/src/nsIOService.cpp
+++ b/netwerk/base/src/nsIOService.cpp
@@ -296,23 +296,23 @@ nsIOService::GetInstance() {
return nullptr;
}
return gIOService;
}
NS_ADDREF(gIOService);
return gIOService;
}
-NS_IMPL_THREADSAFE_ISUPPORTS6(nsIOService,
- nsIIOService,
- nsIIOService2,
- nsINetUtil,
- nsISpeculativeConnect,
- nsIObserver,
- nsISupportsWeakReference)
+NS_IMPL_ISUPPORTS6(nsIOService,
+ nsIIOService,
+ nsIIOService2,
+ nsINetUtil,
+ nsISpeculativeConnect,
+ nsIObserver,
+ nsISupportsWeakReference)
////////////////////////////////////////////////////////////////////////////////
nsresult
nsIOService::AsyncOnChannelRedirect(nsIChannel* oldChan, nsIChannel* newChan,
uint32_t flags,
nsAsyncRedirectVerifyHelper *helper)
{
--- a/netwerk/base/src/nsIOService.h
+++ b/netwerk/base/src/nsIOService.h
@@ -43,17 +43,17 @@ class nsIPrefBranch;
class nsIOService MOZ_FINAL : public nsIIOService2
, public nsIObserver
, public nsINetUtil
, public nsISpeculativeConnect
, public nsSupportsWeakReference
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIIOSERVICE
NS_DECL_NSIIOSERVICE2
NS_DECL_NSIOBSERVER
NS_DECL_NSINETUTIL
NS_DECL_NSISPECULATIVECONNECT
// Gets the singleton instance of the IO Service, creating it as needed
// Returns nullptr on out of memory or failure to initialize.
--- a/netwerk/base/src/nsIOThreadPool.cpp
+++ b/netwerk/base/src/nsIOThreadPool.cpp
@@ -38,17 +38,17 @@ static PRLogModuleInfo *gIOThreadPoolLog
// more than THREAD_IDLE_TIMEOUT. the thread pool shuts down when it receives
// the "xpcom-shutdown-threads" event.
//-----------------------------------------------------------------------------
class nsIOThreadPool : public nsIEventTarget
, public nsIObserver
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIEVENTTARGET
NS_DECL_NSIOBSERVER
nsresult Init();
void Shutdown();
private:
virtual ~nsIOThreadPool();
@@ -61,17 +61,17 @@ private:
PRCondVar *mExitThreadCV; // notified when a thread exits
uint32_t mNumThreads; // number of active + idle threads
uint32_t mNumIdleThreads; // number of idle threads
PRCList mEventQ; // queue of PLEvent structs
bool mShutdown; // set to true if shutting down
nsThreadPoolNaming mNaming; // thread name numbering
};
-NS_IMPL_THREADSAFE_ISUPPORTS2(nsIOThreadPool, nsIEventTarget, nsIObserver)
+NS_IMPL_ISUPPORTS2(nsIOThreadPool, nsIEventTarget, nsIObserver)
nsresult
nsIOThreadPool::Init()
{
#if defined(PR_LOGGING)
if (!gIOThreadPoolLog)
gIOThreadPoolLog = PR_NewLogModule("nsIOThreadPool");
#endif
--- a/netwerk/base/src/nsInputStreamPump.cpp
+++ b/netwerk/base/src/nsInputStreamPump.cpp
@@ -150,21 +150,21 @@ nsInputStreamPump::EnsureWaiting()
//-----------------------------------------------------------------------------
// nsInputStreamPump::nsISupports
//-----------------------------------------------------------------------------
// although this class can only be accessed from one thread at a time, we do
// allow its ownership to move from thread to thread, assuming the consumer
// understands the limitations of this.
-NS_IMPL_THREADSAFE_ISUPPORTS4(nsInputStreamPump,
- nsIRequest,
- nsIThreadRetargetableRequest,
- nsIInputStreamCallback,
- nsIInputStreamPump)
+NS_IMPL_ISUPPORTS4(nsInputStreamPump,
+ nsIRequest,
+ nsIThreadRetargetableRequest,
+ nsIInputStreamCallback,
+ nsIInputStreamPump)
//-----------------------------------------------------------------------------
// nsInputStreamPump::nsIRequest
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsInputStreamPump::GetName(nsACString &result)
{
--- a/netwerk/base/src/nsInputStreamPump.h
+++ b/netwerk/base/src/nsInputStreamPump.h
@@ -19,17 +19,17 @@
#include "nsCOMPtr.h"
#include "mozilla/Attributes.h"
class nsInputStreamPump MOZ_FINAL : public nsIInputStreamPump
, public nsIInputStreamCallback
, public nsIThreadRetargetableRequest
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIREQUEST
NS_DECL_NSIINPUTSTREAMPUMP
NS_DECL_NSIINPUTSTREAMCALLBACK
NS_DECL_NSITHREADRETARGETABLEREQUEST
nsInputStreamPump();
~nsInputStreamPump();
--- a/netwerk/base/src/nsLoadGroup.cpp
+++ b/netwerk/base/src/nsLoadGroup.cpp
@@ -1043,26 +1043,26 @@ nsresult nsLoadGroup::MergeLoadFlags(nsI
return rv;
}
// nsLoadGroupConnectionInfo
class nsLoadGroupConnectionInfo MOZ_FINAL : public nsILoadGroupConnectionInfo
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSILOADGROUPCONNECTIONINFO
nsLoadGroupConnectionInfo();
private:
int32_t mBlockingTransactionCount; // signed for PR_ATOMIC_*
nsAutoPtr<mozilla::net::SpdyPushCache3> mSpdyCache3;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsLoadGroupConnectionInfo, nsILoadGroupConnectionInfo)
+NS_IMPL_ISUPPORTS1(nsLoadGroupConnectionInfo, nsILoadGroupConnectionInfo)
nsLoadGroupConnectionInfo::nsLoadGroupConnectionInfo()
: mBlockingTransactionCount(0)
{
}
NS_IMETHODIMP
nsLoadGroupConnectionInfo::GetBlockingTransactionCount(uint32_t *aBlockingTransactionCount)
--- a/netwerk/base/src/nsMIMEInputStream.cpp
+++ b/netwerk/base/src/nsMIMEInputStream.cpp
@@ -27,17 +27,17 @@ using namespace mozilla::ipc;
class nsMIMEInputStream : public nsIMIMEInputStream,
public nsISeekableStream,
public nsIIPCSerializableInputStream
{
public:
nsMIMEInputStream();
virtual ~nsMIMEInputStream();
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIINPUTSTREAM
NS_DECL_NSIMIMEINPUTSTREAM
NS_DECL_NSISEEKABLESTREAM
NS_DECL_NSIIPCSERIALIZABLEINPUTSTREAM
NS_METHOD Init();
private:
@@ -60,18 +60,18 @@ private:
nsCOMPtr<nsIStringInputStream> mCLStream;
nsCOMPtr<nsIInputStream> mData;
nsCOMPtr<nsIMultiplexInputStream> mStream;
bool mAddContentLength;
bool mStartedReading;
};
-NS_IMPL_THREADSAFE_ADDREF(nsMIMEInputStream)
-NS_IMPL_THREADSAFE_RELEASE(nsMIMEInputStream)
+NS_IMPL_ADDREF(nsMIMEInputStream)
+NS_IMPL_RELEASE(nsMIMEInputStream)
NS_IMPL_CLASSINFO(nsMIMEInputStream, NULL, nsIClassInfo::THREADSAFE,
NS_MIMEINPUTSTREAM_CID)
NS_IMPL_QUERY_INTERFACE4_CI(nsMIMEInputStream,
nsIMIMEInputStream,
nsIInputStream,
nsISeekableStream,
--- a/netwerk/base/src/nsPACMan.cpp
+++ b/netwerk/base/src/nsPACMan.cpp
@@ -557,18 +557,18 @@ nsPACMan::ProcessPending()
nsresult status = mPAC.GetProxyForURI(query->mSpec, query->mHost, pacString);
query->Complete(status, pacString);
}
mInProgress = false;
return true;
}
-NS_IMPL_THREADSAFE_ISUPPORTS3(nsPACMan, nsIStreamLoaderObserver,
- nsIInterfaceRequestor, nsIChannelEventSink)
+NS_IMPL_ISUPPORTS3(nsPACMan, nsIStreamLoaderObserver,
+ nsIInterfaceRequestor, nsIChannelEventSink)
NS_IMETHODIMP
nsPACMan::OnStreamComplete(nsIStreamLoader *loader,
nsISupports *context,
nsresult status,
uint32_t dataLen,
const uint8_t *data)
{
--- a/netwerk/base/src/nsPACMan.h
+++ b/netwerk/base/src/nsPACMan.h
@@ -78,17 +78,17 @@ private:
* defined on this class are intended to be called on the main thread only.
*/
class nsPACMan MOZ_FINAL : public nsIStreamLoaderObserver
, public nsIInterfaceRequestor
, public nsIChannelEventSink
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
nsPACMan();
/**
* This method may be called to shutdown the PAC manager. Any async queries
* that have not yet completed will either finish normally or be canceled by
* the time this method returns.
*/
--- a/netwerk/base/src/nsPreloadedStream.cpp
+++ b/netwerk/base/src/nsPreloadedStream.cpp
@@ -8,19 +8,19 @@
#include "nsThreadUtils.h"
#include "nsAlgorithm.h"
#include <algorithm>
namespace mozilla {
namespace net {
-NS_IMPL_THREADSAFE_ISUPPORTS2(nsPreloadedStream,
- nsIInputStream,
- nsIAsyncInputStream)
+NS_IMPL_ISUPPORTS2(nsPreloadedStream,
+ nsIInputStream,
+ nsIAsyncInputStream)
nsPreloadedStream::nsPreloadedStream(nsIAsyncInputStream *aStream,
const char *data, uint32_t datalen)
: mStream(aStream),
mOffset(0),
mLen(datalen)
{
mBuf = (char *) moz_xmalloc(datalen);
--- a/netwerk/base/src/nsPreloadedStream.h
+++ b/netwerk/base/src/nsPreloadedStream.h
@@ -25,17 +25,17 @@
#include "mozilla/Attributes.h"
namespace mozilla {
namespace net {
class nsPreloadedStream MOZ_FINAL : public nsIAsyncInputStream
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIINPUTSTREAM
NS_DECL_NSIASYNCINPUTSTREAM
nsPreloadedStream(nsIAsyncInputStream *aStream,
const char *data, uint32_t datalen);
private:
~nsPreloadedStream();
--- a/netwerk/base/src/nsProtocolProxyService.cpp
+++ b/netwerk/base/src/nsProtocolProxyService.cpp
@@ -71,17 +71,17 @@ struct nsProtocolInfo {
// The nsPACManCallback portion of this implementation should be run
// on the main thread - so call nsPACMan::AsyncGetProxyForURI() with
// a true mainThreadResponse parameter.
class nsAsyncResolveRequest MOZ_FINAL : public nsIRunnable
, public nsPACManCallback
, public nsICancelable
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
nsAsyncResolveRequest(nsProtocolProxyService *pps, nsIURI *uri,
uint32_t aResolveFlags,
nsIProtocolProxyCallback *callback)
: mStatus(NS_OK)
, mDispatched(false)
, mResolveFlags(aResolveFlags)
, mPPS(pps)
@@ -268,17 +268,17 @@ private:
nsProtocolProxyService *mPPS;
nsCOMPtr<nsIProtocolProxyService> mXPComPPS;
nsCOMPtr<nsIURI> mURI;
nsCOMPtr<nsIProtocolProxyCallback> mCallback;
nsCOMPtr<nsIProxyInfo> mProxyInfo;
};
-NS_IMPL_THREADSAFE_ISUPPORTS2(nsAsyncResolveRequest, nsICancelable, nsIRunnable)
+NS_IMPL_ISUPPORTS2(nsAsyncResolveRequest, nsICancelable, nsIRunnable)
//----------------------------------------------------------------------------
#define IS_ASCII_SPACE(_c) ((_c) == ' ' || (_c) == '\t')
//
// apply mask to address (zeros out excluded bits).
//
@@ -967,17 +967,17 @@ nsProtocolProxyService::ReloadPAC()
// When sync interface is removed this can go away too
// The nsPACManCallback portion of this implementation should be run
// off the main thread, because it uses a condvar for signaling and
// the main thread is blocking on that condvar -
// so call nsPACMan::AsyncGetProxyForURI() with
// a false mainThreadResponse parameter.
class nsAsyncBridgeRequest MOZ_FINAL : public nsPACManCallback
{
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
nsAsyncBridgeRequest()
: mMutex("nsDeprecatedCallback")
, mCondVar(mMutex, "nsDeprecatedCallback")
, mCompleted(false)
{
}
@@ -1007,17 +1007,17 @@ private:
Mutex mMutex;
CondVar mCondVar;
nsresult mStatus;
nsCString mPACString;
nsCString mPACURL;
bool mCompleted;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsAsyncBridgeRequest, nsPACManCallback)
+NS_IMPL_ISUPPORTS1(nsAsyncBridgeRequest, nsPACManCallback)
// nsIProtocolProxyService2
NS_IMETHODIMP
nsProtocolProxyService::DeprecatedBlockingResolve(nsIURI *aURI,
uint32_t aFlags,
nsIProxyInfo **retval)
{
NS_ENSURE_ARG_POINTER(aURI);
--- a/netwerk/base/src/nsProxyInfo.cpp
+++ b/netwerk/base/src/nsProxyInfo.cpp
@@ -3,17 +3,17 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsProxyInfo.h"
#include "nsCOMPtr.h"
// Yes, we support QI to nsProxyInfo
-NS_IMPL_THREADSAFE_ISUPPORTS2(nsProxyInfo, nsProxyInfo, nsIProxyInfo)
+NS_IMPL_ISUPPORTS2(nsProxyInfo, nsProxyInfo, nsIProxyInfo)
using namespace mozilla;
NS_IMETHODIMP
nsProxyInfo::GetHost(nsACString &result)
{
result = mHost;
return NS_OK;
--- a/netwerk/base/src/nsProxyInfo.h
+++ b/netwerk/base/src/nsProxyInfo.h
@@ -22,17 +22,17 @@
// This class is exposed to other classes inside Necko for fast access
// to the nsIProxyInfo attributes.
class nsProxyInfo MOZ_FINAL : public nsIProxyInfo
{
public:
NS_DECLARE_STATIC_IID_ACCESSOR(NS_PROXYINFO_IID)
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIPROXYINFO
// Cheap accessors for use within Necko
const nsCString &Host() { return mHost; }
int32_t Port() { return mPort; }
const char *Type() { return mType; }
uint32_t Flags() { return mFlags; }
--- a/netwerk/base/src/nsRequestObserverProxy.cpp
+++ b/netwerk/base/src/nsRequestObserverProxy.cpp
@@ -110,19 +110,19 @@ public:
return NS_OK;
}
};
//-----------------------------------------------------------------------------
// nsRequestObserverProxy::nsISupports implementation...
//-----------------------------------------------------------------------------
-NS_IMPL_THREADSAFE_ISUPPORTS2(nsRequestObserverProxy,
- nsIRequestObserver,
- nsIRequestObserverProxy)
+NS_IMPL_ISUPPORTS2(nsRequestObserverProxy,
+ nsIRequestObserver,
+ nsIRequestObserverProxy)
//-----------------------------------------------------------------------------
// nsRequestObserverProxy::nsIRequestObserver implementation...
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsRequestObserverProxy::OnStartRequest(nsIRequest *request,
nsISupports *context)
--- a/netwerk/base/src/nsRequestObserverProxy.h
+++ b/netwerk/base/src/nsRequestObserverProxy.h
@@ -13,17 +13,17 @@
#include "nsCOMPtr.h"
#include "nsProxyRelease.h"
class nsARequestObserverEvent;
class nsRequestObserverProxy MOZ_FINAL : public nsIRequestObserverProxy
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIREQUESTOBSERVER
NS_DECL_NSIREQUESTOBSERVERPROXY
nsRequestObserverProxy() {}
nsIRequestObserver *Observer() { return mObserver; }
nsresult FireEvent(nsARequestObserverEvent *);
--- a/netwerk/base/src/nsServerSocket.cpp
+++ b/netwerk/base/src/nsServerSocket.cpp
@@ -239,17 +239,17 @@ nsServerSocket::KeepWhenOffline(bool *aK
{
*aKeepWhenOffline = mKeepWhenOffline;
}
//-----------------------------------------------------------------------------
// nsServerSocket::nsISupports
//-----------------------------------------------------------------------------
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsServerSocket, nsIServerSocket)
+NS_IMPL_ISUPPORTS1(nsServerSocket, nsIServerSocket)
//-----------------------------------------------------------------------------
// nsServerSocket::nsIServerSocket
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsServerSocket::Init(int32_t aPort, bool aLoopbackOnly, int32_t aBackLog)
@@ -359,17 +359,17 @@ namespace {
class ServerSocketListenerProxy MOZ_FINAL : public nsIServerSocketListener
{
public:
ServerSocketListenerProxy(nsIServerSocketListener* aListener)
: mListener(new nsMainThreadPtrHolder<nsIServerSocketListener>(aListener))
, mTargetThread(do_GetCurrentThread())
{ }
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSISERVERSOCKETLISTENER
class OnSocketAcceptedRunnable : public nsRunnable
{
public:
OnSocketAcceptedRunnable(const nsMainThreadPtrHandle<nsIServerSocketListener>& aListener,
nsIServerSocket* aServ,
nsISocketTransport* aTransport)
@@ -405,18 +405,18 @@ public:
nsresult mStatus;
};
private:
nsMainThreadPtrHandle<nsIServerSocketListener> mListener;
nsCOMPtr<nsIEventTarget> mTargetThread;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(ServerSocketListenerProxy,
- nsIServerSocketListener)
+NS_IMPL_ISUPPORTS1(ServerSocketListenerProxy,
+ nsIServerSocketListener)
NS_IMETHODIMP
ServerSocketListenerProxy::OnSocketAccepted(nsIServerSocket* aServ,
nsISocketTransport* aTransport)
{
nsRefPtr<OnSocketAcceptedRunnable> r =
new OnSocketAcceptedRunnable(mListener, aServ, aTransport);
return mTargetThread->Dispatch(r, NS_DISPATCH_NORMAL);
--- a/netwerk/base/src/nsServerSocket.h
+++ b/netwerk/base/src/nsServerSocket.h
@@ -11,17 +11,17 @@
#include "mozilla/Mutex.h"
//-----------------------------------------------------------------------------
class nsServerSocket : public nsASocketHandler
, public nsIServerSocket
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSISERVERSOCKET
// nsASocketHandler methods:
virtual void OnSocketReady(PRFileDesc *fd, int16_t outFlags);
virtual void OnSocketDetached(PRFileDesc *fd);
virtual void IsLocal(bool *aIsLocal);
virtual void KeepWhenOffline(bool *aKeepWhenOffline);
--- a/netwerk/base/src/nsSocketTransport2.cpp
+++ b/netwerk/base/src/nsSocketTransport2.cpp
@@ -230,24 +230,24 @@ nsSocketInputStream::OnSocketReady(nsres
NS_IMPL_QUERY_INTERFACE2(nsSocketInputStream,
nsIInputStream,
nsIAsyncInputStream)
NS_IMETHODIMP_(nsrefcnt)
nsSocketInputStream::AddRef()
{
- NS_AtomicIncrementRefcnt(mReaderRefCnt);
+ ++mReaderRefCnt;
return mTransport->AddRef();
}
NS_IMETHODIMP_(nsrefcnt)
nsSocketInputStream::Release()
{
- if (NS_AtomicDecrementRefcnt(mReaderRefCnt) == 0)
+ if (--mReaderRefCnt == 0)
Close();
return mTransport->Release();
}
NS_IMETHODIMP
nsSocketInputStream::Close()
{
return CloseWithStatus(NS_BASE_STREAM_CLOSED);
@@ -493,24 +493,24 @@ nsSocketOutputStream::OnSocketReady(nsre
NS_IMPL_QUERY_INTERFACE2(nsSocketOutputStream,
nsIOutputStream,
nsIAsyncOutputStream)
NS_IMETHODIMP_(nsrefcnt)
nsSocketOutputStream::AddRef()
{
- NS_AtomicIncrementRefcnt(mWriterRefCnt);
+ ++mWriterRefCnt;
return mTransport->AddRef();
}
NS_IMETHODIMP_(nsrefcnt)
nsSocketOutputStream::Release()
{
- if (NS_AtomicDecrementRefcnt(mWriterRefCnt) == 0)
+ if (--mWriterRefCnt == 0)
Close();
return mTransport->Release();
}
NS_IMETHODIMP
nsSocketOutputStream::Close()
{
return CloseWithStatus(NS_BASE_STREAM_CLOSED);
@@ -1727,21 +1727,21 @@ nsSocketTransport::IsLocal(bool *aIsLoca
MutexAutoLock lock(mLock);
*aIsLocal = IsLoopBackAddress(&mNetAddr);
}
}
//-----------------------------------------------------------------------------
// xpcom api
-NS_IMPL_THREADSAFE_ISUPPORTS4(nsSocketTransport,
- nsISocketTransport,
- nsITransport,
- nsIDNSListener,
- nsIClassInfo)
+NS_IMPL_ISUPPORTS4(nsSocketTransport,
+ nsISocketTransport,
+ nsITransport,
+ nsIDNSListener,
+ nsIClassInfo)
NS_IMPL_CI_INTERFACE_GETTER3(nsSocketTransport,
nsISocketTransport,
nsITransport,
nsIDNSListener)
NS_IMETHODIMP
nsSocketTransport::OpenInputStream(uint32_t flags,
uint32_t segsize,
--- a/netwerk/base/src/nsSocketTransport2.h
+++ b/netwerk/base/src/nsSocketTransport2.h
@@ -52,17 +52,17 @@ public:
nsresult Condition() { return mCondition; }
uint64_t ByteCount() { return mByteCount; }
// called by the socket transport on the socket thread...
void OnSocketReady(nsresult condition);
private:
nsSocketTransport *mTransport;
- nsrefcnt mReaderRefCnt;
+ mozilla::ThreadSafeAutoRefCnt mReaderRefCnt;
// access to these is protected by mTransport->mLock
nsresult mCondition;
nsCOMPtr<nsIInputStreamCallback> mCallback;
uint32_t mCallbackFlags;
uint64_t mByteCount;
};
@@ -86,17 +86,17 @@ public:
void OnSocketReady(nsresult condition);
private:
static NS_METHOD WriteFromSegments(nsIInputStream *, void *,
const char *, uint32_t offset,
uint32_t count, uint32_t *countRead);
nsSocketTransport *mTransport;
- nsrefcnt mWriterRefCnt;
+ mozilla::ThreadSafeAutoRefCnt mWriterRefCnt;
// access to these is protected by mTransport->mLock
nsresult mCondition;
nsCOMPtr<nsIOutputStreamCallback> mCallback;
uint32_t mCallbackFlags;
uint64_t mByteCount;
};
@@ -105,17 +105,17 @@ private:
class nsSocketTransport : public nsASocketHandler
, public nsISocketTransport
, public nsIDNSListener
, public nsIClassInfo
{
typedef mozilla::Mutex Mutex;
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSITRANSPORT
NS_DECL_NSISOCKETTRANSPORT
NS_DECL_NSIDNSLISTENER
NS_DECL_NSICLASSINFO
nsSocketTransport();
// this method instructs the socket transport to open a socket of the
--- a/netwerk/base/src/nsSocketTransportService2.cpp
+++ b/netwerk/base/src/nsSocketTransportService2.cpp
@@ -396,23 +396,23 @@ nsSocketTransportService::Poll(bool wait
*interval = PR_IntervalToSeconds(passedInterval);
return rv;
}
//-----------------------------------------------------------------------------
// xpcom api
-NS_IMPL_THREADSAFE_ISUPPORTS6(nsSocketTransportService,
- nsISocketTransportService,
- nsIEventTarget,
- nsIThreadObserver,
- nsIRunnable,
- nsPISocketTransportService,
- nsIObserver)
+NS_IMPL_ISUPPORTS6(nsSocketTransportService,
+ nsISocketTransportService,
+ nsIEventTarget,
+ nsIThreadObserver,
+ nsIRunnable,
+ nsPISocketTransportService,
+ nsIObserver)
// called from main thread only
NS_IMETHODIMP
nsSocketTransportService::Init()
{
if (!NS_IsMainThread()) {
NS_ERROR("wrong thread");
return NS_ERROR_UNEXPECTED;
--- a/netwerk/base/src/nsSocketTransportService2.h
+++ b/netwerk/base/src/nsSocketTransportService2.h
@@ -42,17 +42,17 @@ class nsSocketTransportService : public
, public nsIEventTarget
, public nsIThreadObserver
, public nsIRunnable
, public nsIObserver
{
typedef mozilla::Mutex Mutex;
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSPISOCKETTRANSPORTSERVICE
NS_DECL_NSISOCKETTRANSPORTSERVICE
NS_DECL_NSIEVENTTARGET
NS_DECL_NSITHREADOBSERVER
NS_DECL_NSIRUNNABLE
NS_DECL_NSIOBSERVER
nsSocketTransportService();
--- a/netwerk/base/src/nsStreamListenerTee.cpp
+++ b/netwerk/base/src/nsStreamListenerTee.cpp
@@ -1,20 +1,20 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsStreamListenerTee.h"
#include "nsProxyRelease.h"
-NS_IMPL_THREADSAFE_ISUPPORTS4(nsStreamListenerTee,
- nsIStreamListener,
- nsIRequestObserver,
- nsIStreamListenerTee,
- nsIThreadRetargetableStreamListener)
+NS_IMPL_ISUPPORTS4(nsStreamListenerTee,
+ nsIStreamListener,
+ nsIRequestObserver,
+ nsIStreamListenerTee,
+ nsIThreadRetargetableStreamListener)
NS_IMETHODIMP
nsStreamListenerTee::OnStartRequest(nsIRequest *request,
nsISupports *context)
{
NS_ENSURE_TRUE(mListener, NS_ERROR_NOT_INITIALIZED);
nsresult rv1 = mListener->OnStartRequest(request, context);
nsresult rv2 = NS_OK;
--- a/netwerk/base/src/nsStreamListenerTee.h
+++ b/netwerk/base/src/nsStreamListenerTee.h
@@ -11,17 +11,17 @@
#include "nsIOutputStream.h"
#include "nsCOMPtr.h"
#include "nsIEventTarget.h"
class nsStreamListenerTee : public nsIStreamListenerTee
, public nsIThreadRetargetableStreamListener
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIREQUESTOBSERVER
NS_DECL_NSISTREAMLISTENER
NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER
NS_DECL_NSISTREAMLISTENERTEE
nsStreamListenerTee() { }
virtual ~nsStreamListenerTee() { }
--- a/netwerk/base/src/nsStreamTransportService.cpp
+++ b/netwerk/base/src/nsStreamTransportService.cpp
@@ -27,17 +27,17 @@
// allows the transport to support seeking, range-limiting, progress reporting,
// and close-when-done semantics while utilizing NS_AsyncCopy.
//-----------------------------------------------------------------------------
class nsInputStreamTransport : public nsITransport
, public nsIInputStream
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSITRANSPORT
NS_DECL_NSIINPUTSTREAM
nsInputStreamTransport(nsIInputStream *source,
uint64_t offset,
uint64_t limit,
bool closeWhenDone)
: mSource(source)
@@ -65,19 +65,19 @@ private:
bool mCloseWhenDone;
bool mFirstTime;
// this variable serves as a lock to prevent the state of the transport
// from being modified once the copy is in progress.
bool mInProgress;
};
-NS_IMPL_THREADSAFE_ISUPPORTS2(nsInputStreamTransport,
- nsITransport,
- nsIInputStream)
+NS_IMPL_ISUPPORTS2(nsInputStreamTransport,
+ nsITransport,
+ nsIInputStream)
/** nsITransport **/
NS_IMETHODIMP
nsInputStreamTransport::OpenInputStream(uint32_t flags,
uint32_t segsize,
uint32_t segcount,
nsIInputStream **result)
@@ -227,17 +227,17 @@ nsInputStreamTransport::IsNonBlocking(bo
// allows the transport to support seeking, range-limiting, progress reporting,
// and close-when-done semantics while utilizing NS_AsyncCopy.
//-----------------------------------------------------------------------------
class nsOutputStreamTransport : public nsITransport
, public nsIOutputStream
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSITRANSPORT
NS_DECL_NSIOUTPUTSTREAM
nsOutputStreamTransport(nsIOutputStream *sink,
uint64_t offset,
uint64_t limit,
bool closeWhenDone)
: mSink(sink)
@@ -265,19 +265,19 @@ private:
bool mCloseWhenDone;
bool mFirstTime;
// this variable serves as a lock to prevent the state of the transport
// from being modified once the copy is in progress.
bool mInProgress;
};
-NS_IMPL_THREADSAFE_ISUPPORTS2(nsOutputStreamTransport,
- nsITransport,
- nsIOutputStream)
+NS_IMPL_ISUPPORTS2(nsOutputStreamTransport,
+ nsITransport,
+ nsIOutputStream)
/** nsITransport **/
NS_IMETHODIMP
nsOutputStreamTransport::OpenInputStream(uint32_t flags,
uint32_t segsize,
uint32_t segcount,
nsIInputStream **result)
@@ -449,20 +449,20 @@ nsStreamTransportService::Init()
nsCOMPtr<nsIObserverService> obsSvc =
mozilla::services::GetObserverService();
if (obsSvc)
obsSvc->AddObserver(this, "xpcom-shutdown-threads", false);
return NS_OK;
}
-NS_IMPL_THREADSAFE_ISUPPORTS3(nsStreamTransportService,
- nsIStreamTransportService,
- nsIEventTarget,
- nsIObserver)
+NS_IMPL_ISUPPORTS3(nsStreamTransportService,
+ nsIStreamTransportService,
+ nsIEventTarget,
+ nsIObserver)
NS_IMETHODIMP
nsStreamTransportService::Dispatch(nsIRunnable *task, uint32_t flags)
{
NS_ENSURE_TRUE(mPool, NS_ERROR_NOT_INITIALIZED);
return mPool->Dispatch(task, flags);
}
--- a/netwerk/base/src/nsStreamTransportService.h
+++ b/netwerk/base/src/nsStreamTransportService.h
@@ -9,17 +9,17 @@
#include "nsCOMPtr.h"
#include "mozilla/Attributes.h"
class nsStreamTransportService MOZ_FINAL : public nsIStreamTransportService
, public nsIEventTarget
, public nsIObserver
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSISTREAMTRANSPORTSERVICE
NS_DECL_NSIEVENTTARGET
NS_DECL_NSIOBSERVER
nsresult Init();
nsStreamTransportService() {}
--- a/netwerk/base/src/nsTemporaryFileInputStream.cpp
+++ b/netwerk/base/src/nsTemporaryFileInputStream.cpp
@@ -1,17 +1,17 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsTemporaryFileInputStream.h"
#include "nsStreamUtils.h"
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsTemporaryFileInputStream, nsIInputStream)
+NS_IMPL_ISUPPORTS1(nsTemporaryFileInputStream, nsIInputStream)
nsTemporaryFileInputStream::nsTemporaryFileInputStream(FileDescOwner* aFileDescOwner, uint64_t aStartPos, uint64_t aEndPos)
: mFileDescOwner(aFileDescOwner),
mStartPos(aStartPos),
mEndPos(aEndPos),
mClosed(false)
{
NS_ASSERTION(aStartPos <= aEndPos, "StartPos should less equal than EndPos!");
--- a/netwerk/base/src/nsTemporaryFileInputStream.h
+++ b/netwerk/base/src/nsTemporaryFileInputStream.h
@@ -34,17 +34,17 @@ public:
PRFileDesc* mFD;
mozilla::Mutex mMutex;
};
nsTemporaryFileInputStream(FileDescOwner* aFileDescOwner, uint64_t aStartPos, uint64_t aEndPos);
virtual ~nsTemporaryFileInputStream() { }
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIINPUTSTREAM
private:
nsRefPtr<FileDescOwner> mFileDescOwner;
uint64_t mStartPos;
uint64_t mEndPos;
bool mClosed;
};
--- a/netwerk/base/src/nsTransportUtils.cpp
+++ b/netwerk/base/src/nsTransportUtils.cpp
@@ -14,17 +14,17 @@ using namespace mozilla;
//-----------------------------------------------------------------------------
class nsTransportStatusEvent;
class nsTransportEventSinkProxy : public nsITransportEventSink
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSITRANSPORTEVENTSINK
nsTransportEventSinkProxy(nsITransportEventSink *sink,
nsIEventTarget *target,
bool coalesceAll)
: mSink(sink)
, mTarget(target)
, mLock("nsTransportEventSinkProxy.mLock")
@@ -84,17 +84,17 @@ public:
// parameters to OnTransportStatus
nsCOMPtr<nsITransport> mTransport;
nsresult mStatus;
uint64_t mProgress;
uint64_t mProgressMax;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsTransportEventSinkProxy, nsITransportEventSink)
+NS_IMPL_ISUPPORTS1(nsTransportEventSinkProxy, nsITransportEventSink)
NS_IMETHODIMP
nsTransportEventSinkProxy::OnTransportStatus(nsITransport *transport,
nsresult status,
uint64_t progress,
uint64_t progressMax)
{
nsresult rv = NS_OK;
--- a/netwerk/base/src/nsUDPServerSocket.cpp
+++ b/netwerk/base/src/nsUDPServerSocket.cpp
@@ -38,17 +38,17 @@ PostEvent(nsUDPServerSocket *s, nsUDPSer
return NS_ERROR_FAILURE;
return gSocketTransportService->Dispatch(ev, NS_DISPATCH_NORMAL);
}
//-----------------------------------------------------------------------------
// nsUPDOutputStream impl
//-----------------------------------------------------------------------------
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsUDPOutputStream, nsIOutputStream)
+NS_IMPL_ISUPPORTS1(nsUDPOutputStream, nsIOutputStream)
nsUDPOutputStream::nsUDPOutputStream(nsUDPServerSocket* aServer,
PRFileDesc* aFD,
PRNetAddr& aPrClientAddr)
: mServer(aServer)
, mFD(aFD)
, mPrClientAddr(aPrClientAddr)
, mIsClosed(false)
@@ -112,17 +112,17 @@ NS_IMETHODIMP nsUDPOutputStream::IsNonBl
{
*_retval = true;
return NS_OK;
}
//-----------------------------------------------------------------------------
// nsUPDMessage impl
//-----------------------------------------------------------------------------
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsUDPMessage, nsIUDPMessage)
+NS_IMPL_ISUPPORTS1(nsUDPMessage, nsIUDPMessage)
nsUDPMessage::nsUDPMessage(PRNetAddr* aAddr,
nsIOutputStream* aOutputStream,
const nsACString& aData)
: mOutputStream(aOutputStream)
, mData(aData)
{
memcpy(&mAddr, aAddr, sizeof(NetAddr));
@@ -378,17 +378,17 @@ nsUDPServerSocket::IsLocal(bool *aIsLoca
// If bound to loopback, this server socket only accepts local connections.
*aIsLocal = mAddr.raw.family == nsINetAddr::FAMILY_LOCAL;
}
//-----------------------------------------------------------------------------
// nsServerSocket::nsISupports
//-----------------------------------------------------------------------------
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsUDPServerSocket, nsIUDPServerSocket)
+NS_IMPL_ISUPPORTS1(nsUDPServerSocket, nsIUDPServerSocket)
//-----------------------------------------------------------------------------
// nsServerSocket::nsIServerSocket
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsUDPServerSocket::Init(int32_t aPort, bool aLoopbackOnly)
@@ -512,17 +512,17 @@ namespace {
class ServerSocketListenerProxy MOZ_FINAL : public nsIUDPServerSocketListener
{
public:
ServerSocketListenerProxy(nsIUDPServerSocketListener* aListener)
: mListener(new nsMainThreadPtrHolder<nsIUDPServerSocketListener>(aListener))
, mTargetThread(do_GetCurrentThread())
{ }
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIUDPSERVERSOCKETLISTENER
class OnPacketReceivedRunnable : public nsRunnable
{
public:
OnPacketReceivedRunnable(const nsMainThreadPtrHandle<nsIUDPServerSocketListener>& aListener,
nsIUDPServerSocket* aServ,
nsIUDPMessage* aMessage)
@@ -558,18 +558,18 @@ public:
nsresult mStatus;
};
private:
nsMainThreadPtrHandle<nsIUDPServerSocketListener> mListener;
nsCOMPtr<nsIEventTarget> mTargetThread;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(ServerSocketListenerProxy,
- nsIUDPServerSocketListener)
+NS_IMPL_ISUPPORTS1(ServerSocketListenerProxy,
+ nsIUDPServerSocketListener)
NS_IMETHODIMP
ServerSocketListenerProxy::OnPacketReceived(nsIUDPServerSocket* aServ,
nsIUDPMessage* aMessage)
{
nsRefPtr<OnPacketReceivedRunnable> r =
new OnPacketReceivedRunnable(mListener, aServ, aMessage);
return mTargetThread->Dispatch(r, NS_DISPATCH_NORMAL);
--- a/netwerk/base/src/nsUDPServerSocket.h
+++ b/netwerk/base/src/nsUDPServerSocket.h
@@ -12,17 +12,17 @@
#include "nsIOutputStream.h"
//-----------------------------------------------------------------------------
class nsUDPServerSocket : public nsASocketHandler
, public nsIUDPServerSocket
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIUDPSERVERSOCKET
// nsASocketHandler methods:
virtual void OnSocketReady(PRFileDesc* fd, int16_t outFlags);
virtual void OnSocketDetached(PRFileDesc* fd);
virtual void IsLocal(bool* aIsLocal);
uint64_t ByteCountSent() { return mByteWriteCount; }
@@ -56,17 +56,17 @@ private:
uint64_t mByteWriteCount;
};
//-----------------------------------------------------------------------------
class nsUDPMessage : public nsIUDPMessage
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIUDPMESSAGE
nsUDPMessage(PRNetAddr* aAddr,
nsIOutputStream* aOutputStream,
const nsACString& aData);
private:
virtual ~nsUDPMessage();
@@ -77,17 +77,17 @@ private:
};
//-----------------------------------------------------------------------------
class nsUDPOutputStream : public nsIOutputStream
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIOUTPUTSTREAM
nsUDPOutputStream(nsUDPServerSocket* aServer,
PRFileDesc* aFD,
PRNetAddr& aPrClientAddr);
virtual ~nsUDPOutputStream();
private:
--- a/netwerk/base/src/nsURLParsers.cpp
+++ b/netwerk/base/src/nsURLParsers.cpp
@@ -27,21 +27,18 @@ CountConsecutiveSlashes(const char *str,
while (len-- && *p++ == '/') ++count;
return count;
}
//----------------------------------------------------------------------------
// nsBaseURLParser implementation
//----------------------------------------------------------------------------
-// The URL parser service does not have any internal state; however, it can
-// be called from multiple threads, so we must use a threadsafe AddRef and
-// Release implementation.
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsAuthURLParser, nsIURLParser)
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsNoAuthURLParser, nsIURLParser)
+NS_IMPL_ISUPPORTS1(nsAuthURLParser, nsIURLParser)
+NS_IMPL_ISUPPORTS1(nsNoAuthURLParser, nsIURLParser)
#define SET_RESULT(component, pos, len) \
PR_BEGIN_MACRO \
if (component ## Pos) \
*component ## Pos = uint32_t(pos); \
if (component ## Len) \
*component ## Len = int32_t(len); \
PR_END_MACRO
--- a/netwerk/base/src/nsURLParsers.h
+++ b/netwerk/base/src/nsURLParsers.h
@@ -38,17 +38,17 @@ protected:
//
// XXX except in this case:
// file://foo/bar.txt (the authority "foo" is ignored)
//----------------------------------------------------------------------------
class nsNoAuthURLParser MOZ_FINAL : public nsBaseURLParser
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
#if defined(XP_WIN) || defined(XP_OS2)
NS_IMETHOD ParseFilePath(const char *, int32_t,
uint32_t *, int32_t *,
uint32_t *, int32_t *,
uint32_t *, int32_t *);
#endif
@@ -70,17 +70,17 @@ public:
// http:/www.foo.com/bar.html
// http://www.foo.com/bar.html (treated equivalently)
// http:///www.foo.com/bar.html
//----------------------------------------------------------------------------
class nsAuthURLParser : public nsBaseURLParser
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
virtual ~nsAuthURLParser() {}
NS_IMETHOD ParseAuthority(const char *auth, int32_t authLen,
uint32_t *usernamePos, int32_t *usernameLen,
uint32_t *passwordPos, int32_t *passwordLen,
uint32_t *hostnamePos, int32_t *hostnameLen,
int32_t *port);
--- a/netwerk/cache/nsCacheEntryDescriptor.cpp
+++ b/netwerk/cache/nsCacheEntryDescriptor.cpp
@@ -65,19 +65,19 @@ public:
private:
nsCOMPtr<nsCacheEntryDescriptor> mDescriptor;
nsICacheListener *mListener;
nsCOMPtr<nsIThread> mThread;
};
-NS_IMPL_THREADSAFE_ISUPPORTS2(nsCacheEntryDescriptor,
- nsICacheEntryDescriptor,
- nsICacheEntryInfo)
+NS_IMPL_ISUPPORTS2(nsCacheEntryDescriptor,
+ nsICacheEntryDescriptor,
+ nsICacheEntryInfo)
nsCacheEntryDescriptor::nsCacheEntryDescriptor(nsCacheEntry * entry,
nsCacheAccessMode accessGranted)
: mCacheEntry(entry),
mAccessGranted(accessGranted),
mOutputWrapper(nullptr),
mLock("nsCacheEntryDescriptor.mLock"),
mAsyncDoomPending(false),
@@ -649,17 +649,17 @@ nsCacheEntryDescriptor::VisitMetaData(ns
}
/******************************************************************************
* nsCacheInputStream - a wrapper for nsIInputStream keeps the cache entry
* open while referenced.
******************************************************************************/
-NS_IMPL_THREADSAFE_ADDREF(nsCacheEntryDescriptor::nsInputStreamWrapper)
+NS_IMPL_ADDREF(nsCacheEntryDescriptor::nsInputStreamWrapper)
NS_IMETHODIMP_(nsrefcnt)
nsCacheEntryDescriptor::nsInputStreamWrapper::Release()
{
// Holding a reference to descriptor ensures that cache service won't go
// away. Do not grab cache service lock if there is no descriptor.
nsRefPtr<nsCacheEntryDescriptor> desc;
{
@@ -667,17 +667,17 @@ nsCacheEntryDescriptor::nsInputStreamWra
desc = mDescriptor;
}
if (desc)
nsCacheService::Lock(LOCK_TELEM(NSINPUTSTREAMWRAPPER_RELEASE));
nsrefcnt count;
NS_PRECONDITION(0 != mRefCnt, "dup release");
- count = NS_AtomicDecrementRefcnt(mRefCnt);
+ count = --mRefCnt;
NS_LOG_RELEASE(this, count, "nsCacheEntryDescriptor::nsInputStreamWrapper");
if (0 == count) {
// don't use desc here since mDescriptor might be already nulled out
if (mDescriptor) {
NS_ASSERTION(mDescriptor->mInputWrappers.IndexOf(this) != -1,
"Wrapper not found in array!");
mDescriptor->mInputWrappers.RemoveElement(this);
@@ -841,17 +841,17 @@ nsInputStreamWrapper::IsNonBlocking(bool
return NS_OK;
}
/******************************************************************************
* nsDecompressInputStreamWrapper - an input stream wrapper that decompresses
******************************************************************************/
-NS_IMPL_THREADSAFE_ADDREF(nsCacheEntryDescriptor::nsDecompressInputStreamWrapper)
+NS_IMPL_ADDREF(nsCacheEntryDescriptor::nsDecompressInputStreamWrapper)
NS_IMETHODIMP_(nsrefcnt)
nsCacheEntryDescriptor::nsDecompressInputStreamWrapper::Release()
{
// Holding a reference to descriptor ensures that cache service won't go
// away. Do not grab cache service lock if there is no descriptor.
nsRefPtr<nsCacheEntryDescriptor> desc;
{
@@ -860,17 +860,17 @@ nsCacheEntryDescriptor::nsDecompressInpu
}
if (desc)
nsCacheService::Lock(LOCK_TELEM(
NSDECOMPRESSINPUTSTREAMWRAPPER_RELEASE));
nsrefcnt count;
NS_PRECONDITION(0 != mRefCnt, "dup release");
- count = NS_AtomicDecrementRefcnt(mRefCnt);
+ count = --mRefCnt;
NS_LOG_RELEASE(this, count,
"nsCacheEntryDescriptor::nsDecompressInputStreamWrapper");
if (0 == count) {
// don't use desc here since mDescriptor might be already nulled out
if (mDescriptor) {
NS_ASSERTION(mDescriptor->mInputWrappers.IndexOf(this) != -1,
"Wrapper not found in array!");
@@ -1031,17 +1031,17 @@ nsDecompressInputStreamWrapper::EndZstre
/******************************************************************************
* nsOutputStreamWrapper - a wrapper for nsIOutputstream to track the amount of
* data written to a cache entry.
* - also keeps the cache entry open while referenced.
******************************************************************************/
-NS_IMPL_THREADSAFE_ADDREF(nsCacheEntryDescriptor::nsOutputStreamWrapper)
+NS_IMPL_ADDREF(nsCacheEntryDescriptor::nsOutputStreamWrapper)
NS_IMETHODIMP_(nsrefcnt)
nsCacheEntryDescriptor::nsOutputStreamWrapper::Release()
{
// Holding a reference to descriptor ensures that cache service won't go
// away. Do not grab cache service lock if there is no descriptor.
nsRefPtr<nsCacheEntryDescriptor> desc;
{
@@ -1049,17 +1049,17 @@ nsCacheEntryDescriptor::nsOutputStreamWr
desc = mDescriptor;
}
if (desc)
nsCacheService::Lock(LOCK_TELEM(NSOUTPUTSTREAMWRAPPER_RELEASE));
nsrefcnt count;
NS_PRECONDITION(0 != mRefCnt, "dup release");
- count = NS_AtomicDecrementRefcnt(mRefCnt);
+ count = --mRefCnt;
NS_LOG_RELEASE(this, count,
"nsCacheEntryDescriptor::nsOutputStreamWrapper");
if (0 == count) {
// don't use desc here since mDescriptor might be already nulled out
if (mDescriptor)
mDescriptor->mOutputWrapper = nullptr;
@@ -1261,17 +1261,17 @@ nsOutputStreamWrapper::IsNonBlocking(boo
}
/******************************************************************************
* nsCompressOutputStreamWrapper - an output stream wrapper that compresses
* data before it is written
******************************************************************************/
-NS_IMPL_THREADSAFE_ADDREF(nsCacheEntryDescriptor::nsCompressOutputStreamWrapper)
+NS_IMPL_ADDREF(nsCacheEntryDescriptor::nsCompressOutputStreamWrapper)
NS_IMETHODIMP_(nsrefcnt)
nsCacheEntryDescriptor::nsCompressOutputStreamWrapper::Release()
{
// Holding a reference to descriptor ensures that cache service won't go
// away. Do not grab cache service lock if there is no descriptor.
nsRefPtr<nsCacheEntryDescriptor> desc;
{
@@ -1279,17 +1279,17 @@ nsCacheEntryDescriptor::nsCompressOutput
desc = mDescriptor;
}
if (desc)
nsCacheService::Lock(LOCK_TELEM(NSCOMPRESSOUTPUTSTREAMWRAPPER_RELEASE));
nsrefcnt count;
NS_PRECONDITION(0 != mRefCnt, "dup release");
- count = NS_AtomicDecrementRefcnt(mRefCnt);
+ count = --mRefCnt;
NS_LOG_RELEASE(this, count,
"nsCacheEntryDescriptor::nsCompressOutputStreamWrapper");
if (0 == count) {
// don't use desc here since mDescriptor might be already nulled out
if (mDescriptor)
mDescriptor->mOutputWrapper = nullptr;
--- a/netwerk/cache/nsCacheEntryDescriptor.h
+++ b/netwerk/cache/nsCacheEntryDescriptor.h
@@ -20,17 +20,17 @@
/******************************************************************************
* nsCacheEntryDescriptor
*******************************************************************************/
class nsCacheEntryDescriptor :
public PRCList,
public nsICacheEntryDescriptor
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSICACHEENTRYDESCRIPTOR
NS_DECL_NSICACHEENTRYINFO
friend class nsAsyncDoomEvent;
friend class nsCacheService;
nsCacheEntryDescriptor(nsCacheEntry * entry, nsCacheAccessMode mode);
virtual ~nsCacheEntryDescriptor();
@@ -77,17 +77,17 @@ private:
private:
nsCacheEntryDescriptor * mDescriptor;
nsCOMPtr<nsIInputStream> mInput;
uint32_t mStartOffset;
bool mInitialized;
mozilla::Mutex mLock;
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIINPUTSTREAM
nsInputStreamWrapper(nsCacheEntryDescriptor * desc, uint32_t off)
: mDescriptor(desc)
, mStartOffset(off)
, mInitialized(false)
, mLock("nsInputStreamWrapper.mLock")
{
@@ -110,17 +110,17 @@ private:
class nsDecompressInputStreamWrapper : public nsInputStreamWrapper {
private:
unsigned char* mReadBuffer;
uint32_t mReadBufferLen;
z_stream mZstream;
bool mStreamInitialized;
bool mStreamEnded;
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
nsDecompressInputStreamWrapper(nsCacheEntryDescriptor * desc,
uint32_t off)
: nsInputStreamWrapper(desc, off)
, mReadBuffer(0)
, mReadBufferLen(0)
, mStreamInitialized(false)
, mStreamEnded(false)
@@ -149,17 +149,17 @@ private:
protected:
nsCacheEntryDescriptor * mDescriptor;
nsCOMPtr<nsIOutputStream> mOutput;
uint32_t mStartOffset;
bool mInitialized;
mozilla::Mutex mLock;
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIOUTPUTSTREAM
nsOutputStreamWrapper(nsCacheEntryDescriptor * desc, uint32_t off)
: mDescriptor(desc)
, mStartOffset(off)
, mInitialized(false)
, mLock("nsOutputStreamWrapper.mLock")
{
@@ -189,17 +189,17 @@ private:
private:
unsigned char* mWriteBuffer;
uint32_t mWriteBufferLen;
z_stream mZstream;
bool mStreamInitialized;
bool mStreamEnded;
uint32_t mUncompressedCount;
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
nsCompressOutputStreamWrapper(nsCacheEntryDescriptor * desc,
uint32_t off)
: nsOutputStreamWrapper(desc, off)
, mWriteBuffer(0)
, mWriteBufferLen(0)
, mStreamInitialized(false)
, mStreamEnded(false)
--- a/netwerk/cache/nsCacheService.cpp
+++ b/netwerk/cache/nsCacheService.cpp
@@ -116,17 +116,17 @@ const int32_t MAX_CACHE_SIZE = 350 * 102
const int32_t OLD_MAX_CACHE_SIZE = 1024 * 1024; // 1 GB
#endif
// Default cache size was 50 MB for many years until FF 4:
const int32_t PRE_GECKO_2_0_DEFAULT_CACHE_SIZE = 50 * 1024;
class nsCacheProfilePrefObserver : public nsIObserver
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIOBSERVER
nsCacheProfilePrefObserver()
: mHaveProfile(false)
, mDiskCacheEnabled(false)
, mDiskCacheCapacity(0)
, mDiskCacheMaxEntrySize(-1) // -1 means "no limit"
, mSmartSizeEnabled(false)
@@ -196,34 +196,34 @@ private:
int32_t mMemoryCacheMaxEntrySize; // in kilobytes
int32_t mCacheCompressionLevel;
bool mSanitizeOnShutdown;
bool mClearCacheOnShutdown;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsCacheProfilePrefObserver, nsIObserver)
+NS_IMPL_ISUPPORTS1(nsCacheProfilePrefObserver, nsIObserver)
class nsSetDiskSmartSizeCallback MOZ_FINAL : public nsITimerCallback
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_IMETHOD Notify(nsITimer* aTimer) {
if (nsCacheService::gService) {
nsCacheServiceAutoLock autoLock(LOCK_TELEM(NSSETDISKSMARTSIZECALLBACK_NOTIFY));
nsCacheService::gService->SetDiskSmartSize_Locked();
nsCacheService::gService->mSmartSizeTimer = nullptr;
}
return NS_OK;
}
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsSetDiskSmartSizeCallback, nsITimerCallback)
+NS_IMPL_ISUPPORTS1(nsSetDiskSmartSizeCallback, nsITimerCallback)
// Runnable sent to main thread after the cache IO thread calculates available
// disk space, so that there is no race in setting mDiskCacheCapacity.
class nsSetSmartSizeEvent: public nsRunnable
{
public:
nsSetSmartSizeEvent(int32_t smartSize)
: mSmartSize(smartSize) {}
@@ -1067,17 +1067,17 @@ private:
nsCOMPtr<nsIThread> mThread;
};
/******************************************************************************
* nsCacheService
*****************************************************************************/
nsCacheService * nsCacheService::gService = nullptr;
-NS_IMPL_THREADSAFE_ISUPPORTS2(nsCacheService, nsICacheService, nsICacheServiceInternal)
+NS_IMPL_ISUPPORTS2(nsCacheService, nsICacheService, nsICacheServiceInternal)
nsCacheService::nsCacheService()
: mObserver(nullptr),
mLock("nsCacheService.mLock"),
mCondVar(mLock, "nsCacheService.mCondVar"),
mTimeStampLock("nsCacheService.mTimeStampLock"),
mInitialized(false),
mClearingEntries(false),
--- a/netwerk/cache/nsCacheService.h
+++ b/netwerk/cache/nsCacheService.h
@@ -59,17 +59,17 @@ private:
/******************************************************************************
* nsCacheService
******************************************************************************/
class nsCacheService : public nsICacheServiceInternal
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSICACHESERVICE
NS_DECL_NSICACHESERVICEINTERNAL
nsCacheService();
virtual ~nsCacheService();
// Define a Create method to be used with a factory:
static nsresult
--- a/netwerk/cache/nsDiskCacheBinding.cpp
+++ b/netwerk/cache/nsDiskCacheBinding.cpp
@@ -65,17 +65,17 @@ GetCacheEntryBinding(nsCacheEntry * entr
return (nsDiskCacheBinding *) entry->Data();
}
/******************************************************************************
* nsDiskCacheBinding
*****************************************************************************/
-NS_IMPL_THREADSAFE_ISUPPORTS0(nsDiskCacheBinding)
+NS_IMPL_ISUPPORTS0(nsDiskCacheBinding)
nsDiskCacheBinding::nsDiskCacheBinding(nsCacheEntry* entry, nsDiskCacheRecord * record)
: mCacheEntry(entry)
, mStreamIO(nullptr)
, mDeactivateEvent(nullptr)
{
NS_ASSERTION(record->ValidRecord(), "bad record");
PR_INIT_CLIST(this);
--- a/netwerk/cache/nsDiskCacheBinding.h
+++ b/netwerk/cache/nsDiskCacheBinding.h
@@ -27,17 +27,17 @@
* linked by the PRCList.
*
*****************************************************************************/
class nsDiskCacheDeviceDeactivateEntryEvent;
class nsDiskCacheBinding : public nsISupports, public PRCList {
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
nsDiskCacheBinding(nsCacheEntry* entry, nsDiskCacheRecord * record);
virtual ~nsDiskCacheBinding();
nsresult EnsureStreamIO();
bool IsActive() { return mCacheEntry != nullptr;}
// XXX make friends
--- a/netwerk/cache/nsDiskCacheDeviceSQL.cpp
+++ b/netwerk/cache/nsDiskCacheDeviceSQL.cpp
@@ -145,17 +145,17 @@ DCacheHash(const char * key)
// initval 0x7416f295 was chosen randomly
return (uint64_t(nsDiskCache::Hash(key, 0)) << 32) | nsDiskCache::Hash(key, 0x7416f295);
}
/******************************************************************************
* nsOfflineCacheEvictionFunction
*/
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsOfflineCacheEvictionFunction, mozIStorageFunction)
+NS_IMPL_ISUPPORTS1(nsOfflineCacheEvictionFunction, mozIStorageFunction)
// helper function for directly exposing the same data file binding
// path algorithm used in nsOfflineCacheBinding::Create
static nsresult
GetCacheDataFile(nsIFile *cacheDir, const char *key,
int generation, nsCOMPtr<nsIFile> &file)
{
cacheDir->Clone(getter_AddRefs(file));
@@ -342,33 +342,33 @@ nsOfflineCacheDeviceInfo::GetMaximumSize
/******************************************************************************
* nsOfflineCacheBinding
*/
class nsOfflineCacheBinding MOZ_FINAL : public nsISupports
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
static nsOfflineCacheBinding *
Create(nsIFile *cacheDir, const nsCString *key, int generation);
enum { FLAG_NEW_ENTRY = 1 };
nsCOMPtr<nsIFile> mDataFile;
int mGeneration;
int mFlags;
bool IsNewEntry() { return mFlags & FLAG_NEW_ENTRY; }
void MarkNewEntry() { mFlags |= FLAG_NEW_ENTRY; }
void ClearNewEntry() { mFlags &= ~FLAG_NEW_ENTRY; }
};
-NS_IMPL_THREADSAFE_ISUPPORTS0(nsOfflineCacheBinding)
+NS_IMPL_ISUPPORTS0(nsOfflineCacheBinding)
nsOfflineCacheBinding *
nsOfflineCacheBinding::Create(nsIFile *cacheDir,
const nsCString *fullKey,
int generation)
{
nsCOMPtr<nsIFile> file;
cacheDir->Clone(getter_AddRefs(file));
@@ -870,17 +870,17 @@ private:
};
/******************************************************************************
* nsOfflineCacheDevice
*/
-NS_IMPL_THREADSAFE_ISUPPORTS0(nsOfflineCacheDevice)
+NS_IMPL_ISUPPORTS0(nsOfflineCacheDevice)
nsOfflineCacheDevice::nsOfflineCacheDevice()
: mDB(nullptr)
, mCacheCapacity(0)
, mDeltaCounter(0)
, mAutoShutdown(false)
{
}
--- a/netwerk/cache/nsDiskCacheDeviceSQL.h
+++ b/netwerk/cache/nsDiskCacheDeviceSQL.h
@@ -36,17 +36,17 @@ public:
private:
uint32_t mItemType;
nsCString mNamespaceSpec;
nsCString mData;
};
class nsOfflineCacheEvictionFunction MOZ_FINAL : public mozIStorageFunction {
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_MOZISTORAGEFUNCTION
nsOfflineCacheEvictionFunction(nsOfflineCacheDevice *device)
: mDevice(device)
{}
void Reset() { mItems.Clear(); }
void Apply();
@@ -58,17 +58,17 @@ private:
};
class nsOfflineCacheDevice : public nsCacheDevice
, public nsISupports
{
public:
nsOfflineCacheDevice();
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
/**
* nsCacheDevice methods
*/
virtual nsresult Init();
nsresult InitWithSqlite(mozIStorageService * ss);
virtual nsresult Shutdown();
--- a/netwerk/cache/nsDiskCacheStreams.cpp
+++ b/netwerk/cache/nsDiskCacheStreams.cpp
@@ -39,30 +39,30 @@ public:
nsDiskCacheInputStream( nsDiskCacheStreamIO * parent,
PRFileDesc * fileDesc,
const char * buffer,
uint32_t endOfStream);
virtual ~nsDiskCacheInputStream();
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIINPUTSTREAM
private:
nsDiskCacheStreamIO * mStreamIO; // backpointer to parent
PRFileDesc * mFD;
const char * mBuffer;
uint32_t mStreamEnd;
uint32_t mPos; // stream position
bool mClosed;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsDiskCacheInputStream, nsIInputStream)
+NS_IMPL_ISUPPORTS1(nsDiskCacheInputStream, nsIInputStream)
nsDiskCacheInputStream::nsDiskCacheInputStream( nsDiskCacheStreamIO * parent,
PRFileDesc * fileDesc,
const char * buffer,
uint32_t endOfStream)
: mStreamIO(parent)
, mFD(fileDesc)
@@ -185,17 +185,17 @@ nsDiskCacheInputStream::IsNonBlocking(bo
}
/******************************************************************************
* nsDiskCacheStreamIO
*****************************************************************************/
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsDiskCacheStreamIO, nsIOutputStream)
+NS_IMPL_ISUPPORTS1(nsDiskCacheStreamIO, nsIOutputStream)
nsDiskCacheStreamIO::nsDiskCacheStreamIO(nsDiskCacheBinding * binding)
: mBinding(binding)
, mInStreamCount(0)
, mFD(nullptr)
, mStreamEnd(0)
, mBufSize(0)
, mBuffer(nullptr)
--- a/netwerk/cache/nsDiskCacheStreams.h
+++ b/netwerk/cache/nsDiskCacheStreams.h
@@ -21,17 +21,17 @@
class nsDiskCacheInputStream;
class nsDiskCacheDevice;
class nsDiskCacheStreamIO : public nsIOutputStream {
public:
nsDiskCacheStreamIO(nsDiskCacheBinding * binding);
virtual ~nsDiskCacheStreamIO();
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIOUTPUTSTREAM
nsresult GetInputStream(uint32_t offset, nsIInputStream ** inputStream);
nsresult GetOutputStream(uint32_t offset, nsIOutputStream ** outputStream);
nsresult ClearBinding();
void IncrementInputStreamCount() { mInStreamCount++; }
--- a/netwerk/dns/nsDNSService2.cpp
+++ b/netwerk/dns/nsDNSService2.cpp
@@ -44,17 +44,17 @@ static const char kPrefDisableIPv6[]
static const char kPrefDisablePrefetch[] = "network.dns.disablePrefetch";
static const char kPrefDnsLocalDomains[] = "network.dns.localDomains";
//-----------------------------------------------------------------------------
class nsDNSRecord : public nsIDNSRecord
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIDNSRECORD
nsDNSRecord(nsHostRecord *hostRecord)
: mHostRecord(hostRecord)
, mIter(nullptr)
, mIterGenCnt(-1)
, mDone(false) {}
@@ -64,17 +64,17 @@ private:
nsRefPtr<nsHostRecord> mHostRecord;
NetAddrElement *mIter;
int mIterGenCnt; // the generation count of
// mHostRecord->addr_info when we
// start iterating
bool mDone;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsDNSRecord, nsIDNSRecord)
+NS_IMPL_ISUPPORTS1(nsDNSRecord, nsIDNSRecord)
NS_IMETHODIMP
nsDNSRecord::GetCanonicalName(nsACString &result)
{
// this method should only be called if we have a CNAME
NS_ENSURE_TRUE(mHostRecord->flags & nsHostResolver::RES_CANON_NAME,
NS_ERROR_NOT_AVAILABLE);
@@ -241,17 +241,17 @@ nsDNSRecord::ReportUnusable(uint16_t aPo
}
//-----------------------------------------------------------------------------
class nsDNSAsyncRequest MOZ_FINAL : public nsResolveHostCallback
, public nsICancelable
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSICANCELABLE
nsDNSAsyncRequest(nsHostResolver *res,
const nsACString &host,
nsIDNSListener *listener,
uint16_t flags,
uint16_t af)
: mResolver(res)
@@ -301,17 +301,17 @@ nsDNSAsyncRequest::OnLookupComplete(nsHo
}
bool
nsDNSAsyncRequest::EqualsAsyncListener(nsIDNSListener *aListener)
{
return (aListener == mListener);
}
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsDNSAsyncRequest, nsICancelable)
+NS_IMPL_ISUPPORTS1(nsDNSAsyncRequest, nsICancelable)
NS_IMETHODIMP
nsDNSAsyncRequest::Cancel(nsresult reason)
{
NS_ENSURE_ARG(NS_FAILED(reason));
mResolver->DetachCallback(mHost.get(), mFlags, mAF, this, reason);
return NS_OK;
}
@@ -367,17 +367,17 @@ nsDNSService::nsDNSService()
, mOffline(false)
{
}
nsDNSService::~nsDNSService()
{
}
-NS_IMPL_THREADSAFE_ISUPPORTS3(nsDNSService, nsIDNSService, nsPIDNSService,
+NS_IMPL_ISUPPORTS3(nsDNSService, nsIDNSService, nsPIDNSService,
nsIObserver)
NS_IMETHODIMP
nsDNSService::Init()
{
if (mResolver)
return NS_OK;
NS_ENSURE_TRUE(!mResolver, NS_ERROR_ALREADY_INITIALIZED);
@@ -527,17 +527,17 @@ public:
// Sometimes aListener is a main-thread only object like XPCWrappedJS, and
// sometimes it's a threadsafe object like nsSOCKSSocketInfo. Use a main-
// thread pointer holder, but disable strict enforcement of thread invariants.
// The AddRef implementation of XPCWrappedJS will assert if we go wrong here.
: mListener(new nsMainThreadPtrHolder<nsIDNSListener>(aListener, false))
, mTargetThread(aTargetThread)
{ }
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIDNSLISTENER
class OnLookupCompleteRunnable : public nsRunnable
{
public:
OnLookupCompleteRunnable(const nsMainThreadPtrHandle<nsIDNSListener>& aListener,
nsICancelable* aRequest,
nsIDNSRecord* aRecord,
@@ -557,17 +557,17 @@ public:
nsresult mStatus;
};
private:
nsMainThreadPtrHandle<nsIDNSListener> mListener;
nsCOMPtr<nsIEventTarget> mTargetThread;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(DNSListenerProxy, nsIDNSListener)
+NS_IMPL_ISUPPORTS1(DNSListenerProxy, nsIDNSListener)
NS_IMETHODIMP
DNSListenerProxy::OnLookupComplete(nsICancelable* aRequest,
nsIDNSRecord* aRecord,
nsresult aStatus)
{
nsRefPtr<OnLookupCompleteRunnable> r =
new OnLookupCompleteRunnable(mListener, aRequest, aRecord, aStatus);
--- a/netwerk/dns/nsDNSService2.h
+++ b/netwerk/dns/nsDNSService2.h
@@ -15,17 +15,17 @@
#include "nsHashKeys.h"
#include "mozilla/Mutex.h"
#include "mozilla/Attributes.h"
class nsDNSService MOZ_FINAL : public nsPIDNSService
, public nsIObserver
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSPIDNSSERVICE
NS_DECL_NSIDNSSERVICE
NS_DECL_NSIOBSERVER
nsDNSService();
~nsDNSService();
private:
--- a/netwerk/dns/nsIDNService.cpp
+++ b/netwerk/dns/nsIDNService.cpp
@@ -41,20 +41,20 @@ inline bool isOnlySafeChars(const nsAFla
in.FindCharInSet(blacklist) == kNotFound);
}
//-----------------------------------------------------------------------------
// nsIDNService
//-----------------------------------------------------------------------------
/* Implementation file */
-NS_IMPL_THREADSAFE_ISUPPORTS3(nsIDNService,
- nsIIDNService,
- nsIObserver,
- nsISupportsWeakReference)
+NS_IMPL_ISUPPORTS3(nsIDNService,
+ nsIIDNService,
+ nsIObserver,
+ nsISupportsWeakReference)
nsresult nsIDNService::Init()
{
nsCOMPtr<nsIPrefService> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
if (prefs)
prefs->GetBranch(NS_NET_PREF_IDNWHITELIST, getter_AddRefs(mIDNWhitelistPrefBranch));
nsCOMPtr<nsIPrefBranch> prefInternal(do_QueryInterface(prefs));
--- a/netwerk/dns/nsIDNService.h
+++ b/netwerk/dns/nsIDNService.h
@@ -22,17 +22,17 @@ class nsIPrefBranch;
#define kACEPrefixLen 4
class nsIDNService : public nsIIDNService,
public nsIObserver,
public nsSupportsWeakReference
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIIDNSERVICE
NS_DECL_NSIOBSERVER
nsIDNService();
virtual ~nsIDNService();
nsresult Init();
--- a/netwerk/ipc/RemoteOpenFileChild.cpp
+++ b/netwerk/ipc/RemoteOpenFileChild.cpp
@@ -57,20 +57,20 @@ private:
nsCOMPtr<nsIRemoteOpenFileListener> mListener;
nsresult mRV;
};
//-----------------------------------------------------------------------------
// RemoteOpenFileChild
//-----------------------------------------------------------------------------
-NS_IMPL_THREADSAFE_ISUPPORTS3(RemoteOpenFileChild,
- nsIFile,
- nsIHashable,
- nsICachedFileDescriptorListener)
+NS_IMPL_ISUPPORTS3(RemoteOpenFileChild,
+ nsIFile,
+ nsIHashable,
+ nsICachedFileDescriptorListener)
RemoteOpenFileChild::RemoteOpenFileChild(const RemoteOpenFileChild& other)
: mTabChild(other.mTabChild)
, mNSPRFileDesc(other.mNSPRFileDesc)
, mAsyncOpenCalled(other.mAsyncOpenCalled)
, mNSPROpenCalled(other.mNSPROpenCalled)
{
// Note: don't clone mListener or we'll have a refcount leak.
--- a/netwerk/ipc/RemoteOpenFileChild.h
+++ b/netwerk/ipc/RemoteOpenFileChild.h
@@ -54,17 +54,17 @@ public:
RemoteOpenFileChild()
: mNSPRFileDesc(nullptr)
, mAsyncOpenCalled(false)
, mNSPROpenCalled(false)
{}
virtual ~RemoteOpenFileChild();
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIFILE
NS_DECL_NSIHASHABLE
// URI must be scheme 'remoteopenfile://': otherwise looks like a file:// uri.
nsresult Init(nsIURI* aRemoteOpenUri);
// Send message to parent to tell it to open file handle for file.
// TabChild is required, for IPC security.
--- a/netwerk/protocol/device/AndroidCaptureProvider.cpp
+++ b/netwerk/protocol/device/AndroidCaptureProvider.cpp
@@ -12,17 +12,17 @@
#include "nsMemory.h"
#include "RawStructs.h"
// The maximum number of frames we keep in our queue. Don't live in the past.
#define MAX_FRAMES_QUEUED 10
using namespace mozilla::net;
-NS_IMPL_THREADSAFE_ISUPPORTS2(AndroidCameraInputStream, nsIInputStream, nsIAsyncInputStream)
+NS_IMPL_ISUPPORTS2(AndroidCameraInputStream, nsIInputStream, nsIAsyncInputStream)
AndroidCameraInputStream::AndroidCameraInputStream() :
mWidth(0), mHeight(0), mCamera(0), mHeaderSent(false), mClosed(true), mFrameSize(0),
mMonitor("AndroidCamera.Monitor")
{
mAvailable = sizeof(RawVideoHeader);
mFrameQueue = new nsDeque();
}
@@ -250,17 +250,17 @@ NS_IMETHODIMP AndroidCameraInputStream::
AndroidCameraInputStream::doClose();
return NS_OK;
}
/**
* AndroidCaptureProvider implementation
*/
-NS_IMPL_THREADSAFE_ISUPPORTS0(AndroidCaptureProvider)
+NS_IMPL_ISUPPORTS0(AndroidCaptureProvider)
AndroidCaptureProvider* AndroidCaptureProvider::sInstance = NULL;
AndroidCaptureProvider::AndroidCaptureProvider() {
}
AndroidCaptureProvider::~AndroidCaptureProvider() {
AndroidCaptureProvider::sInstance = NULL;
--- a/netwerk/protocol/device/AndroidCaptureProvider.h
+++ b/netwerk/protocol/device/AndroidCaptureProvider.h
@@ -16,30 +16,30 @@
#include "nsDeque.h"
#include "mozilla/ReentrantMonitor.h"
class AndroidCaptureProvider MOZ_FINAL : public nsDeviceCaptureProvider {
public:
AndroidCaptureProvider();
~AndroidCaptureProvider();
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
nsresult Init(nsACString& aContentType, nsCaptureParams* aParams, nsIInputStream** aStream);
static AndroidCaptureProvider* sInstance;
};
class AndroidCameraInputStream MOZ_FINAL : public nsIAsyncInputStream, mozilla::net::CameraStreamImpl::FrameCallback {
public:
AndroidCameraInputStream();
~AndroidCameraInputStream();
NS_IMETHODIMP Init(nsACString& aContentType, nsCaptureParams* aParams);
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIINPUTSTREAM
NS_DECL_NSIASYNCINPUTSTREAM
void ReceiveFrame(char* frame, uint32_t length);
protected:
void NotifyListeners();
void doClose();
--- a/netwerk/protocol/device/nsDeviceProtocolHandler.cpp
+++ b/netwerk/protocol/device/nsDeviceProtocolHandler.cpp
@@ -7,18 +7,18 @@
#include "nsDeviceChannel.h"
#include "nsNetCID.h"
#include "nsAutoPtr.h"
#include "nsCOMPtr.h"
#include "nsSimpleURI.h"
//-----------------------------------------------------------------------------
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsDeviceProtocolHandler,
- nsIProtocolHandler)
+NS_IMPL_ISUPPORTS1(nsDeviceProtocolHandler,
+ nsIProtocolHandler)
nsresult
nsDeviceProtocolHandler::Init(){
return NS_OK;
}
NS_IMETHODIMP
nsDeviceProtocolHandler::GetScheme(nsACString &aResult)
--- a/netwerk/protocol/device/nsDeviceProtocolHandler.h
+++ b/netwerk/protocol/device/nsDeviceProtocolHandler.h
@@ -12,17 +12,17 @@
// {6b0ffe9e-d114-486b-aeb7-da62e7273ed5}
#define NS_DEVICEPROTOCOLHANDLER_CID \
{ 0x60ffe9e, 0xd114, 0x486b, \
{0xae, 0xb7, 0xda, 0x62, 0xe7, 0x27, 0x3e, 0xd5} }
class nsDeviceProtocolHandler MOZ_FINAL : public nsIProtocolHandler {
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIPROTOCOLHANDLER
nsDeviceProtocolHandler() {}
~nsDeviceProtocolHandler() {}
nsresult Init();
};
--- a/netwerk/protocol/file/nsFileProtocolHandler.cpp
+++ b/netwerk/protocol/file/nsFileProtocolHandler.cpp
@@ -46,20 +46,20 @@ nsFileProtocolHandler::nsFileProtocolHan
}
nsresult
nsFileProtocolHandler::Init()
{
return NS_OK;
}
-NS_IMPL_THREADSAFE_ISUPPORTS3(nsFileProtocolHandler,
- nsIFileProtocolHandler,
- nsIProtocolHandler,
- nsISupportsWeakReference)
+NS_IMPL_ISUPPORTS3(nsFileProtocolHandler,
+ nsIFileProtocolHandler,
+ nsIProtocolHandler,
+ nsISupportsWeakReference)
//-----------------------------------------------------------------------------
// nsIProtocolHandler methods:
#if defined(XP_WIN)
NS_IMETHODIMP
nsFileProtocolHandler::ReadURLFile(nsIFile* aFile, nsIURI** aURI)
{
--- a/netwerk/protocol/file/nsFileProtocolHandler.h
+++ b/netwerk/protocol/file/nsFileProtocolHandler.h
@@ -8,17 +8,17 @@
#include "nsIFileProtocolHandler.h"
#include "nsWeakReference.h"
class nsFileProtocolHandler : public nsIFileProtocolHandler
, public nsSupportsWeakReference
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIPROTOCOLHANDLER
NS_DECL_NSIFILEPROTOCOLHANDLER
nsFileProtocolHandler();
virtual ~nsFileProtocolHandler() {}
nsresult Init();
};
--- a/netwerk/protocol/ftp/nsFTPChannel.cpp
+++ b/netwerk/protocol/ftp/nsFTPChannel.cpp
@@ -154,17 +154,17 @@ namespace {
class FTPEventSinkProxy MOZ_FINAL : public nsIFTPEventSink
{
public:
FTPEventSinkProxy(nsIFTPEventSink* aTarget)
: mTarget(aTarget)
, mTargetThread(do_GetCurrentThread())
{ }
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIFTPEVENTSINK
class OnFTPControlLogRunnable : public nsRunnable
{
public:
OnFTPControlLogRunnable(nsIFTPEventSink* aTarget,
bool aServer,
const char* aMessage)
@@ -181,17 +181,17 @@ public:
nsCString mMessage;
};
private:
nsCOMPtr<nsIFTPEventSink> mTarget;
nsCOMPtr<nsIThread> mTargetThread;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(FTPEventSinkProxy, nsIFTPEventSink)
+NS_IMPL_ISUPPORTS1(FTPEventSinkProxy, nsIFTPEventSink)
NS_IMETHODIMP
FTPEventSinkProxy::OnFTPControlLog(bool aServer, const char* aMsg)
{
nsRefPtr<OnFTPControlLogRunnable> r =
new OnFTPControlLogRunnable(mTarget, aServer, aMsg);
return mTargetThread->Dispatch(r, NS_DISPATCH_NORMAL);
}
--- a/netwerk/protocol/ftp/nsFtpProtocolHandler.cpp
+++ b/netwerk/protocol/ftp/nsFtpProtocolHandler.cpp
@@ -89,21 +89,21 @@ nsFtpProtocolHandler::~nsFtpProtocolHand
{
LOG(("FTP:destroying handler @%x\n", this));
NS_ASSERTION(mRootConnectionList.Length() == 0, "why wasn't Observe called?");
gFtpHandler = nullptr;
}
-NS_IMPL_THREADSAFE_ISUPPORTS4(nsFtpProtocolHandler,
- nsIProtocolHandler,
- nsIProxiedProtocolHandler,
- nsIObserver,
- nsISupportsWeakReference)
+NS_IMPL_ISUPPORTS4(nsFtpProtocolHandler,
+ nsIProtocolHandler,
+ nsIProxiedProtocolHandler,
+ nsIObserver,
+ nsISupportsWeakReference)
nsresult
nsFtpProtocolHandler::Init()
{
if (IsNeckoChild())
NeckoChild::InitNeckoChild();
if (mIdleTimeout == -1) {
--- a/netwerk/protocol/ftp/nsFtpProtocolHandler.h
+++ b/netwerk/protocol/ftp/nsFtpProtocolHandler.h
@@ -23,17 +23,17 @@ class nsIStreamListener;
//-----------------------------------------------------------------------------
class nsFtpProtocolHandler : public nsIProxiedProtocolHandler
, public nsIObserver
, public nsSupportsWeakReference
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIPROTOCOLHANDLER
NS_DECL_NSIPROXIEDPROTOCOLHANDLER
NS_DECL_NSIOBSERVER
nsFtpProtocolHandler();
virtual ~nsFtpProtocolHandler();
nsresult Init();
--- a/netwerk/protocol/http/NullHttpTransaction.cpp
+++ b/netwerk/protocol/http/NullHttpTransaction.cpp
@@ -10,17 +10,17 @@
#include "nsHttp.h"
#include "NullHttpTransaction.h"
#include "nsProxyRelease.h"
#include "nsHttpHandler.h"
namespace mozilla {
namespace net {
-NS_IMPL_THREADSAFE_ISUPPORTS0(NullHttpTransaction)
+NS_IMPL_ISUPPORTS0(NullHttpTransaction)
NullHttpTransaction::NullHttpTransaction(nsHttpConnectionInfo *ci,
nsIInterfaceRequestor *callbacks,
uint32_t caps)
: mStatus(NS_OK)
, mCaps(caps | NS_HTTP_ALLOW_KEEPALIVE)
, mCallbacks(callbacks)
, mConnectionInfo(ci)
--- a/netwerk/protocol/http/NullHttpTransaction.h
+++ b/netwerk/protocol/http/NullHttpTransaction.h
@@ -19,17 +19,17 @@
// tunnels) so that a nsHttpConnection becomes fully established in
// anticipation of a real transaction needing to use it soon.
namespace mozilla { namespace net {
class NullHttpTransaction MOZ_FINAL : public nsAHttpTransaction
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSAHTTPTRANSACTION
NullHttpTransaction(nsHttpConnectionInfo *ci,
nsIInterfaceRequestor *callbacks,
uint32_t caps);
~NullHttpTransaction();
nsHttpConnectionInfo *ConnectionInfo() { return mConnectionInfo; }
--- a/netwerk/protocol/http/SpdyPush3.cpp
+++ b/netwerk/protocol/http/SpdyPush3.cpp
@@ -203,17 +203,17 @@ SpdyPushCache3::RemovePushedStream(nsCSt
}
//////////////////////////////////////////
// SpdyPush3TransactionBuffer
// This is the nsAHttpTransction owned by the stream when the pushed
// stream has not yet been matched with a pull request
//////////////////////////////////////////
-NS_IMPL_THREADSAFE_ISUPPORTS0(SpdyPush3TransactionBuffer)
+NS_IMPL_ISUPPORTS0(SpdyPush3TransactionBuffer)
SpdyPush3TransactionBuffer::SpdyPush3TransactionBuffer()
: mStatus(NS_OK)
, mRequestHead(nullptr)
, mPushStream(nullptr)
, mIsDone(false)
, mBufferedHTTP1Size(kDefaultBufferSize)
, mBufferedHTTP1Used(0)
--- a/netwerk/protocol/http/SpdyPush3.h
+++ b/netwerk/protocol/http/SpdyPush3.h
@@ -68,17 +68,17 @@ private:
nsresult mStatus;
bool mPushCompleted; // server push FIN received
bool mDeferCleanupOnSuccess;
};
class SpdyPush3TransactionBuffer MOZ_FINAL : public nsAHttpTransaction
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSAHTTPTRANSACTION
SpdyPush3TransactionBuffer();
virtual ~SpdyPush3TransactionBuffer();
nsresult GetBufferedData(char *buf, uint32_t count, uint32_t *countWritten);
void SetPushStream(SpdyPushedStream3 *stream) { mPushStream = stream; }
--- a/netwerk/protocol/http/SpdySession2.cpp
+++ b/netwerk/protocol/http/SpdySession2.cpp
@@ -24,18 +24,18 @@ extern PRThread *gSocketThread;
#endif
namespace mozilla {
namespace net {
// SpdySession2 has multiple inheritance of things that implement
// nsISupports, so this magic is taken from nsHttpPipeline that
// implements some of the same abstract classes.
-NS_IMPL_THREADSAFE_ADDREF(SpdySession2)
-NS_IMPL_THREADSAFE_RELEASE(SpdySession2)
+NS_IMPL_ADDREF(SpdySession2)
+NS_IMPL_RELEASE(SpdySession2)
NS_INTERFACE_MAP_BEGIN(SpdySession2)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsAHttpConnection)
NS_INTERFACE_MAP_END
SpdySession2::SpdySession2(nsAHttpTransaction *aHttpTransaction,
nsISocketTransport *aSocketTransport,
int32_t firstPriority)
: mSocketTransport(aSocketTransport),
--- a/netwerk/protocol/http/SpdySession2.h
+++ b/netwerk/protocol/http/SpdySession2.h
@@ -26,17 +26,17 @@ namespace mozilla { namespace net {
class SpdyStream2;
class SpdySession2 MOZ_FINAL : public ASpdySession
, public nsAHttpConnection
, public nsAHttpSegmentReader
, public nsAHttpSegmentWriter
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSAHTTPTRANSACTION
NS_DECL_NSAHTTPCONNECTION(mConnection)
NS_DECL_NSAHTTPSEGMENTREADER
NS_DECL_NSAHTTPSEGMENTWRITER
SpdySession2(nsAHttpTransaction *, nsISocketTransport *, int32_t);
~SpdySession2();
--- a/netwerk/protocol/http/SpdySession3.cpp
+++ b/netwerk/protocol/http/SpdySession3.cpp
@@ -27,18 +27,18 @@ extern PRThread *gSocketThread;
#endif
namespace mozilla {
namespace net {
// SpdySession3 has multiple inheritance of things that implement
// nsISupports, so this magic is taken from nsHttpPipeline that
// implements some of the same abstract classes.
-NS_IMPL_THREADSAFE_ADDREF(SpdySession3)
-NS_IMPL_THREADSAFE_RELEASE(SpdySession3)
+NS_IMPL_ADDREF(SpdySession3)
+NS_IMPL_RELEASE(SpdySession3)
NS_INTERFACE_MAP_BEGIN(SpdySession3)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsAHttpConnection)
NS_INTERFACE_MAP_END
SpdySession3::SpdySession3(nsAHttpTransaction *aHttpTransaction,
nsISocketTransport *aSocketTransport,
int32_t firstPriority)
: mSocketTransport(aSocketTransport),
--- a/netwerk/protocol/http/SpdySession3.h
+++ b/netwerk/protocol/http/SpdySession3.h
@@ -24,17 +24,17 @@ namespace mozilla { namespace net {
class SpdyStream3;
class SpdySession3 MOZ_FINAL : public ASpdySession
, public nsAHttpConnection
, public nsAHttpSegmentReader
, public nsAHttpSegmentWriter
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSAHTTPTRANSACTION
NS_DECL_NSAHTTPCONNECTION(mConnection)
NS_DECL_NSAHTTPSEGMENTREADER
NS_DECL_NSAHTTPSEGMENTWRITER
SpdySession3(nsAHttpTransaction *, nsISocketTransport *, int32_t);
~SpdySession3();
--- a/netwerk/protocol/http/nsHttpActivityDistributor.cpp
+++ b/netwerk/protocol/http/nsHttpActivityDistributor.cpp
@@ -56,19 +56,19 @@ private:
uint32_t mActivitySubtype;
PRTime mTimestamp;
uint64_t mExtraSizeData;
nsCString mExtraStringData;
ObserverArray mObservers;
};
-NS_IMPL_THREADSAFE_ISUPPORTS2(nsHttpActivityDistributor,
- nsIHttpActivityDistributor,
- nsIHttpActivityObserver)
+NS_IMPL_ISUPPORTS2(nsHttpActivityDistributor,
+ nsIHttpActivityDistributor,
+ nsIHttpActivityObserver)
nsHttpActivityDistributor::nsHttpActivityDistributor()
: mLock("nsHttpActivityDistributor.mLock")
{
}
nsHttpActivityDistributor::~nsHttpActivityDistributor()
{
--- a/netwerk/protocol/http/nsHttpActivityDistributor.h
+++ b/netwerk/protocol/http/nsHttpActivityDistributor.h
@@ -10,17 +10,17 @@
#include "nsProxyRelease.h"
#include "mozilla/Mutex.h"
class nsHttpActivityDistributor : public nsIHttpActivityDistributor
{
public:
typedef nsTArray<nsMainThreadPtrHandle<nsIHttpActivityObserver> > ObserverArray;
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIHTTPACTIVITYOBSERVER
NS_DECL_NSIHTTPACTIVITYDISTRIBUTOR
nsHttpActivityDistributor();
virtual ~nsHttpActivityDistributor();
protected:
ObserverArray mObservers;
--- a/netwerk/protocol/http/nsHttpConnection.cpp
+++ b/netwerk/protocol/http/nsHttpConnection.cpp
@@ -1509,21 +1509,21 @@ nsHttpConnection::SetupProxyConnect()
return NS_NewCStringInputStream(getter_AddRefs(mProxyConnectStream), buf);
}
//-----------------------------------------------------------------------------
// nsHttpConnection::nsISupports
//-----------------------------------------------------------------------------
-NS_IMPL_THREADSAFE_ISUPPORTS4(nsHttpConnection,
- nsIInputStreamCallback,
- nsIOutputStreamCallback,
- nsITransportEventSink,
- nsIInterfaceRequestor)
+NS_IMPL_ISUPPORTS4(nsHttpConnection,
+ nsIInputStreamCallback,
+ nsIOutputStreamCallback,
+ nsITransportEventSink,
+ nsIInterfaceRequestor)
//-----------------------------------------------------------------------------
// nsHttpConnection::nsIInputStreamCallback
//-----------------------------------------------------------------------------
// called on the socket transport thread
NS_IMETHODIMP
nsHttpConnection::OnInputStreamReady(nsIAsyncInputStream *in)
--- a/netwerk/protocol/http/nsHttpConnection.h
+++ b/netwerk/protocol/http/nsHttpConnection.h
@@ -36,17 +36,17 @@ class nsHttpResponseHead;
class nsHttpConnection : public nsAHttpSegmentReader
, public nsAHttpSegmentWriter
, public nsIInputStreamCallback
, public nsIOutputStreamCallback
, public nsITransportEventSink
, public nsIInterfaceRequestor
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSAHTTPSEGMENTREADER
NS_DECL_NSAHTTPSEGMENTWRITER
NS_DECL_NSIINPUTSTREAMCALLBACK
NS_DECL_NSIOUTPUTSTREAMCALLBACK
NS_DECL_NSITRANSPORTEVENTSINK
NS_DECL_NSIINTERFACEREQUESTOR
nsHttpConnection();
--- a/netwerk/protocol/http/nsHttpConnectionInfo.h
+++ b/netwerk/protocol/http/nsHttpConnectionInfo.h
@@ -31,24 +31,24 @@ public:
~nsHttpConnectionInfo()
{
PR_LOG(gHttpLog, 4, ("Destroying nsHttpConnectionInfo @%x\n", this));
}
nsrefcnt AddRef()
{
- nsrefcnt n = NS_AtomicIncrementRefcnt(mRef);
+ nsrefcnt n = ++mRef;
NS_LOG_ADDREF(this, n, "nsHttpConnectionInfo", sizeof(*this));
return n;
}
nsrefcnt Release()
{
- nsrefcnt n = NS_AtomicDecrementRefcnt(mRef);
+ nsrefcnt n = --mRef;
NS_LOG_RELEASE(this, n, "nsHttpConnectionInfo");
if (n == 0)
delete this;
return n;
}
const nsAFlatCString &HashKey() const { return mHashKey; }
@@ -92,17 +92,17 @@ public:
bool GetPrivate() const { return mHashKey.CharAt(3) == 'P'; }
const nsCString &GetHost() { return mHost; }
// Returns true for any kind of proxy (http, socks, etc..)
bool UsingProxy();
private:
- nsrefcnt mRef;
+ mozilla::ThreadSafeAutoRefCnt mRef;
nsCString mHashKey;
nsCString mHost;
int32_t mPort;
nsCOMPtr<nsProxyInfo> mProxyInfo;
bool mUsingHttpProxy;
bool mUsingSSL;
bool mUsingConnect; // if will use CONNECT with http proxy
};
--- a/netwerk/protocol/http/nsHttpConnectionMgr.cpp
+++ b/netwerk/protocol/http/nsHttpConnectionMgr.cpp
@@ -32,17 +32,17 @@ using namespace mozilla::net;
// defined by the socket transport service while active
extern PRThread *gSocketThread;
static NS_DEFINE_CID(kSocketTransportServiceCID, NS_SOCKETTRANSPORTSERVICE_CID);
//-----------------------------------------------------------------------------
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsHttpConnectionMgr, nsIObserver)
+NS_IMPL_ISUPPORTS1(nsHttpConnectionMgr, nsIObserver)
static void
InsertTransactionSorted(nsTArray<nsHttpTransaction*> &pendingQ, nsHttpTransaction *trans)
{
// insert into queue with smallest valued number first. search in reverse
// order under the assumption that many of the existing transactions will
// have the same priority (usually 0).
@@ -2454,17 +2454,17 @@ nsHttpConnectionMgr::TimeoutTickCB(const
nsHttpConnectionMgr::nsConnectionHandle::~nsConnectionHandle()
{
if (mConn) {
gHttpHandler->ReclaimConnection(mConn);
NS_RELEASE(mConn);
}
}
-NS_IMPL_THREADSAFE_ISUPPORTS0(nsHttpConnectionMgr::nsConnectionHandle)
+NS_IMPL_ISUPPORTS0(nsHttpConnectionMgr::nsConnectionHandle)
nsHttpConnectionMgr::nsConnectionEntry *
nsHttpConnectionMgr::GetOrCreateConnectionEntry(nsHttpConnectionInfo *ci)
{
nsConnectionEntry *ent = mCT.Get(ci->HashKey());
if (ent)
return ent;
@@ -2552,21 +2552,21 @@ nsHttpConnectionMgr::nsConnectionHandle:
{
return mConn->PushBack(buf, bufLen);
}
//////////////////////// nsHalfOpenSocket
-NS_IMPL_THREADSAFE_ISUPPORTS4(nsHttpConnectionMgr::nsHalfOpenSocket,
- nsIOutputStreamCallback,
- nsITransportEventSink,
- nsIInterfaceRequestor,
- nsITimerCallback)
+NS_IMPL_ISUPPORTS4(nsHttpConnectionMgr::nsHalfOpenSocket,
+ nsIOutputStreamCallback,
+ nsITransportEventSink,
+ nsIInterfaceRequestor,
+ nsITimerCallback)
nsHttpConnectionMgr::
nsHalfOpenSocket::nsHalfOpenSocket(nsConnectionEntry *ent,
nsAHttpTransaction *trans,
uint32_t caps)
: mEnt(ent),
mTransaction(trans),
mCaps(caps),
--- a/netwerk/protocol/http/nsHttpConnectionMgr.h
+++ b/netwerk/protocol/http/nsHttpConnectionMgr.h
@@ -35,17 +35,17 @@ class EventTokenBucket;
}
}
//-----------------------------------------------------------------------------
class nsHttpConnectionMgr : public nsIObserver
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIOBSERVER
// parameter names
enum nsParamName {
MAX_CONNECTIONS,
MAX_PERSISTENT_CONNECTIONS_PER_HOST,
MAX_PERSISTENT_CONNECTIONS_PER_PROXY,
MAX_REQUEST_DELAY,
@@ -385,17 +385,17 @@ private:
// transaction (or pipeline) owns a reference to this handle. this extra
// layer of indirection greatly simplifies consumer code, avoiding the
// need for consumer code to know when to give the connection back to the
// connection manager.
//
class nsConnectionHandle : public nsAHttpConnection
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSAHTTPCONNECTION(mConn)
nsConnectionHandle(nsHttpConnection *conn) { NS_ADDREF(mConn = conn); }
virtual ~nsConnectionHandle();
nsHttpConnection *mConn;
};
@@ -403,17 +403,17 @@ private:
// while we wait for it to establish and bind it to a connection
class nsHalfOpenSocket MOZ_FINAL : public nsIOutputStreamCallback,
public nsITransportEventSink,
public nsIInterfaceRequestor,
public nsITimerCallback
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIOUTPUTSTREAMCALLBACK
NS_DECL_NSITRANSPORTEVENTSINK
NS_DECL_NSIINTERFACEREQUESTOR
NS_DECL_NSITIMERCALLBACK
nsHalfOpenSocket(nsConnectionEntry *ent,
nsAHttpTransaction *trans,
uint32_t caps);
--- a/netwerk/protocol/http/nsHttpHandler.cpp
+++ b/netwerk/protocol/http/nsHttpHandler.cpp
@@ -1497,23 +1497,23 @@ nsHttpHandler::SetAcceptEncodings(const
mAcceptEncodings = aAcceptEncodings;
return NS_OK;
}
//-----------------------------------------------------------------------------
// nsHttpHandler::nsISupports
//-----------------------------------------------------------------------------
-NS_IMPL_THREADSAFE_ISUPPORTS6(nsHttpHandler,
- nsIHttpProtocolHandler,
- nsIProxiedProtocolHandler,
- nsIProtocolHandler,
- nsIObserver,
- nsISupportsWeakReference,
- nsISpeculativeConnect)
+NS_IMPL_ISUPPORTS6(nsHttpHandler,
+ nsIHttpProtocolHandler,
+ nsIProxiedProtocolHandler,
+ nsIProtocolHandler,
+ nsIObserver,
+ nsISupportsWeakReference,
+ nsISpeculativeConnect)
//-----------------------------------------------------------------------------
// nsHttpHandler::nsIProtocolHandler
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsHttpHandler::GetScheme(nsACString &aScheme)
{
@@ -1934,22 +1934,22 @@ nsHttpHandler::TickleWifi(nsIInterfaceRe
mWifiTickler->SetIPV4Address(gwAddress);
mWifiTickler->Tickle();
}
//-----------------------------------------------------------------------------
// nsHttpsHandler implementation
//-----------------------------------------------------------------------------
-NS_IMPL_THREADSAFE_ISUPPORTS5(nsHttpsHandler,
- nsIHttpProtocolHandler,
- nsIProxiedProtocolHandler,
- nsIProtocolHandler,
- nsISupportsWeakReference,
- nsISpeculativeConnect)
+NS_IMPL_ISUPPORTS5(nsHttpsHandler,
+ nsIHttpProtocolHandler,
+ nsIProxiedProtocolHandler,
+ nsIProtocolHandler,
+ nsISupportsWeakReference,
+ nsISpeculativeConnect)
nsresult
nsHttpsHandler::Init()
{
nsCOMPtr<nsIProtocolHandler> httpHandler(
do_GetService(NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "http"));
MOZ_ASSERT(httpHandler.get() != nullptr);
return NS_OK;
--- a/netwerk/protocol/http/nsHttpHandler.h
+++ b/netwerk/protocol/http/nsHttpHandler.h
@@ -50,17 +50,17 @@ class Tickler;
//-----------------------------------------------------------------------------
class nsHttpHandler : public nsIHttpProtocolHandler
, public nsIObserver
, public nsSupportsWeakReference
, public nsISpeculativeConnect
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIPROTOCOLHANDLER
NS_DECL_NSIPROXIEDPROTOCOLHANDLER
NS_DECL_NSIHTTPPROTOCOLHANDLER
NS_DECL_NSIOBSERVER
NS_DECL_NSISPECULATIVECONNECT
nsHttpHandler();
virtual ~nsHttpHandler();
@@ -490,17 +490,17 @@ extern nsHttpHandler *gHttpHandler;
class nsHttpsHandler : public nsIHttpProtocolHandler
, public nsSupportsWeakReference
, public nsISpeculativeConnect
{
public:
// we basically just want to override GetScheme and GetDefaultPort...
// all other methods should be forwarded to the nsHttpHandler instance.
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIPROTOCOLHANDLER
NS_FORWARD_NSIPROXIEDPROTOCOLHANDLER (gHttpHandler->)
NS_FORWARD_NSIHTTPPROTOCOLHANDLER (gHttpHandler->)
NS_FORWARD_NSISPECULATIVECONNECT (gHttpHandler->)
nsHttpsHandler() { }
virtual ~nsHttpsHandler() { }
--- a/netwerk/protocol/http/nsHttpPipeline.cpp
+++ b/netwerk/protocol/http/nsHttpPipeline.cpp
@@ -156,18 +156,18 @@ nsHttpPipeline::QueryPipeline()
{
return this;
}
//-----------------------------------------------------------------------------
// nsHttpPipeline::nsISupports
//-----------------------------------------------------------------------------
-NS_IMPL_THREADSAFE_ADDREF(nsHttpPipeline)
-NS_IMPL_THREADSAFE_RELEASE(nsHttpPipeline)
+NS_IMPL_ADDREF(nsHttpPipeline)
+NS_IMPL_RELEASE(nsHttpPipeline)
// multiple inheritance fun :-)
NS_INTERFACE_MAP_BEGIN(nsHttpPipeline)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsAHttpConnection)
NS_INTERFACE_MAP_END
//-----------------------------------------------------------------------------
--- a/netwerk/protocol/http/nsHttpPipeline.h
+++ b/netwerk/protocol/http/nsHttpPipeline.h
@@ -14,17 +14,17 @@
#include "nsTArray.h"
#include "nsCOMPtr.h"
class nsHttpPipeline : public nsAHttpConnection
, public nsAHttpTransaction
, public nsAHttpSegmentReader
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSAHTTPCONNECTION(mConnection)
NS_DECL_NSAHTTPTRANSACTION
NS_DECL_NSAHTTPSEGMENTREADER
nsHttpPipeline();
virtual ~nsHttpPipeline();
private:
--- a/netwerk/protocol/http/nsHttpTransaction.cpp
+++ b/netwerk/protocol/http/nsHttpTransaction.cpp
@@ -1676,38 +1676,38 @@ nsHttpTransaction::CancelPacing(nsresult
mTokenBucketCancel = nullptr;
}
}
//-----------------------------------------------------------------------------
// nsHttpTransaction::nsISupports
//-----------------------------------------------------------------------------
-NS_IMPL_THREADSAFE_ADDREF(nsHttpTransaction)
+NS_IMPL_ADDREF(nsHttpTransaction)
NS_IMETHODIMP_(nsrefcnt)
nsHttpTransaction::Release()
{
nsrefcnt count;
NS_PRECONDITION(0 != mRefCnt, "dup release");
- count = NS_AtomicDecrementRefcnt(mRefCnt);
+ count = --mRefCnt;
NS_LOG_RELEASE(this, count, "nsHttpTransaction");
if (0 == count) {
mRefCnt = 1; /* stablize */
// it is essential that the transaction be destroyed on the consumer
// thread (we could be holding the last reference to our consumer).
DeleteSelfOnConsumerThread();
return 0;
}
return count;
}
-NS_IMPL_THREADSAFE_QUERY_INTERFACE2(nsHttpTransaction,
- nsIInputStreamCallback,
- nsIOutputStreamCallback)
+NS_IMPL_QUERY_INTERFACE2(nsHttpTransaction,
+ nsIInputStreamCallback,
+ nsIOutputStreamCallback)
//-----------------------------------------------------------------------------
// nsHttpTransaction::nsIInputStreamCallback
//-----------------------------------------------------------------------------
// called on the socket thread
NS_IMETHODIMP
nsHttpTransaction::OnInputStreamReady(nsIAsyncInputStream *out)
--- a/netwerk/protocol/http/nsHttpTransaction.h
+++ b/netwerk/protocol/http/nsHttpTransaction.h
@@ -37,17 +37,17 @@ class UpdateSecurityCallbacks;
//-----------------------------------------------------------------------------
class nsHttpTransaction : public nsAHttpTransaction
, public mozilla::net::ATokenBucketEvent
, public nsIInputStreamCallback
, public nsIOutputStreamCallback
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSAHTTPTRANSACTION
NS_DECL_NSIINPUTSTREAMCALLBACK
NS_DECL_NSIOUTPUTSTREAMCALLBACK
nsHttpTransaction();
virtual ~nsHttpTransaction();
//
--- a/netwerk/protocol/res/nsResProtocolHandler.cpp
+++ b/netwerk/protocol/res/nsResProtocolHandler.cpp
@@ -194,20 +194,20 @@ nsResProtocolHandler::CollectSubstitutio
{
mSubstitutions.EnumerateRead(&EnumerateSubstitution, &aResources);
}
//----------------------------------------------------------------------------
// nsResProtocolHandler::nsISupports
//----------------------------------------------------------------------------
-NS_IMPL_THREADSAFE_ISUPPORTS3(nsResProtocolHandler,
- nsIResProtocolHandler,
- nsIProtocolHandler,
- nsISupportsWeakReference)
+NS_IMPL_ISUPPORTS3(nsResProtocolHandler,
+ nsIResProtocolHandler,
+ nsIProtocolHandler,
+ nsISupportsWeakReference)
//----------------------------------------------------------------------------
// nsResProtocolHandler::nsIProtocolHandler
//----------------------------------------------------------------------------
NS_IMETHODIMP
nsResProtocolHandler::GetScheme(nsACString &result)
{
--- a/netwerk/protocol/res/nsResProtocolHandler.h
+++ b/netwerk/protocol/res/nsResProtocolHandler.h
@@ -22,17 +22,17 @@ public:
virtual nsStandardURL* StartClone();
virtual nsresult EnsureFile();
NS_IMETHOD GetClassIDNoAlloc(nsCID *aCID);
};
class nsResProtocolHandler : public nsIResProtocolHandler, public nsSupportsWeakReference
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIPROTOCOLHANDLER
NS_DECL_NSIRESPROTOCOLHANDLER
nsResProtocolHandler();
virtual ~nsResProtocolHandler();
nsresult Init();
--- a/netwerk/protocol/websocket/WebSocketChannel.cpp
+++ b/netwerk/protocol/websocket/WebSocketChannel.cpp
@@ -52,28 +52,28 @@
extern PRThread *gSocketThread;
using namespace mozilla;
namespace mozilla {
namespace net {
-NS_IMPL_THREADSAFE_ISUPPORTS11(WebSocketChannel,
- nsIWebSocketChannel,
- nsIHttpUpgradeListener,
- nsIRequestObserver,
- nsIStreamListener,
- nsIProtocolHandler,
- nsIInputStreamCallback,
- nsIOutputStreamCallback,
- nsITimerCallback,
- nsIDNSListener,
- nsIInterfaceRequestor,
- nsIChannelEventSink)
+NS_IMPL_ISUPPORTS11(WebSocketChannel,
+ nsIWebSocketChannel,
+ nsIHttpUpgradeListener,
+ nsIRequestObserver,
+ nsIStreamListener,
+ nsIProtocolHandler,
+ nsIInputStreamCallback,
+ nsIOutputStreamCallback,
+ nsITimerCallback,
+ nsIDNSListener,
+ nsIInterfaceRequestor,
+ nsIChannelEventSink)
// We implement RFC 6455, which uses Sec-WebSocket-Version: 13 on the wire.
#define SEC_WEBSOCKET_VERSION "13"
/*
* About SSL unsigned certificates
*
* wss will not work to a host using an unsigned certificate unless there
@@ -485,17 +485,17 @@ static nsWSAdmissionManager *sWebSocketA
//-----------------------------------------------------------------------------
// CallOnMessageAvailable
//-----------------------------------------------------------------------------
class CallOnMessageAvailable MOZ_FINAL : public nsIRunnable
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
CallOnMessageAvailable(WebSocketChannel *aChannel,
nsCString &aData,
int32_t aLen)
: mChannel(aChannel),
mData(aData),
mLen(aLen) {}
@@ -510,26 +510,26 @@ public:
private:
~CallOnMessageAvailable() {}
nsRefPtr<WebSocketChannel> mChannel;
nsCString mData;
int32_t mLen;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(CallOnMessageAvailable, nsIRunnable)
+NS_IMPL_ISUPPORTS1(CallOnMessageAvailable, nsIRunnable)
//-----------------------------------------------------------------------------
// CallOnStop
//-----------------------------------------------------------------------------
class CallOnStop MOZ_FINAL : public nsIRunnable
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
CallOnStop(WebSocketChannel *aChannel,
nsresult aReason)
: mChannel(aChannel),
mReason(aReason) {}
NS_IMETHOD Run()
{
@@ -546,26 +546,26 @@ public:
}
private:
~CallOnStop() {}
nsRefPtr<WebSocketChannel> mChannel;
nsresult mReason;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(CallOnStop, nsIRunnable)
+NS_IMPL_ISUPPORTS1(CallOnStop, nsIRunnable)
//-----------------------------------------------------------------------------
// CallOnServerClose
//-----------------------------------------------------------------------------
class CallOnServerClose MOZ_FINAL : public nsIRunnable
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
CallOnServerClose(WebSocketChannel *aChannel,
uint16_t aCode,
nsCString &aReason)
: mChannel(aChannel),
mCode(aCode),
mReason(aReason) {}
@@ -577,26 +577,26 @@ public:
private:
~CallOnServerClose() {}
nsRefPtr<WebSocketChannel> mChannel;
uint16_t mCode;
nsCString mReason;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(CallOnServerClose, nsIRunnable)
+NS_IMPL_ISUPPORTS1(CallOnServerClose, nsIRunnable)
//-----------------------------------------------------------------------------
// CallAcknowledge
//-----------------------------------------------------------------------------
class CallAcknowledge MOZ_FINAL : public nsIRunnable
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
CallAcknowledge(WebSocketChannel *aChannel,
uint32_t aSize)
: mChannel(aChannel),
mSize(aSize) {}
NS_IMETHOD Run()
{
@@ -606,26 +606,26 @@ public:
}
private:
~CallAcknowledge() {}
nsRefPtr<WebSocketChannel> mChannel;
uint32_t mSize;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(CallAcknowledge, nsIRunnable)
+NS_IMPL_ISUPPORTS1(CallAcknowledge, nsIRunnable)
//-----------------------------------------------------------------------------
// CallOnTransportAvailable
//-----------------------------------------------------------------------------
class CallOnTransportAvailable MOZ_FINAL : public nsIRunnable
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
CallOnTransportAvailable(WebSocketChannel *aChannel,
nsISocketTransport *aTransport,
nsIAsyncInputStream *aSocketIn,
nsIAsyncOutputStream *aSocketOut)
: mChannel(aChannel),
mTransport(aTransport),
mSocketIn(aSocketIn),
@@ -640,17 +640,17 @@ public:
private:
~CallOnTransportAvailable() {}
nsRefPtr<WebSocketChannel> mChannel;
nsCOMPtr<nsISocketTransport> mTransport;
nsCOMPtr<nsIAsyncInputStream> mSocketIn;
nsCOMPtr<nsIAsyncOutputStream> mSocketOut;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(CallOnTransportAvailable, nsIRunnable)
+NS_IMPL_ISUPPORTS1(CallOnTransportAvailable, nsIRunnable)
//-----------------------------------------------------------------------------
// OutboundMessage
//-----------------------------------------------------------------------------
enum WsMsgType {
kMsgTypeString = 0,
kMsgTypeBinaryString,
@@ -759,34 +759,34 @@ private:
//-----------------------------------------------------------------------------
// OutboundEnqueuer
//-----------------------------------------------------------------------------
class OutboundEnqueuer MOZ_FINAL : public nsIRunnable
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
OutboundEnqueuer(WebSocketChannel *aChannel, OutboundMessage *aMsg)
: mChannel(aChannel), mMessage(aMsg) {}
NS_IMETHOD Run()
{
mChannel->EnqueueOutgoingMessage(mChannel->mOutgoingMessages, mMessage);
return NS_OK;
}
private:
~OutboundEnqueuer() {}
nsRefPtr<WebSocketChannel> mChannel;
OutboundMessage *mMessage;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(OutboundEnqueuer, nsIRunnable)
+NS_IMPL_ISUPPORTS1(OutboundEnqueuer, nsIRunnable)
//-----------------------------------------------------------------------------
// nsWSCompression
//
// similar to nsDeflateConverter except for the mandatory FLUSH calls
// required by websocket and the absence of the deflate termination
// block which is appropriate because it would create data bytes after
// sending the websockets CLOSE message.
--- a/netwerk/protocol/websocket/WebSocketChannel.h
+++ b/netwerk/protocol/websocket/WebSocketChannel.h
@@ -57,17 +57,17 @@ class WebSocketChannel : public BaseWebS
public nsIInputStreamCallback,
public nsIOutputStreamCallback,
public nsITimerCallback,
public nsIDNSListener,
public nsIInterfaceRequestor,
public nsIChannelEventSink
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIHTTPUPGRADELISTENER
NS_DECL_NSIREQUESTOBSERVER
NS_DECL_NSISTREAMLISTENER
NS_DECL_NSIINPUTSTREAMCALLBACK
NS_DECL_NSIOUTPUTSTREAMCALLBACK
NS_DECL_NSITIMERCALLBACK
NS_DECL_NSIDNSLISTENER
NS_DECL_NSIINTERFACEREQUESTOR
--- a/netwerk/protocol/websocket/WebSocketChannelParent.cpp
+++ b/netwerk/protocol/websocket/WebSocketChannelParent.cpp
@@ -10,17 +10,17 @@
#include "mozilla/ipc/InputStreamUtils.h"
#include "mozilla/ipc/URIUtils.h"
using namespace mozilla::ipc;
namespace mozilla {
namespace net {
-NS_IMPL_THREADSAFE_ISUPPORTS2(WebSocketChannelParent,
+NS_IMPL_ISUPPORTS2(WebSocketChannelParent,
nsIWebSocketListener,
nsIInterfaceRequestor)
WebSocketChannelParent::WebSocketChannelParent(nsIAuthPromptProvider* aAuthProvider,
nsILoadContext* aLoadContext,
PBOverrideStatus aOverrideStatus)
: mAuthProvider(aAuthProvider)
, mLoadContext(aLoadContext)
--- a/netwerk/protocol/websocket/WebSocketChannelParent.h
+++ b/netwerk/protocol/websocket/WebSocketChannelParent.h
@@ -21,17 +21,17 @@ class nsIAuthPromptProvider;
namespace mozilla {
namespace net {
class WebSocketChannelParent : public PWebSocketParent,
public nsIWebSocketListener,
public nsIInterfaceRequestor
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIWEBSOCKETLISTENER
NS_DECL_NSIINTERFACEREQUESTOR
WebSocketChannelParent(nsIAuthPromptProvider* aAuthProvider,
nsILoadContext* aLoadContext,
PBOverrideStatus aOverrideStatus);
private:
--- a/netwerk/protocol/wyciwyg/nsWyciwygChannel.cpp
+++ b/netwerk/protocol/wyciwyg/nsWyciwygChannel.cpp
@@ -90,24 +90,24 @@ nsWyciwygChannel::nsWyciwygChannel()
mInBrowser(false)
{
}
nsWyciwygChannel::~nsWyciwygChannel()
{
}
-NS_IMPL_THREADSAFE_ISUPPORTS7(nsWyciwygChannel,
- nsIChannel,
- nsIRequest,
- nsIStreamListener,
- nsIRequestObserver,
- nsICacheListener,
- nsIWyciwygChannel,
- nsIPrivateBrowsingChannel)
+NS_IMPL_ISUPPORTS7(nsWyciwygChannel,
+ nsIChannel,
+ nsIRequest,
+ nsIStreamListener,
+ nsIRequestObserver,
+ nsICacheListener,
+ nsIWyciwygChannel,
+ nsIPrivateBrowsingChannel)
nsresult
nsWyciwygChannel::Init(nsIURI* uri)
{
NS_ENSURE_ARG_POINTER(uri);
nsresult rv;
--- a/netwerk/protocol/wyciwyg/nsWyciwygChannel.h
+++ b/netwerk/protocol/wyciwyg/nsWyciwygChannel.h
@@ -33,17 +33,17 @@ extern PRLogModuleInfo * gWyciwygLog;
//-----------------------------------------------------------------------------
class nsWyciwygChannel: public nsIWyciwygChannel,
public nsIStreamListener,
public nsICacheListener,
public mozilla::net::PrivateBrowsingChannel<nsWyciwygChannel>
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIREQUEST
NS_DECL_NSICHANNEL
NS_DECL_NSIWYCIWYGCHANNEL
NS_DECL_NSIREQUESTOBSERVER
NS_DECL_NSISTREAMLISTENER
NS_DECL_NSICACHELISTENER
friend class nsWyciwygSetCharsetandSourceEvent;
--- a/netwerk/sctp/datachannel/DataChannel.cpp
+++ b/netwerk/sctp/datachannel/DataChannel.cpp
@@ -267,18 +267,18 @@ void DataChannelConnection::DestroyOnSTS
if (aSocket && aSocket != aMasterSocket)
usrsctp_close(aSocket);
if (aMasterSocket)
usrsctp_close(aMasterSocket);
disconnect_all();
}
-NS_IMPL_THREADSAFE_ISUPPORTS1(DataChannelConnection,
- nsITimerCallback)
+NS_IMPL_ISUPPORTS1(DataChannelConnection,
+ nsITimerCallback)
bool
DataChannelConnection::Init(unsigned short aPort, uint16_t aNumStreams, bool aUsingDtls)
{
struct sctp_initmsg initmsg;
struct sctp_udpencaps encaps;
struct sctp_assoc_value av;
struct sctp_event event;
--- a/netwerk/sctp/datachannel/DataChannel.h
+++ b/netwerk/sctp/datachannel/DataChannel.h
@@ -116,17 +116,17 @@ public:
// One per PeerConnection
class DataChannelConnection: public nsITimerCallback
#ifdef SCTP_DTLS_SUPPORTED
, public sigslot::has_slots<>
#endif
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSITIMERCALLBACK
class DataConnectionListener : public SupportsWeakPtr<DataConnectionListener>
{
public:
virtual ~DataConnectionListener() {}
// Called when a the connection is open
--- a/netwerk/socket/nsSOCKSIOLayer.cpp
+++ b/netwerk/socket/nsSOCKSIOLayer.cpp
@@ -61,17 +61,17 @@ class nsSOCKSSocketInfo : public nsISOCK
// in case of SOCKS4 as well as SOCKS5
static const uint32_t BUFFER_SIZE = 262;
static const uint32_t MAX_HOSTNAME_LEN = 255;
public:
nsSOCKSSocketInfo();
virtual ~nsSOCKSSocketInfo() { HandshakeFinished(); }
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSISOCKSSOCKETINFO
NS_DECL_NSIDNSLISTENER
void Init(int32_t version,
int32_t family,
const char *proxyHost,
int32_t proxyPort,
const char *destinationHost,
@@ -172,17 +172,17 @@ nsSOCKSSocketInfo::Init(int32_t version,
mVersion = version;
mDestinationFamily = family;
mProxyHost = proxyHost;
mProxyPort = proxyPort;
mDestinationHost = host;
mFlags = flags;
}
-NS_IMPL_THREADSAFE_ISUPPORTS2(nsSOCKSSocketInfo, nsISOCKSSocketInfo, nsIDNSListener)
+NS_IMPL_ISUPPORTS2(nsSOCKSSocketInfo, nsISOCKSSocketInfo, nsIDNSListener)
NS_IMETHODIMP
nsSOCKSSocketInfo::GetExternalProxyAddr(NetAddr * *aExternalProxyAddr)
{
memcpy(*aExternalProxyAddr, &mExternalProxyAddr, sizeof(NetAddr));
return NS_OK;
}
--- a/netwerk/socket/nsSOCKSSocketProvider.cpp
+++ b/netwerk/socket/nsSOCKSSocketProvider.cpp
@@ -7,17 +7,17 @@
#include "nsIServiceManager.h"
#include "nsSOCKSSocketProvider.h"
#include "nsSOCKSIOLayer.h"
#include "nsCOMPtr.h"
#include "nsError.h"
//////////////////////////////////////////////////////////////////////////
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsSOCKSSocketProvider, nsISocketProvider)
+NS_IMPL_ISUPPORTS1(nsSOCKSSocketProvider, nsISocketProvider)
nsresult
nsSOCKSSocketProvider::CreateV4(nsISupports *aOuter, REFNSIID aIID, void **aResult)
{
nsresult rv;
nsCOMPtr<nsISocketProvider> inst =
new nsSOCKSSocketProvider(NS_SOCKS_VERSION_4);
if (!inst)
--- a/netwerk/socket/nsSOCKSSocketProvider.h
+++ b/netwerk/socket/nsSOCKSSocketProvider.h
@@ -13,17 +13,17 @@
enum {
NS_SOCKS_VERSION_4 = 4,
NS_SOCKS_VERSION_5 = 5
};
class nsSOCKSSocketProvider : public nsISocketProvider
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSISOCKETPROVIDER
nsSOCKSSocketProvider(uint32_t version) : mVersion(version) {}
virtual ~nsSOCKSSocketProvider() {}
static nsresult CreateV4(nsISupports *, REFNSIID aIID, void **aResult);
static nsresult CreateV5(nsISupports *, REFNSIID aIID, void **aResult);
--- a/netwerk/socket/nsSocketProviderService.cpp
+++ b/netwerk/socket/nsSocketProviderService.cpp
@@ -18,17 +18,17 @@ nsSocketProviderService::Create(nsISuppo
nsCOMPtr<nsISocketProviderService> inst = new nsSocketProviderService();
if (!inst)
rv = NS_ERROR_OUT_OF_MEMORY;
else
rv = inst->QueryInterface(aIID, aResult);
return rv;
}
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsSocketProviderService, nsISocketProviderService)
+NS_IMPL_ISUPPORTS1(nsSocketProviderService, nsISocketProviderService)
////////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsSocketProviderService::GetSocketProvider(const char *type,
nsISocketProvider **result)
{
nsresult rv;
--- a/netwerk/socket/nsSocketProviderService.h
+++ b/netwerk/socket/nsSocketProviderService.h
@@ -6,17 +6,17 @@
#ifndef nsSocketProviderService_h__
#define nsSocketProviderService_h__
#include "nsISocketProviderService.h"
class nsSocketProviderService : public nsISocketProviderService
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSISOCKETPROVIDERSERVICE
nsSocketProviderService() {}
virtual ~nsSocketProviderService() {}
static nsresult Create(nsISupports *, REFNSIID aIID, void **aResult);
};
--- a/netwerk/socket/nsUDPSocketProvider.cpp
+++ b/netwerk/socket/nsUDPSocketProvider.cpp
@@ -1,17 +1,17 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsUDPSocketProvider.h"
#include "nspr.h"
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsUDPSocketProvider, nsISocketProvider)
+NS_IMPL_ISUPPORTS1(nsUDPSocketProvider, nsISocketProvider)
nsUDPSocketProvider::~nsUDPSocketProvider()
{
}
NS_IMETHODIMP
nsUDPSocketProvider::NewSocket(int32_t aFamily,
const char *aHost,
--- a/netwerk/socket/nsUDPSocketProvider.h
+++ b/netwerk/socket/nsUDPSocketProvider.h
@@ -6,17 +6,17 @@
#define nsUDPSocketProvider_h__
#include "nsISocketProvider.h"
#include "mozilla/Attributes.h"
class nsUDPSocketProvider MOZ_FINAL : public nsISocketProvider
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSISOCKETPROVIDER
private:
~nsUDPSocketProvider();
};
#endif /* nsUDPSocketProvider_h__ */
--- a/netwerk/streamconv/converters/nsHTTPCompressConv.cpp
+++ b/netwerk/streamconv/converters/nsHTTPCompressConv.cpp
@@ -12,20 +12,20 @@
#include "nsCOMPtr.h"
#include "nsReadableUtils.h"
#include "nsError.h"
#include "nsStreamUtils.h"
#include "nsStringStream.h"
#include "nsComponentManagerUtils.h"
// nsISupports implementation
-NS_IMPL_THREADSAFE_ISUPPORTS3(nsHTTPCompressConv,
- nsIStreamConverter,
- nsIStreamListener,
- nsIRequestObserver)
+NS_IMPL_ISUPPORTS3(nsHTTPCompressConv,
+ nsIStreamConverter,
+ nsIStreamListener,
+ nsIRequestObserver)
// nsFTPDirListingConv methods
nsHTTPCompressConv::nsHTTPCompressConv()
: mListener(nullptr)
, mMode(HTTP_COMPRESS_IDENTITY)
, mOutBuffer(NULL)
, mInpBuffer(NULL)
, mOutBufferLen(0)
--- a/netwerk/streamconv/converters/nsHTTPCompressConv.h
+++ b/netwerk/streamconv/converters/nsHTTPCompressConv.h
@@ -35,17 +35,17 @@ typedef enum {
HTTP_COMPRESS_DEFLATE,
HTTP_COMPRESS_COMPRESS,
HTTP_COMPRESS_IDENTITY
} CompressMode;
class nsHTTPCompressConv : public nsIStreamConverter {
public:
// nsISupports methods
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIREQUESTOBSERVER
NS_DECL_NSISTREAMLISTENER
// nsIStreamConverter methods
NS_DECL_NSISTREAMCONVERTER
--- a/netwerk/system/win32/nsNotifyAddrListener.cpp
+++ b/netwerk/system/win32/nsNotifyAddrListener.cpp
@@ -46,20 +46,20 @@ static void FreeDynamicLibraries(void)
{
if (sNetshell) {
sNcFreeNetconProperties = nullptr;
FreeLibrary(sNetshell);
sNetshell = nullptr;
}
}
-NS_IMPL_THREADSAFE_ISUPPORTS3(nsNotifyAddrListener,
- nsINetworkLinkService,
- nsIRunnable,
- nsIObserver)
+NS_IMPL_ISUPPORTS3(nsNotifyAddrListener,
+ nsINetworkLinkService,
+ nsIRunnable,
+ nsIObserver)
nsNotifyAddrListener::nsNotifyAddrListener()
: mLinkUp(true) // assume true by default
, mStatusKnown(false)
, mCheckAttempted(false)
, mShutdownEvent(nullptr)
{
}
--- a/netwerk/system/win32/nsNotifyAddrListener.h
+++ b/netwerk/system/win32/nsNotifyAddrListener.h
@@ -15,17 +15,17 @@
#include "nsThreadUtils.h"
#include "nsCOMPtr.h"
class nsNotifyAddrListener : public nsINetworkLinkService,
public nsIRunnable,
public nsIObserver
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSINETWORKLINKSERVICE
NS_DECL_NSIRUNNABLE
NS_DECL_NSIOBSERVER
nsNotifyAddrListener();
virtual ~nsNotifyAddrListener();
nsresult Init(void);
--- a/netwerk/test/TestCallbacks.cpp
+++ b/netwerk/test/TestCallbacks.cpp
@@ -40,32 +40,32 @@ public:
NS_DECLARE_STATIC_IID_ACCESSOR(NS_IEQUALS_IID)
NS_IMETHOD Equals(void *aPtr, bool *_retval) = 0;
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsIEquals, NS_IEQUALS_IID)
class ConsumerContext MOZ_FINAL : public nsIEquals {
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
ConsumerContext() { }
NS_IMETHOD Equals(void *aPtr, bool *_retval) {
*_retval = true;
if (aPtr != this) *_retval = false;
return NS_OK;
}
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(ConsumerContext, nsIEquals)
+NS_IMPL_ISUPPORTS1(ConsumerContext, nsIEquals)
class Consumer : public nsIStreamListener {
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIREQUESTOBSERVER
NS_DECL_NSISTREAMLISTENER
Consumer();
virtual ~Consumer();
nsresult Init(nsIURI *aURI, nsIChannel *aChannel, nsISupports *aContext);
nsresult Validate(nsIRequest *request, nsISupports *aContext);
@@ -74,17 +74,17 @@ public:
bool mOnStop; // have we received an onStop?
int32_t mOnDataCount; // number of times OnData was called.
nsCOMPtr<nsIURI> mURI;
nsCOMPtr<nsIChannel> mChannel;
nsCOMPtr<nsIEquals> mContext;
};
// nsISupports implementation
-NS_IMPL_THREADSAFE_ISUPPORTS2(Consumer, nsIStreamListener, nsIRequestObserver)
+NS_IMPL_ISUPPORTS2(Consumer, nsIStreamListener, nsIRequestObserver)
// nsIRequestObserver implementation
NS_IMETHODIMP
Consumer::OnStartRequest(nsIRequest *request, nsISupports* aContext) {
fprintf(stderr, "Consumer::OnStart() -> in\n\n");
if (mOnStart) {
--- a/netwerk/test/TestCommon.h
+++ b/netwerk/test/TestCommon.h
@@ -15,23 +15,23 @@ inline int test_common_init(int *argc, c
}
//-----------------------------------------------------------------------------
static bool gKeepPumpingEvents = false;
class nsQuitPumpingEvent MOZ_FINAL : public nsIRunnable {
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_IMETHOD Run() {
gKeepPumpingEvents = false;
return NS_OK;
}
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsQuitPumpingEvent, nsIRunnable)
+NS_IMPL_ISUPPORTS1(nsQuitPumpingEvent, nsIRunnable)
static inline void PumpEvents()
{
nsCOMPtr<nsIThread> thread = do_GetCurrentThread();
gKeepPumpingEvents = true;
while (gKeepPumpingEvents)
NS_ProcessNextEvent(thread);
--- a/netwerk/test/TestDNS.cpp
+++ b/netwerk/test/TestDNS.cpp
@@ -17,17 +17,17 @@
#include "prthread.h"
#include "prnetdb.h"
#include "nsXPCOM.h"
#include "nsServiceManagerUtils.h"
class myDNSListener : public nsIDNSListener
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
myDNSListener(const char *host, int32_t index)
: mHost(host)
, mIndex(index) {}
virtual ~myDNSListener() {}
NS_IMETHOD OnLookupComplete(nsICancelable *request,
nsIDNSRecord *rec,
@@ -52,17 +52,17 @@ public:
return NS_OK;
}
private:
nsCString mHost;
int32_t mIndex;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(myDNSListener, nsIDNSListener)
+NS_IMPL_ISUPPORTS1(myDNSListener, nsIDNSListener)
static bool IsAscii(const char *s)
{
for (; *s; ++s) {
if (*s & 0x80)
return false;
}
--- a/netwerk/test/TestHttp.cpp
+++ b/netwerk/test/TestHttp.cpp
@@ -83,27 +83,27 @@ MyListener::OnDataAvailable(nsIRequest *
//-----------------------------------------------------------------------------
// NotificationCallbacks implementation
//-----------------------------------------------------------------------------
class MyNotifications : public nsIInterfaceRequestor
, public nsIProgressEventSink
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIINTERFACEREQUESTOR
NS_DECL_NSIPROGRESSEVENTSINK
MyNotifications() { }
virtual ~MyNotifications() {}
};
-NS_IMPL_THREADSAFE_ISUPPORTS2(MyNotifications,
- nsIInterfaceRequestor,
- nsIProgressEventSink)
+NS_IMPL_ISUPPORTS2(MyNotifications,
+ nsIInterfaceRequestor,
+ nsIProgressEventSink)
NS_IMETHODIMP
MyNotifications::GetInterface(const nsIID &iid, void **result)
{
return QueryInterface(iid, result);
}
NS_IMETHODIMP
--- a/netwerk/test/TestIOThreads.cpp
+++ b/netwerk/test/TestIOThreads.cpp
@@ -16,29 +16,29 @@
// set NSPR_LOG_MODULES=Test:5
//
static PRLogModuleInfo *gTestLog = nullptr;
#endif
#define LOG(args) PR_LOG(gTestLog, PR_LOG_DEBUG, args)
class nsIOEvent : public nsIRunnable {
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
nsIOEvent(int i) : mIndex(i) {}
NS_IMETHOD Run() {
LOG(("Run [%d]\n", mIndex));
return NS_OK;
}
private:
int mIndex;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsIOEvent, nsIRunnable)
+NS_IMPL_ISUPPORTS1(nsIOEvent, nsIRunnable)
static nsresult RunTest()
{
nsresult rv;
nsCOMPtr<nsIEventTarget> target =
do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID, &rv);
if (NS_FAILED(rv))
return rv;
--- a/netwerk/test/TestPageLoad.cpp
+++ b/netwerk/test/TestPageLoad.cpp
@@ -191,27 +191,27 @@ MyListener::OnDataAvailable(nsIRequest *
//-----------------------------------------------------------------------------
// NotificationCallbacks implementation
//-----------------------------------------------------------------------------
class MyNotifications : public nsIInterfaceRequestor
, public nsIProgressEventSink
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIINTERFACEREQUESTOR
NS_DECL_NSIPROGRESSEVENTSINK
MyNotifications() { }
virtual ~MyNotifications() {}
};
-NS_IMPL_THREADSAFE_ISUPPORTS2(MyNotifications,
- nsIInterfaceRequestor,
- nsIProgressEventSink)
+NS_IMPL_ISUPPORTS2(MyNotifications,
+ nsIInterfaceRequestor,
+ nsIProgressEventSink)
NS_IMETHODIMP
MyNotifications::GetInterface(const nsIID &iid, void **result)
{
return QueryInterface(iid, result);
}
NS_IMETHODIMP
--- a/netwerk/test/TestProtocols.cpp
+++ b/netwerk/test/TestProtocols.cpp
@@ -191,17 +191,17 @@ HeaderVisitor::VisitHeader(const nsACStr
class URLLoadInfo : public nsISupports
{
public:
URLLoadInfo(const char* aUrl);
virtual ~URLLoadInfo();
// ISupports interface...
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
const char* Name() { return mURLString.get(); }
int64_t mBytesRead;
PRTime mTotalTime;
PRTime mConnectTime;
nsCString mURLString;
};
@@ -211,17 +211,17 @@ URLLoadInfo::URLLoadInfo(const char *aUr
mConnectTime = mTotalTime = PR_Now();
}
URLLoadInfo::~URLLoadInfo()
{
}
-NS_IMPL_THREADSAFE_ISUPPORTS0(URLLoadInfo)
+NS_IMPL_ISUPPORTS0(URLLoadInfo)
//-----------------------------------------------------------------------------
// TestChannelEventSink
//-----------------------------------------------------------------------------
class TestChannelEventSink : public nsIChannelEventSink
{
public:
--- a/netwerk/test/TestServ.cpp
+++ b/netwerk/test/TestServ.cpp
@@ -19,24 +19,24 @@
//
static PRLogModuleInfo *gTestLog = nullptr;
#endif
#define LOG(args) PR_LOG(gTestLog, PR_LOG_DEBUG, args)
class MySocketListener : public nsIServerSocketListener
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSISERVERSOCKETLISTENER
MySocketListener() {}
virtual ~MySocketListener() {}
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(MySocketListener, nsIServerSocketListener)
+NS_IMPL_ISUPPORTS1(MySocketListener, nsIServerSocketListener)
NS_IMETHODIMP
MySocketListener::OnSocketAccepted(nsIServerSocket *serv,
nsISocketTransport *trans)
{
LOG(("MySocketListener::OnSocketAccepted [serv=%p trans=%p]\n", serv, trans));
nsAutoCString host;
--- a/netwerk/test/TestSocketTransport.cpp
+++ b/netwerk/test/TestSocketTransport.cpp
@@ -40,17 +40,17 @@ static PRLogModuleInfo *gTestLog = nullp
static NS_DEFINE_CID(kSocketTransportServiceCID, NS_SOCKETTRANSPORTSERVICE_CID);
////////////////////////////////////////////////////////////////////////////////
class MyHandler : public nsIOutputStreamCallback
, public nsIInputStreamCallback
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
MyHandler(const char *path,
nsIAsyncInputStream *in,
nsIAsyncOutputStream *out)
: mInput(in)
, mOutput(out)
, mWriteOffset(0)
{
@@ -110,19 +110,19 @@ public:
private:
nsCOMPtr<nsIAsyncInputStream> mInput;
nsCOMPtr<nsIAsyncOutputStream> mOutput;
nsCString mBuf;
uint32_t mWriteOffset;
};
-NS_IMPL_THREADSAFE_ISUPPORTS2(MyHandler,
- nsIOutputStreamCallback,
- nsIInputStreamCallback)
+NS_IMPL_ISUPPORTS2(MyHandler,
+ nsIOutputStreamCallback,
+ nsIInputStreamCallback)
////////////////////////////////////////////////////////////////////////////////
/**
* create transport, open streams, and close
*/
static nsresult
RunCloseTest(nsISocketTransportService *sts,
--- a/netwerk/test/TestStreamTransport.cpp
+++ b/netwerk/test/TestStreamTransport.cpp
@@ -40,17 +40,17 @@ static NS_DEFINE_CID(kStreamTransportSer
////////////////////////////////////////////////////////////////////////////////
#define CHUNK_SIZE 500
class MyCopier : public nsIInputStreamCallback
, public nsIOutputStreamCallback
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
MyCopier()
: mLock(nullptr)
, mInputCondition(NS_OK)
{
}
virtual ~MyCopier()
@@ -157,19 +157,19 @@ public:
protected:
PRLock *mLock;
nsCOMPtr<nsIAsyncInputStream> mInput;
nsCOMPtr<nsIAsyncOutputStream> mOutput;
nsresult mInputCondition;
};
-NS_IMPL_THREADSAFE_ISUPPORTS2(MyCopier,
- nsIInputStreamCallback,
- nsIOutputStreamCallback)
+NS_IMPL_ISUPPORTS2(MyCopier,
+ nsIInputStreamCallback,
+ nsIOutputStreamCallback)
////////////////////////////////////////////////////////////////////////////////
/**
* asynchronously copy file.
*/
static nsresult
RunTest(nsIFile *srcFile, nsIFile *destFile)
--- a/netwerk/test/TestUDPServerSocket.cpp
+++ b/netwerk/test/TestUDPServerSocket.cpp
@@ -40,26 +40,26 @@
PR_END_MACRO
/*
* UDPListener: listens for incomming UDP packets
*/
class UDPListener : public nsIUDPServerSocketListener
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIUDPSERVERSOCKETLISTENER
virtual ~UDPListener();
nsresult mResult;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(UDPListener,
- nsIUDPServerSocketListener)
+NS_IMPL_ISUPPORTS1(UDPListener,
+ nsIUDPServerSocketListener)
UDPListener::~UDPListener()
{
}
NS_IMETHODIMP
UDPListener::OnPacketReceived(nsIUDPServerSocket* socket, nsIUDPMessage* message)
{
--- a/netwerk/wifi/nsWifiAccessPoint.cpp
+++ b/netwerk/wifi/nsWifiAccessPoint.cpp
@@ -8,17 +8,17 @@
#include "prlog.h"
#if defined(PR_LOGGING)
extern PRLogModuleInfo *gWifiMonitorLog;
#endif
#define LOG(args) PR_LOG(gWifiMonitorLog, PR_LOG_DEBUG, args)
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsWifiAccessPoint, nsIWifiAccessPoint)
+NS_IMPL_ISUPPORTS1(nsWifiAccessPoint, nsIWifiAccessPoint)
nsWifiAccessPoint::nsWifiAccessPoint()
{
// make sure these are null terminated (because we are paranoid)
mMac[0] = '\0';
mSsid[0] = '\0';
mSsidLen = 0;
}
--- a/netwerk/wifi/nsWifiAccessPoint.h
+++ b/netwerk/wifi/nsWifiAccessPoint.h
@@ -10,17 +10,17 @@
#include "mozilla/Attributes.h"
#ifndef __nsWifiAccessPoint__
#define __nsWifiAccessPoint__
class nsWifiAccessPoint MOZ_FINAL : public nsIWifiAccessPoint
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIWIFIACCESSPOINT
nsWifiAccessPoint();
~nsWifiAccessPoint();
char mMac[18];
int mSignal;
char mSsid[33];
--- a/netwerk/wifi/nsWifiMonitor.cpp
+++ b/netwerk/wifi/nsWifiMonitor.cpp
@@ -19,20 +19,20 @@
#include "mozilla/Services.h"
using namespace mozilla;
#if defined(PR_LOGGING)
PRLogModuleInfo *gWifiMonitorLog;
#endif
-NS_IMPL_THREADSAFE_ISUPPORTS3(nsWifiMonitor,
- nsIRunnable,
- nsIObserver,
- nsIWifiMonitor)
+NS_IMPL_ISUPPORTS3(nsWifiMonitor,
+ nsIRunnable,
+ nsIObserver,
+ nsIWifiMonitor)
nsWifiMonitor::nsWifiMonitor()
: mKeepGoing(true)
, mReentrantMonitor("nsWifiMonitor.mReentrantMonitor")
{
#if defined(PR_LOGGING)
gWifiMonitorLog = PR_NewLogModule("WifiMonitor");
#endif
@@ -112,32 +112,32 @@ NS_IMETHODIMP nsWifiMonitor::StopWatchin
return NS_OK;
}
typedef nsTArray<nsMainThreadPtrHandle<nsIWifiListener> > WifiListenerArray;
class nsPassErrorToWifiListeners MOZ_FINAL : public nsIRunnable
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIRUNNABLE
nsPassErrorToWifiListeners(nsAutoPtr<WifiListenerArray> aListeners,
nsresult aResult)
: mListeners(aListeners),
mResult(aResult)
{}
private:
nsAutoPtr<WifiListenerArray> mListeners;
nsresult mResult;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsPassErrorToWifiListeners,
- nsIRunnable)
+NS_IMPL_ISUPPORTS1(nsPassErrorToWifiListeners,
+ nsIRunnable)
NS_IMETHODIMP nsPassErrorToWifiListeners::Run()
{
LOG(("About to send error to the wifi listeners\n"));
for (size_t i = 0; i < mListeners->Length(); i++) {
(*mListeners)[i]->OnError(mResult);
}
return NS_OK;
@@ -172,32 +172,32 @@ NS_IMETHODIMP nsWifiMonitor::Run()
}
return NS_OK;
}
class nsCallWifiListeners MOZ_FINAL : public nsIRunnable
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIRUNNABLE
nsCallWifiListeners(nsAutoPtr<WifiListenerArray> aListeners,
nsAutoPtr<nsTArray<nsIWifiAccessPoint*> > aAccessPoints)
: mListeners(aListeners),
mAccessPoints(aAccessPoints)
{}
private:
nsAutoPtr<WifiListenerArray> mListeners;
nsAutoPtr<nsTArray<nsIWifiAccessPoint*> > mAccessPoints;
};
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsCallWifiListeners,
- nsIRunnable)
+NS_IMPL_ISUPPORTS1(nsCallWifiListeners,
+ nsIRunnable)
NS_IMETHODIMP nsCallWifiListeners::Run()
{
LOG(("About to send data to the wifi listeners\n"));
for (size_t i = 0; i < mListeners->Length(); i++) {
(*mListeners)[i]->OnChange(mAccessPoints->Elements(), mAccessPoints->Length());
}
return NS_OK;
--- a/netwerk/wifi/nsWifiMonitor.h
+++ b/netwerk/wifi/nsWifiMonitor.h
@@ -42,17 +42,17 @@ class nsWifiListener
nsMainThreadPtrHandle<nsIWifiListener> mListener;
bool mHasSentData;
};
#ifndef MOZ_WIDGET_GONK
class nsWifiMonitor MOZ_FINAL : nsIRunnable, nsIWifiMonitor, nsIObserver
{
public:
- NS_DECL_ISUPPORTS
+ NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIWIFIMONITOR
NS_DECL_NSIRUNNABLE
NS_DECL_NSIOBSERVER
nsWifiMonitor();
private:
~nsWifiMonitor();