gecko-dev/xpcom/glue/nsEnumeratorUtils.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

292 lines
6.1 KiB
C++

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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/Attributes.h"
#include "nsEnumeratorUtils.h"
#include "nsISimpleEnumerator.h"
#include "nsIStringEnumerator.h"
#include "nsCOMPtr.h"
#include "mozilla/RefPtr.h"
class EmptyEnumeratorImpl
: public nsISimpleEnumerator
, public nsIUTF8StringEnumerator
, public nsIStringEnumerator
{
public:
EmptyEnumeratorImpl() {}
// nsISupports interface
NS_DECL_ISUPPORTS_INHERITED // not really inherited, but no mRefCnt
// nsISimpleEnumerator
NS_DECL_NSISIMPLEENUMERATOR
NS_DECL_NSIUTF8STRINGENUMERATOR
// can't use NS_DECL_NSISTRINGENUMERATOR because they share the
// HasMore() signature
NS_IMETHOD GetNext(nsAString& aResult) override;
static EmptyEnumeratorImpl* GetInstance()
{
static const EmptyEnumeratorImpl kInstance;
return const_cast<EmptyEnumeratorImpl*>(&kInstance);
}
};
// nsISupports interface
NS_IMETHODIMP_(MozExternalRefCountType)
EmptyEnumeratorImpl::AddRef(void)
{
return 2;
}
NS_IMETHODIMP_(MozExternalRefCountType)
EmptyEnumeratorImpl::Release(void)
{
return 1;
}
NS_IMPL_QUERY_INTERFACE(EmptyEnumeratorImpl, nsISimpleEnumerator,
nsIUTF8StringEnumerator, nsIStringEnumerator)
// nsISimpleEnumerator interface
NS_IMETHODIMP
EmptyEnumeratorImpl::HasMoreElements(bool* aResult)
{
*aResult = false;
return NS_OK;
}
NS_IMETHODIMP
EmptyEnumeratorImpl::HasMore(bool* aResult)
{
*aResult = false;
return NS_OK;
}
NS_IMETHODIMP
EmptyEnumeratorImpl::GetNext(nsISupports** aResult)
{
return NS_ERROR_UNEXPECTED;
}
NS_IMETHODIMP
EmptyEnumeratorImpl::GetNext(nsACString& aResult)
{
return NS_ERROR_UNEXPECTED;
}
NS_IMETHODIMP
EmptyEnumeratorImpl::GetNext(nsAString& aResult)
{
return NS_ERROR_UNEXPECTED;
}
nsresult
NS_NewEmptyEnumerator(nsISimpleEnumerator** aResult)
{
*aResult = EmptyEnumeratorImpl::GetInstance();
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
class nsSingletonEnumerator final : public nsISimpleEnumerator
{
public:
NS_DECL_ISUPPORTS
// nsISimpleEnumerator methods
NS_IMETHOD HasMoreElements(bool* aResult) override;
NS_IMETHOD GetNext(nsISupports** aResult) override;
explicit nsSingletonEnumerator(nsISupports* aValue);
private:
~nsSingletonEnumerator();
protected:
nsCOMPtr<nsISupports> mValue;
bool mConsumed;
};
nsSingletonEnumerator::nsSingletonEnumerator(nsISupports* aValue)
: mValue(aValue)
{
mConsumed = (mValue ? false : true);
}
nsSingletonEnumerator::~nsSingletonEnumerator()
{
}
NS_IMPL_ISUPPORTS(nsSingletonEnumerator, nsISimpleEnumerator)
NS_IMETHODIMP
nsSingletonEnumerator::HasMoreElements(bool* aResult)
{
NS_PRECONDITION(aResult != 0, "null ptr");
if (!aResult) {
return NS_ERROR_NULL_POINTER;
}
*aResult = !mConsumed;
return NS_OK;
}
NS_IMETHODIMP
nsSingletonEnumerator::GetNext(nsISupports** aResult)
{
NS_PRECONDITION(aResult != 0, "null ptr");
if (!aResult) {
return NS_ERROR_NULL_POINTER;
}
if (mConsumed) {
return NS_ERROR_UNEXPECTED;
}
mConsumed = true;
*aResult = mValue;
NS_ADDREF(*aResult);
return NS_OK;
}
nsresult
NS_NewSingletonEnumerator(nsISimpleEnumerator** aResult,
nsISupports* aSingleton)
{
RefPtr<nsSingletonEnumerator> enumer = new nsSingletonEnumerator(aSingleton);
enumer.forget(aResult);
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
class nsUnionEnumerator final : public nsISimpleEnumerator
{
public:
NS_DECL_ISUPPORTS
// nsISimpleEnumerator methods
NS_IMETHOD HasMoreElements(bool* aResult) override;
NS_IMETHOD GetNext(nsISupports** aResult) override;
nsUnionEnumerator(nsISimpleEnumerator* aFirstEnumerator,
nsISimpleEnumerator* aSecondEnumerator);
private:
~nsUnionEnumerator();
protected:
nsCOMPtr<nsISimpleEnumerator> mFirstEnumerator, mSecondEnumerator;
bool mConsumed;
bool mAtSecond;
};
nsUnionEnumerator::nsUnionEnumerator(nsISimpleEnumerator* aFirstEnumerator,
nsISimpleEnumerator* aSecondEnumerator)
: mFirstEnumerator(aFirstEnumerator)
, mSecondEnumerator(aSecondEnumerator)
, mConsumed(false)
, mAtSecond(false)
{
}
nsUnionEnumerator::~nsUnionEnumerator()
{
}
NS_IMPL_ISUPPORTS(nsUnionEnumerator, nsISimpleEnumerator)
NS_IMETHODIMP
nsUnionEnumerator::HasMoreElements(bool* aResult)
{
NS_PRECONDITION(aResult != 0, "null ptr");
if (!aResult) {
return NS_ERROR_NULL_POINTER;
}
nsresult rv;
if (mConsumed) {
*aResult = false;
return NS_OK;
}
if (!mAtSecond) {
rv = mFirstEnumerator->HasMoreElements(aResult);
if (NS_FAILED(rv)) {
return rv;
}
if (*aResult) {
return NS_OK;
}
mAtSecond = true;
}
rv = mSecondEnumerator->HasMoreElements(aResult);
if (NS_FAILED(rv)) {
return rv;
}
if (*aResult) {
return NS_OK;
}
*aResult = false;
mConsumed = true;
return NS_OK;
}
NS_IMETHODIMP
nsUnionEnumerator::GetNext(nsISupports** aResult)
{
NS_PRECONDITION(aResult != 0, "null ptr");
if (!aResult) {
return NS_ERROR_NULL_POINTER;
}
if (mConsumed) {
return NS_ERROR_UNEXPECTED;
}
if (!mAtSecond) {
return mFirstEnumerator->GetNext(aResult);
}
return mSecondEnumerator->GetNext(aResult);
}
nsresult
NS_NewUnionEnumerator(nsISimpleEnumerator** aResult,
nsISimpleEnumerator* aFirstEnumerator,
nsISimpleEnumerator* aSecondEnumerator)
{
*aResult = nullptr;
if (!aFirstEnumerator) {
*aResult = aSecondEnumerator;
} else if (!aSecondEnumerator) {
*aResult = aFirstEnumerator;
} else {
nsUnionEnumerator* enumer = new nsUnionEnumerator(aFirstEnumerator,
aSecondEnumerator);
if (!enumer) {
return NS_ERROR_OUT_OF_MEMORY;
}
*aResult = enumer;
}
NS_ADDREF(*aResult);
return NS_OK;
}