gecko-dev/netwerk/base/nsTransportUtils.cpp
Nathan Froyd 01583602a9 Bug 1207245 - part 6 - rename nsRefPtr<T> to RefPtr<T>; r=ehsan; a=Tomcat
The bulk of this commit was generated with a script, executed at the top
level of a typical source code checkout.  The only non-machine-generated
part was modifying MFBT's moz.build to reflect the new naming.

CLOSED TREE makes big refactorings like this a piece of cake.

 # The main substitution.
find . -name '*.cpp' -o -name '*.cc' -o -name '*.h' -o -name '*.mm' -o -name '*.idl'| \
    xargs perl -p -i -e '
 s/nsRefPtr\.h/RefPtr\.h/g; # handle includes
 s/nsRefPtr ?</RefPtr</g;   # handle declarations and variables
'

 # Handle a special friend declaration in gfx/layers/AtomicRefCountedWithFinalize.h.
perl -p -i -e 's/::nsRefPtr;/::RefPtr;/' gfx/layers/AtomicRefCountedWithFinalize.h

 # Handle nsRefPtr.h itself, a couple places that define constructors
 # from nsRefPtr, and code generators specially.  We do this here, rather
 # than indiscriminantly s/nsRefPtr/RefPtr/, because that would rename
 # things like nsRefPtrHashtable.
perl -p -i -e 's/nsRefPtr/RefPtr/g' \
     mfbt/nsRefPtr.h \
     xpcom/glue/nsCOMPtr.h \
     xpcom/base/OwningNonNull.h \
     ipc/ipdl/ipdl/lower.py \
     ipc/ipdl/ipdl/builtin.py \
     dom/bindings/Codegen.py \
     python/lldbutils/lldbutils/utils.py

 # In our indiscriminate substitution above, we renamed
 # nsRefPtrGetterAddRefs, the class behind getter_AddRefs.  Fix that up.
find . -name '*.cpp' -o -name '*.h' -o -name '*.idl' | \
    xargs perl -p -i -e 's/nsRefPtrGetterAddRefs/RefPtrGetterAddRefs/g'

if [ -d .git ]; then
    git mv mfbt/nsRefPtr.h mfbt/RefPtr.h
else
    hg mv mfbt/nsRefPtr.h mfbt/RefPtr.h
fi

--HG--
rename : mfbt/nsRefPtr.h => mfbt/RefPtr.h
2015-10-18 01:24:48 -04:00

143 lines
4.3 KiB
C++

/* 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 "mozilla/Mutex.h"
#include "nsTransportUtils.h"
#include "nsITransport.h"
#include "nsProxyRelease.h"
#include "nsThreadUtils.h"
#include "nsAutoPtr.h"
#include "nsCOMPtr.h"
using namespace mozilla;
//-----------------------------------------------------------------------------
class nsTransportStatusEvent;
class nsTransportEventSinkProxy : public nsITransportEventSink
{
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSITRANSPORTEVENTSINK
nsTransportEventSinkProxy(nsITransportEventSink *sink,
nsIEventTarget *target)
: mSink(sink)
, mTarget(target)
, mLock("nsTransportEventSinkProxy.mLock")
, mLastEvent(nullptr)
{
NS_ADDREF(mSink);
}
private:
virtual ~nsTransportEventSinkProxy()
{
// our reference to mSink could be the last, so be sure to release
// it on the target thread. otherwise, we could get into trouble.
NS_ProxyRelease(mTarget, mSink);
}
public:
nsITransportEventSink *mSink;
nsCOMPtr<nsIEventTarget> mTarget;
Mutex mLock;
nsTransportStatusEvent *mLastEvent;
};
class nsTransportStatusEvent : public nsRunnable
{
public:
nsTransportStatusEvent(nsTransportEventSinkProxy *proxy,
nsITransport *transport,
nsresult status,
int64_t progress,
int64_t progressMax)
: mProxy(proxy)
, mTransport(transport)
, mStatus(status)
, mProgress(progress)
, mProgressMax(progressMax)
{}
~nsTransportStatusEvent() {}
NS_IMETHOD Run()
{
// since this event is being handled, we need to clear the proxy's ref.
// if not coalescing all, then last event may not equal self!
{
MutexAutoLock lock(mProxy->mLock);
if (mProxy->mLastEvent == this)
mProxy->mLastEvent = nullptr;
}
mProxy->mSink->OnTransportStatus(mTransport, mStatus, mProgress,
mProgressMax);
return NS_OK;
}
RefPtr<nsTransportEventSinkProxy> mProxy;
// parameters to OnTransportStatus
nsCOMPtr<nsITransport> mTransport;
nsresult mStatus;
int64_t mProgress;
int64_t mProgressMax;
};
NS_IMPL_ISUPPORTS(nsTransportEventSinkProxy, nsITransportEventSink)
NS_IMETHODIMP
nsTransportEventSinkProxy::OnTransportStatus(nsITransport *transport,
nsresult status,
int64_t progress,
int64_t progressMax)
{
nsresult rv = NS_OK;
RefPtr<nsTransportStatusEvent> event;
{
MutexAutoLock lock(mLock);
// try to coalesce events! ;-)
if (mLastEvent && (mLastEvent->mStatus == status)) {
mLastEvent->mStatus = status;
mLastEvent->mProgress = progress;
mLastEvent->mProgressMax = progressMax;
}
else {
event = new nsTransportStatusEvent(this, transport, status,
progress, progressMax);
if (!event)
rv = NS_ERROR_OUT_OF_MEMORY;
mLastEvent = event; // weak ref
}
}
if (event) {
rv = mTarget->Dispatch(event, NS_DISPATCH_NORMAL);
if (NS_FAILED(rv)) {
NS_WARNING("unable to post transport status event");
MutexAutoLock lock(mLock); // cleanup.. don't reference anymore!
mLastEvent = nullptr;
}
}
return rv;
}
//-----------------------------------------------------------------------------
nsresult
net_NewTransportEventSinkProxy(nsITransportEventSink **result,
nsITransportEventSink *sink,
nsIEventTarget *target)
{
*result = new nsTransportEventSinkProxy(sink, target);
if (!*result)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(*result);
return NS_OK;
}