mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-10 11:54:40 +00:00
1426 lines
37 KiB
C++
1426 lines
37 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/. */
|
|
|
|
#ifndef nsCOMPtr_h___
|
|
#define nsCOMPtr_h___
|
|
|
|
/*
|
|
* Having problems?
|
|
*
|
|
* See the User Manual at:
|
|
* http://www.mozilla.org/projects/xpcom/nsCOMPtr.html
|
|
*
|
|
*
|
|
* nsCOMPtr
|
|
* better than a raw pointer
|
|
* for owning objects
|
|
* -- scc
|
|
*/
|
|
|
|
#include "mozilla/AlreadyAddRefed.h"
|
|
#include "mozilla/Assertions.h"
|
|
#include "mozilla/Attributes.h"
|
|
#include "mozilla/Move.h"
|
|
#include "mozilla/TypeTraits.h"
|
|
|
|
#include "nsDebug.h" // for |NS_ASSERTION|
|
|
#include "nsISupportsUtils.h" // for |nsresult|, |NS_ADDREF|, |NS_GET_TEMPLATE_IID| et al
|
|
#include "mozilla/RefPtr.h"
|
|
|
|
#include "nsCycleCollectionNoteChild.h"
|
|
|
|
|
|
/*
|
|
* WARNING: This file defines several macros for internal use only. These
|
|
* macros begin with the prefix |NSCAP_|. Do not use these macros in your own
|
|
* code. They are for internal use only for cross-platform compatibility, and
|
|
* are subject to change without notice.
|
|
*/
|
|
|
|
|
|
#ifdef _MSC_VER
|
|
// Under VC++, we win by inlining StartAssignment.
|
|
#define NSCAP_FEATURE_INLINE_STARTASSIGNMENT
|
|
|
|
// Also under VC++, at the highest warning level, we are overwhelmed with
|
|
// warnings about (unused) inline functions being removed. This is to be
|
|
// expected with templates, so we disable the warning.
|
|
#pragma warning( disable: 4514 )
|
|
#endif
|
|
|
|
#define NSCAP_FEATURE_USE_BASE
|
|
|
|
#ifdef DEBUG
|
|
#define NSCAP_FEATURE_TEST_DONTQUERY_CASES
|
|
#undef NSCAP_FEATURE_USE_BASE
|
|
//#define NSCAP_FEATURE_TEST_NONNULL_QUERY_SUCCEEDS
|
|
#endif
|
|
|
|
#ifdef __GNUC__
|
|
// Our use of nsCOMPtr_base::mRawPtr violates the C++ standard's aliasing
|
|
// rules. Mark it with the may_alias attribute so that gcc 3.3 and higher
|
|
// don't reorder instructions based on aliasing assumptions for
|
|
// this variable. Fortunately, gcc versions < 3.3 do not do any
|
|
// optimizations that break nsCOMPtr.
|
|
|
|
#define NS_MAY_ALIAS_PTR(t) t* __attribute__((__may_alias__))
|
|
#else
|
|
#define NS_MAY_ALIAS_PTR(t) t*
|
|
#endif
|
|
|
|
#if defined(NSCAP_DISABLE_DEBUG_PTR_TYPES)
|
|
#define NSCAP_FEATURE_USE_BASE
|
|
#endif
|
|
|
|
/*
|
|
* The following three macros (NSCAP_ADDREF, NSCAP_RELEASE, and
|
|
* NSCAP_LOG_ASSIGNMENT) allow external clients the ability to add logging or
|
|
* other interesting debug facilities. In fact, if you want |nsCOMPtr| to
|
|
* participate in the standard logging facility, you provide
|
|
* (e.g., in "nsISupportsImpl.h") suitable definitions
|
|
*
|
|
* #define NSCAP_ADDREF(this, ptr) NS_ADDREF(ptr)
|
|
* #define NSCAP_RELEASE(this, ptr) NS_RELEASE(ptr)
|
|
*/
|
|
|
|
#ifndef NSCAP_ADDREF
|
|
#define NSCAP_ADDREF(this, ptr) (ptr)->AddRef()
|
|
#endif
|
|
|
|
#ifndef NSCAP_RELEASE
|
|
#define NSCAP_RELEASE(this, ptr) (ptr)->Release()
|
|
#endif
|
|
|
|
// Clients can define |NSCAP_LOG_ASSIGNMENT| to perform logging.
|
|
#ifdef NSCAP_LOG_ASSIGNMENT
|
|
// Remember that |NSCAP_LOG_ASSIGNMENT| was defined by some client so that we
|
|
// know to instantiate |~nsGetterAddRefs| in turn to note the external
|
|
// assignment into the |nsCOMPtr|.
|
|
#define NSCAP_LOG_EXTERNAL_ASSIGNMENT
|
|
#else
|
|
// ...otherwise, just strip it out of the code
|
|
#define NSCAP_LOG_ASSIGNMENT(this, ptr)
|
|
#endif
|
|
|
|
#ifndef NSCAP_LOG_RELEASE
|
|
#define NSCAP_LOG_RELEASE(this, ptr)
|
|
#endif
|
|
|
|
namespace mozilla {
|
|
template<class T> class OwningNonNull;
|
|
} // namespace mozilla
|
|
|
|
template<class T>
|
|
inline already_AddRefed<T>
|
|
dont_AddRef(T* aRawPtr)
|
|
{
|
|
return already_AddRefed<T>(aRawPtr);
|
|
}
|
|
|
|
template<class T>
|
|
inline already_AddRefed<T>&&
|
|
dont_AddRef(already_AddRefed<T>&& aAlreadyAddRefedPtr)
|
|
{
|
|
return mozilla::Move(aAlreadyAddRefedPtr);
|
|
}
|
|
|
|
|
|
/*
|
|
* An nsCOMPtr_helper transforms commonly called getters into typesafe forms
|
|
* that are more convenient to call, and more efficient to use with |nsCOMPtr|s.
|
|
* Good candidates for helpers are |QueryInterface()|, |CreateInstance()|, etc.
|
|
*
|
|
* Here are the rules for a helper:
|
|
* - it implements |operator()| to produce an interface pointer
|
|
* - (except for its name) |operator()| is a valid [XP]COM `getter'
|
|
* - the interface pointer that it returns is already |AddRef()|ed (as from
|
|
* any good getter)
|
|
* - it matches the type requested with the supplied |nsIID| argument
|
|
* - its constructor provides an optional |nsresult*| that |operator()| can
|
|
* fill in with an error when it is executed
|
|
*
|
|
* See |class nsGetInterface| for an example.
|
|
*/
|
|
class MOZ_STACK_CLASS nsCOMPtr_helper
|
|
{
|
|
public:
|
|
virtual nsresult NS_FASTCALL operator()(const nsIID&, void**) const = 0;
|
|
};
|
|
|
|
/*
|
|
* nsQueryInterface could have been implemented as an nsCOMPtr_helper to avoid
|
|
* adding specialized machinery in nsCOMPtr, but do_QueryInterface is called
|
|
* often enough that the codesize savings are big enough to warrant the
|
|
* specialcasing.
|
|
*/
|
|
class MOZ_STACK_CLASS nsQueryInterface final
|
|
{
|
|
public:
|
|
explicit
|
|
nsQueryInterface(nsISupports* aRawPtr) : mRawPtr(aRawPtr) {}
|
|
|
|
nsresult NS_FASTCALL operator()(const nsIID& aIID, void**) const;
|
|
|
|
private:
|
|
nsISupports* MOZ_OWNING_REF mRawPtr;
|
|
};
|
|
|
|
class nsQueryInterfaceWithError final
|
|
{
|
|
public:
|
|
nsQueryInterfaceWithError(nsISupports* aRawPtr, nsresult* aError)
|
|
: mRawPtr(aRawPtr)
|
|
, mErrorPtr(aError)
|
|
{
|
|
}
|
|
|
|
nsresult NS_FASTCALL operator()(const nsIID& aIID, void**) const;
|
|
|
|
private:
|
|
nsISupports* MOZ_OWNING_REF mRawPtr;
|
|
nsresult* mErrorPtr;
|
|
};
|
|
|
|
inline nsQueryInterface
|
|
do_QueryInterface(nsISupports* aRawPtr)
|
|
{
|
|
return nsQueryInterface(aRawPtr);
|
|
}
|
|
|
|
inline nsQueryInterfaceWithError
|
|
do_QueryInterface(nsISupports* aRawPtr, nsresult* aError)
|
|
{
|
|
return nsQueryInterfaceWithError(aRawPtr, aError);
|
|
}
|
|
|
|
template<class T>
|
|
inline void
|
|
do_QueryInterface(already_AddRefed<T>&)
|
|
{
|
|
// This signature exists solely to _stop_ you from doing the bad thing.
|
|
// Saying |do_QueryInterface()| on a pointer that is not otherwise owned by
|
|
// someone else is an automatic leak. See bug 8221.
|
|
}
|
|
|
|
template<class T>
|
|
inline void
|
|
do_QueryInterface(already_AddRefed<T>&, nsresult*)
|
|
{
|
|
// This signature exists solely to _stop_ you from doing the bad thing.
|
|
// Saying |do_QueryInterface()| on a pointer that is not otherwise owned by
|
|
// someone else is an automatic leak. See bug 8221.
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// Using servicemanager with COMPtrs
|
|
class nsGetServiceByCID final
|
|
{
|
|
public:
|
|
explicit nsGetServiceByCID(const nsCID& aCID) : mCID(aCID) {}
|
|
|
|
nsresult NS_FASTCALL operator()(const nsIID&, void**) const;
|
|
|
|
private:
|
|
const nsCID& mCID;
|
|
};
|
|
|
|
class nsGetServiceByCIDWithError final
|
|
{
|
|
public:
|
|
nsGetServiceByCIDWithError(const nsCID& aCID, nsresult* aErrorPtr)
|
|
: mCID(aCID)
|
|
, mErrorPtr(aErrorPtr)
|
|
{
|
|
}
|
|
|
|
nsresult NS_FASTCALL operator()(const nsIID&, void**) const;
|
|
|
|
private:
|
|
const nsCID& mCID;
|
|
nsresult* mErrorPtr;
|
|
};
|
|
|
|
class nsGetServiceByContractID final
|
|
{
|
|
public:
|
|
explicit nsGetServiceByContractID(const char* aContractID)
|
|
: mContractID(aContractID)
|
|
{
|
|
}
|
|
|
|
nsresult NS_FASTCALL operator()(const nsIID&, void**) const;
|
|
|
|
private:
|
|
const char* mContractID;
|
|
};
|
|
|
|
class nsGetServiceByContractIDWithError final
|
|
{
|
|
public:
|
|
nsGetServiceByContractIDWithError(const char* aContractID, nsresult* aErrorPtr)
|
|
: mContractID(aContractID)
|
|
, mErrorPtr(aErrorPtr)
|
|
{
|
|
}
|
|
|
|
nsresult NS_FASTCALL operator()(const nsIID&, void**) const;
|
|
|
|
private:
|
|
const char* mContractID;
|
|
nsresult* mErrorPtr;
|
|
};
|
|
|
|
/**
|
|
* Factors implementation for all template versions of nsCOMPtr.
|
|
*
|
|
* Here's the way people normally do things like this:
|
|
*
|
|
* template<class T> class Foo { ... };
|
|
* template<> class Foo<void*> { ... };
|
|
* template<class T> class Foo<T*> : private Foo<void*> { ... };
|
|
*/
|
|
class nsCOMPtr_base
|
|
{
|
|
public:
|
|
explicit nsCOMPtr_base(nsISupports* aRawPtr = 0) : mRawPtr(aRawPtr) {}
|
|
|
|
NS_CONSTRUCTOR_FASTCALL ~nsCOMPtr_base()
|
|
{
|
|
NSCAP_LOG_RELEASE(this, mRawPtr);
|
|
if (mRawPtr) {
|
|
NSCAP_RELEASE(this, mRawPtr);
|
|
}
|
|
}
|
|
|
|
void NS_FASTCALL
|
|
assign_with_AddRef(nsISupports*);
|
|
void NS_FASTCALL
|
|
assign_from_qi(const nsQueryInterface, const nsIID&);
|
|
void NS_FASTCALL
|
|
assign_from_qi_with_error(const nsQueryInterfaceWithError&, const nsIID&);
|
|
void NS_FASTCALL
|
|
assign_from_gs_cid(const nsGetServiceByCID, const nsIID&);
|
|
void NS_FASTCALL
|
|
assign_from_gs_cid_with_error(const nsGetServiceByCIDWithError&, const nsIID&);
|
|
void NS_FASTCALL
|
|
assign_from_gs_contractid(const nsGetServiceByContractID, const nsIID&);
|
|
void NS_FASTCALL
|
|
assign_from_gs_contractid_with_error(const nsGetServiceByContractIDWithError&,
|
|
const nsIID&);
|
|
void NS_FASTCALL
|
|
assign_from_helper(const nsCOMPtr_helper&, const nsIID&);
|
|
void** NS_FASTCALL
|
|
begin_assignment();
|
|
|
|
protected:
|
|
NS_MAY_ALIAS_PTR(nsISupports) MOZ_OWNING_REF mRawPtr;
|
|
|
|
void assign_assuming_AddRef(nsISupports* aNewPtr)
|
|
{
|
|
// |AddRef()|ing the new value (before entering this function) before
|
|
// |Release()|ing the old lets us safely ignore the self-assignment case.
|
|
// We must, however, be careful only to |Release()| _after_ doing the
|
|
// assignment, in case the |Release()| leads to our _own_ destruction,
|
|
// which would, in turn, cause an incorrect second |Release()| of our old
|
|
// pointer. Thank <waterson@netscape.com> for discovering this.
|
|
nsISupports* oldPtr = mRawPtr;
|
|
mRawPtr = aNewPtr;
|
|
NSCAP_LOG_ASSIGNMENT(this, aNewPtr);
|
|
NSCAP_LOG_RELEASE(this, oldPtr);
|
|
if (oldPtr) {
|
|
NSCAP_RELEASE(this, oldPtr);
|
|
}
|
|
}
|
|
};
|
|
|
|
// template<class T> class nsGetterAddRefs;
|
|
|
|
// Helper for assert_validity method
|
|
template<class T>
|
|
char (&TestForIID(decltype(&NS_GET_TEMPLATE_IID(T))))[2];
|
|
template<class T>
|
|
char TestForIID(...);
|
|
|
|
template<class T>
|
|
class nsCOMPtr final
|
|
#ifdef NSCAP_FEATURE_USE_BASE
|
|
: private nsCOMPtr_base
|
|
#endif
|
|
{
|
|
|
|
#ifdef NSCAP_FEATURE_USE_BASE
|
|
#define NSCAP_CTOR_BASE(x) nsCOMPtr_base(x)
|
|
#else
|
|
#define NSCAP_CTOR_BASE(x) mRawPtr(x)
|
|
|
|
private:
|
|
void assign_with_AddRef(nsISupports*);
|
|
void assign_from_qi(const nsQueryInterface, const nsIID&);
|
|
void assign_from_qi_with_error(const nsQueryInterfaceWithError&, const nsIID&);
|
|
void assign_from_gs_cid(const nsGetServiceByCID, const nsIID&);
|
|
void assign_from_gs_cid_with_error(const nsGetServiceByCIDWithError&,
|
|
const nsIID&);
|
|
void assign_from_gs_contractid(const nsGetServiceByContractID, const nsIID&);
|
|
void assign_from_gs_contractid_with_error(
|
|
const nsGetServiceByContractIDWithError&, const nsIID&);
|
|
void assign_from_helper(const nsCOMPtr_helper&, const nsIID&);
|
|
void** begin_assignment();
|
|
|
|
void assign_assuming_AddRef(T* aNewPtr)
|
|
{
|
|
T* oldPtr = mRawPtr;
|
|
mRawPtr = aNewPtr;
|
|
NSCAP_LOG_ASSIGNMENT(this, aNewPtr);
|
|
NSCAP_LOG_RELEASE(this, oldPtr);
|
|
if (oldPtr) {
|
|
NSCAP_RELEASE(this, oldPtr);
|
|
}
|
|
}
|
|
|
|
private:
|
|
T* MOZ_OWNING_REF mRawPtr;
|
|
#endif
|
|
|
|
void assert_validity()
|
|
{
|
|
static_assert(1 < sizeof(TestForIID<T>(nullptr)), "nsCOMPtr only works "
|
|
"for types with IIDs. Either use RefPtr; add an IID to "
|
|
"your type with NS_DECLARE_STATIC_IID_ACCESSOR/"
|
|
"NS_DEFINE_STATIC_IID_ACCESSOR; or make the nsCOMPtr point "
|
|
"to a base class with an IID.");
|
|
}
|
|
|
|
public:
|
|
typedef T element_type;
|
|
|
|
#ifndef NSCAP_FEATURE_USE_BASE
|
|
~nsCOMPtr()
|
|
{
|
|
NSCAP_LOG_RELEASE(this, mRawPtr);
|
|
if (mRawPtr) {
|
|
NSCAP_RELEASE(this, mRawPtr);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef NSCAP_FEATURE_TEST_DONTQUERY_CASES
|
|
void Assert_NoQueryNeeded()
|
|
{
|
|
if (mRawPtr) {
|
|
nsCOMPtr<T> query_result(do_QueryInterface(mRawPtr));
|
|
NS_ASSERTION(query_result.get() == mRawPtr, "QueryInterface needed");
|
|
}
|
|
}
|
|
|
|
#define NSCAP_ASSERT_NO_QUERY_NEEDED() Assert_NoQueryNeeded();
|
|
#else
|
|
#define NSCAP_ASSERT_NO_QUERY_NEEDED()
|
|
#endif
|
|
|
|
|
|
// Constructors
|
|
|
|
nsCOMPtr()
|
|
: NSCAP_CTOR_BASE(0)
|
|
{
|
|
assert_validity();
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
}
|
|
|
|
nsCOMPtr(const nsCOMPtr<T>& aSmartPtr)
|
|
: NSCAP_CTOR_BASE(aSmartPtr.mRawPtr)
|
|
{
|
|
assert_validity();
|
|
if (mRawPtr) {
|
|
NSCAP_ADDREF(this, mRawPtr);
|
|
}
|
|
NSCAP_LOG_ASSIGNMENT(this, aSmartPtr.mRawPtr);
|
|
}
|
|
|
|
MOZ_IMPLICIT nsCOMPtr(T* aRawPtr)
|
|
: NSCAP_CTOR_BASE(aRawPtr)
|
|
{
|
|
assert_validity();
|
|
if (mRawPtr) {
|
|
NSCAP_ADDREF(this, mRawPtr);
|
|
}
|
|
NSCAP_LOG_ASSIGNMENT(this, aRawPtr);
|
|
NSCAP_ASSERT_NO_QUERY_NEEDED();
|
|
}
|
|
|
|
MOZ_IMPLICIT nsCOMPtr(already_AddRefed<T>& aSmartPtr)
|
|
: NSCAP_CTOR_BASE(aSmartPtr.take())
|
|
{
|
|
assert_validity();
|
|
NSCAP_LOG_ASSIGNMENT(this, mRawPtr);
|
|
NSCAP_ASSERT_NO_QUERY_NEEDED();
|
|
}
|
|
|
|
// Construct from |otherComPtr.forget()|.
|
|
MOZ_IMPLICIT nsCOMPtr(already_AddRefed<T>&& aSmartPtr)
|
|
: NSCAP_CTOR_BASE(aSmartPtr.take())
|
|
{
|
|
assert_validity();
|
|
NSCAP_LOG_ASSIGNMENT(this, mRawPtr);
|
|
NSCAP_ASSERT_NO_QUERY_NEEDED();
|
|
}
|
|
|
|
// Construct from |already_AddRefed|.
|
|
template<typename U>
|
|
MOZ_IMPLICIT nsCOMPtr(already_AddRefed<U>& aSmartPtr)
|
|
: NSCAP_CTOR_BASE(static_cast<T*>(aSmartPtr.take()))
|
|
{
|
|
assert_validity();
|
|
// But make sure that U actually inherits from T.
|
|
static_assert(mozilla::IsBaseOf<T, U>::value,
|
|
"U is not a subclass of T");
|
|
NSCAP_LOG_ASSIGNMENT(this, static_cast<T*>(mRawPtr));
|
|
NSCAP_ASSERT_NO_QUERY_NEEDED();
|
|
}
|
|
|
|
// Construct from |otherComPtr.forget()|.
|
|
template<typename U>
|
|
MOZ_IMPLICIT nsCOMPtr(already_AddRefed<U>&& aSmartPtr)
|
|
: NSCAP_CTOR_BASE(static_cast<T*>(aSmartPtr.take()))
|
|
{
|
|
assert_validity();
|
|
// But make sure that U actually inherits from T.
|
|
static_assert(mozilla::IsBaseOf<T, U>::value,
|
|
"U is not a subclass of T");
|
|
NSCAP_LOG_ASSIGNMENT(this, static_cast<T*>(mRawPtr));
|
|
NSCAP_ASSERT_NO_QUERY_NEEDED();
|
|
}
|
|
|
|
// Construct from |do_QueryInterface(expr)|.
|
|
MOZ_IMPLICIT nsCOMPtr(const nsQueryInterface aQI)
|
|
: NSCAP_CTOR_BASE(0)
|
|
{
|
|
assert_validity();
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
assign_from_qi(aQI, NS_GET_TEMPLATE_IID(T));
|
|
}
|
|
|
|
// Construct from |do_QueryInterface(expr, &rv)|.
|
|
MOZ_IMPLICIT nsCOMPtr(const nsQueryInterfaceWithError& aQI)
|
|
: NSCAP_CTOR_BASE(0)
|
|
{
|
|
assert_validity();
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
assign_from_qi_with_error(aQI, NS_GET_TEMPLATE_IID(T));
|
|
}
|
|
|
|
// Construct from |do_GetService(cid_expr)|.
|
|
MOZ_IMPLICIT nsCOMPtr(const nsGetServiceByCID aGS)
|
|
: NSCAP_CTOR_BASE(0)
|
|
{
|
|
assert_validity();
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
assign_from_gs_cid(aGS, NS_GET_TEMPLATE_IID(T));
|
|
}
|
|
|
|
// Construct from |do_GetService(cid_expr, &rv)|.
|
|
MOZ_IMPLICIT nsCOMPtr(const nsGetServiceByCIDWithError& aGS)
|
|
: NSCAP_CTOR_BASE(0)
|
|
{
|
|
assert_validity();
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
assign_from_gs_cid_with_error(aGS, NS_GET_TEMPLATE_IID(T));
|
|
}
|
|
|
|
// Construct from |do_GetService(contractid_expr)|.
|
|
MOZ_IMPLICIT nsCOMPtr(const nsGetServiceByContractID aGS)
|
|
: NSCAP_CTOR_BASE(0)
|
|
{
|
|
assert_validity();
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
assign_from_gs_contractid(aGS, NS_GET_TEMPLATE_IID(T));
|
|
}
|
|
|
|
// Construct from |do_GetService(contractid_expr, &rv)|.
|
|
MOZ_IMPLICIT nsCOMPtr(const nsGetServiceByContractIDWithError& aGS)
|
|
: NSCAP_CTOR_BASE(0)
|
|
{
|
|
assert_validity();
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
assign_from_gs_contractid_with_error(aGS, NS_GET_TEMPLATE_IID(T));
|
|
}
|
|
|
|
// And finally, anything else we might need to construct from can exploit the
|
|
// nsCOMPtr_helper facility.
|
|
MOZ_IMPLICIT nsCOMPtr(const nsCOMPtr_helper& aHelper)
|
|
: NSCAP_CTOR_BASE(0)
|
|
{
|
|
assert_validity();
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
assign_from_helper(aHelper, NS_GET_TEMPLATE_IID(T));
|
|
NSCAP_ASSERT_NO_QUERY_NEEDED();
|
|
}
|
|
|
|
// Defined in OwningNonNull.h
|
|
template<class U>
|
|
MOZ_IMPLICIT nsCOMPtr(const mozilla::OwningNonNull<U>& aOther);
|
|
|
|
|
|
// Assignment operators
|
|
|
|
nsCOMPtr<T>& operator=(const nsCOMPtr<T>& aRhs)
|
|
{
|
|
assign_with_AddRef(aRhs.mRawPtr);
|
|
return *this;
|
|
}
|
|
|
|
nsCOMPtr<T>& operator=(T* aRhs)
|
|
{
|
|
assign_with_AddRef(aRhs);
|
|
NSCAP_ASSERT_NO_QUERY_NEEDED();
|
|
return *this;
|
|
}
|
|
|
|
// Assign from |already_AddRefed|.
|
|
template<typename U>
|
|
nsCOMPtr<T>& operator=(already_AddRefed<U>& aRhs)
|
|
{
|
|
// Make sure that U actually inherits from T
|
|
static_assert(mozilla::IsBaseOf<T, U>::value,
|
|
"U is not a subclass of T");
|
|
assign_assuming_AddRef(static_cast<T*>(aRhs.take()));
|
|
NSCAP_ASSERT_NO_QUERY_NEEDED();
|
|
return *this;
|
|
}
|
|
|
|
// Assign from |otherComPtr.forget()|.
|
|
template<typename U>
|
|
nsCOMPtr<T>& operator=(already_AddRefed<U>&& aRhs)
|
|
{
|
|
// Make sure that U actually inherits from T
|
|
static_assert(mozilla::IsBaseOf<T, U>::value,
|
|
"U is not a subclass of T");
|
|
assign_assuming_AddRef(static_cast<T*>(aRhs.take()));
|
|
NSCAP_ASSERT_NO_QUERY_NEEDED();
|
|
return *this;
|
|
}
|
|
|
|
// Assign from |do_QueryInterface(expr)|.
|
|
nsCOMPtr<T>& operator=(const nsQueryInterface aRhs)
|
|
{
|
|
assign_from_qi(aRhs, NS_GET_TEMPLATE_IID(T));
|
|
return *this;
|
|
}
|
|
|
|
// Assign from |do_QueryInterface(expr, &rv)|.
|
|
nsCOMPtr<T>& operator=(const nsQueryInterfaceWithError& aRhs)
|
|
{
|
|
assign_from_qi_with_error(aRhs, NS_GET_TEMPLATE_IID(T));
|
|
return *this;
|
|
}
|
|
|
|
// Assign from |do_GetService(cid_expr)|.
|
|
nsCOMPtr<T>& operator=(const nsGetServiceByCID aRhs)
|
|
{
|
|
assign_from_gs_cid(aRhs, NS_GET_TEMPLATE_IID(T));
|
|
return *this;
|
|
}
|
|
|
|
// Assign from |do_GetService(cid_expr, &rv)|.
|
|
nsCOMPtr<T>& operator=(const nsGetServiceByCIDWithError& aRhs)
|
|
{
|
|
assign_from_gs_cid_with_error(aRhs, NS_GET_TEMPLATE_IID(T));
|
|
return *this;
|
|
}
|
|
|
|
// Assign from |do_GetService(contractid_expr)|.
|
|
nsCOMPtr<T>& operator=(const nsGetServiceByContractID aRhs)
|
|
{
|
|
assign_from_gs_contractid(aRhs, NS_GET_TEMPLATE_IID(T));
|
|
return *this;
|
|
}
|
|
|
|
// Assign from |do_GetService(contractid_expr, &rv)|.
|
|
nsCOMPtr<T>& operator=(const nsGetServiceByContractIDWithError& aRhs)
|
|
{
|
|
assign_from_gs_contractid_with_error(aRhs, NS_GET_TEMPLATE_IID(T));
|
|
return *this;
|
|
}
|
|
|
|
// And finally, anything else we might need to assign from can exploit the
|
|
// nsCOMPtr_helper facility.
|
|
nsCOMPtr<T>& operator=(const nsCOMPtr_helper& aRhs)
|
|
{
|
|
assign_from_helper(aRhs, NS_GET_TEMPLATE_IID(T));
|
|
NSCAP_ASSERT_NO_QUERY_NEEDED();
|
|
return *this;
|
|
}
|
|
|
|
// Defined in OwningNonNull.h
|
|
template<class U>
|
|
nsCOMPtr<T>& operator=(const mozilla::OwningNonNull<U>& aOther);
|
|
|
|
// Exchange ownership with |aRhs|; can save a pair of refcount operations.
|
|
void swap(nsCOMPtr<T>& aRhs)
|
|
{
|
|
#ifdef NSCAP_FEATURE_USE_BASE
|
|
nsISupports* temp = aRhs.mRawPtr;
|
|
#else
|
|
T* temp = aRhs.mRawPtr;
|
|
#endif
|
|
NSCAP_LOG_ASSIGNMENT(&aRhs, mRawPtr);
|
|
NSCAP_LOG_ASSIGNMENT(this, temp);
|
|
NSCAP_LOG_RELEASE(this, mRawPtr);
|
|
NSCAP_LOG_RELEASE(&aRhs, temp);
|
|
aRhs.mRawPtr = mRawPtr;
|
|
mRawPtr = temp;
|
|
// |aRhs| maintains the same invariants, so we don't need to |NSCAP_ASSERT_NO_QUERY_NEEDED|
|
|
}
|
|
|
|
// Exchange ownership with |aRhs|; can save a pair of refcount operations.
|
|
void swap(T*& aRhs)
|
|
{
|
|
#ifdef NSCAP_FEATURE_USE_BASE
|
|
nsISupports* temp = aRhs;
|
|
#else
|
|
T* temp = aRhs;
|
|
#endif
|
|
NSCAP_LOG_ASSIGNMENT(this, temp);
|
|
NSCAP_LOG_RELEASE(this, mRawPtr);
|
|
aRhs = reinterpret_cast<T*>(mRawPtr);
|
|
mRawPtr = temp;
|
|
NSCAP_ASSERT_NO_QUERY_NEEDED();
|
|
}
|
|
|
|
|
|
// Other pointer operators
|
|
|
|
// Return the value of mRawPtr and null out mRawPtr. Useful for
|
|
// already_AddRefed return values.
|
|
already_AddRefed<T> forget()
|
|
{
|
|
T* temp = 0;
|
|
swap(temp);
|
|
return already_AddRefed<T>(temp);
|
|
}
|
|
|
|
// Set the target of aRhs to the value of mRawPtr and null out mRawPtr.
|
|
// Useful to avoid unnecessary AddRef/Release pairs with "out" parameters
|
|
// where aRhs bay be a T** or an I** where I is a base class of T.
|
|
template<typename I>
|
|
void forget(I** aRhs)
|
|
{
|
|
NS_ASSERTION(aRhs, "Null pointer passed to forget!");
|
|
NSCAP_LOG_RELEASE(this, mRawPtr);
|
|
*aRhs = get();
|
|
mRawPtr = 0;
|
|
}
|
|
|
|
// Prefer the implicit conversion provided automatically by
|
|
// |operator T*() const|. Use |get()| to resolve ambiguity or to get a
|
|
// castable pointer.
|
|
T* get() const { return reinterpret_cast<T*>(mRawPtr); }
|
|
|
|
// Makes an nsCOMPtr act like its underlying raw pointer type whenever it is
|
|
// used in a context where a raw pointer is expected. It is this operator
|
|
// that makes an nsCOMPtr substitutable for a raw pointer.
|
|
//
|
|
// Prefer the implicit use of this operator to calling |get()|, except where
|
|
// necessary to resolve ambiguity.
|
|
operator T*() const { return get(); }
|
|
|
|
T* operator->() const MOZ_NO_ADDREF_RELEASE_ON_RETURN
|
|
{
|
|
MOZ_ASSERT(mRawPtr != 0,
|
|
"You can't dereference a NULL nsCOMPtr with operator->().");
|
|
return get();
|
|
}
|
|
|
|
// These are not intended to be used by clients. See |address_of| below.
|
|
nsCOMPtr<T>* get_address() { return this; }
|
|
const nsCOMPtr<T>* get_address() const { return this; }
|
|
|
|
public:
|
|
T& operator*() const
|
|
{
|
|
MOZ_ASSERT(mRawPtr != 0,
|
|
"You can't dereference a NULL nsCOMPtr with operator*().");
|
|
return *get();
|
|
}
|
|
|
|
T** StartAssignment()
|
|
{
|
|
#ifndef NSCAP_FEATURE_INLINE_STARTASSIGNMENT
|
|
return reinterpret_cast<T**>(begin_assignment());
|
|
#else
|
|
assign_assuming_AddRef(0);
|
|
return reinterpret_cast<T**>(&mRawPtr);
|
|
#endif
|
|
}
|
|
};
|
|
|
|
|
|
/*
|
|
* Specializing nsCOMPtr for nsISupports allows us to use nsCOMPtr<nsISupports>
|
|
* the same way people use nsISupports* and void*, i.e., as a `catch-all'
|
|
* pointing to any valid [XP]COM interface. Otherwise, an nsCOMPtr<nsISupports>
|
|
* would only be able to point to the single [XP]COM-correct nsISupports
|
|
* instance within an object; extra querying ensues. Clients need to be able to
|
|
* pass around arbitrary interface pointers, without hassles, through
|
|
* intermediary code that doesn't know the exact type.
|
|
*/
|
|
template<>
|
|
class nsCOMPtr<nsISupports>
|
|
: private nsCOMPtr_base
|
|
{
|
|
public:
|
|
typedef nsISupports element_type;
|
|
|
|
// Constructors
|
|
|
|
nsCOMPtr()
|
|
: nsCOMPtr_base(0)
|
|
{
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
}
|
|
|
|
nsCOMPtr(const nsCOMPtr<nsISupports>& aSmartPtr)
|
|
: nsCOMPtr_base(aSmartPtr.mRawPtr)
|
|
{
|
|
if (mRawPtr) {
|
|
NSCAP_ADDREF(this, mRawPtr);
|
|
}
|
|
NSCAP_LOG_ASSIGNMENT(this, aSmartPtr.mRawPtr);
|
|
}
|
|
|
|
MOZ_IMPLICIT nsCOMPtr(nsISupports* aRawPtr)
|
|
: nsCOMPtr_base(aRawPtr)
|
|
{
|
|
if (mRawPtr) {
|
|
NSCAP_ADDREF(this, mRawPtr);
|
|
}
|
|
NSCAP_LOG_ASSIGNMENT(this, aRawPtr);
|
|
}
|
|
|
|
// Construct from |already_AddRefed|.
|
|
MOZ_IMPLICIT nsCOMPtr(already_AddRefed<nsISupports>& aSmartPtr)
|
|
: nsCOMPtr_base(aSmartPtr.take())
|
|
{
|
|
NSCAP_LOG_ASSIGNMENT(this, mRawPtr);
|
|
}
|
|
|
|
// Construct from |otherComPtr.forget()|.
|
|
MOZ_IMPLICIT nsCOMPtr(already_AddRefed<nsISupports>&& aSmartPtr)
|
|
: nsCOMPtr_base(aSmartPtr.take())
|
|
{
|
|
NSCAP_LOG_ASSIGNMENT(this, mRawPtr);
|
|
}
|
|
|
|
// Construct from |do_QueryInterface(expr)|.
|
|
MOZ_IMPLICIT nsCOMPtr(const nsQueryInterface aQI)
|
|
: nsCOMPtr_base(0)
|
|
{
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
assign_from_qi(aQI, NS_GET_IID(nsISupports));
|
|
}
|
|
|
|
// Construct from |do_QueryInterface(expr, &rv)|.
|
|
MOZ_IMPLICIT nsCOMPtr(const nsQueryInterfaceWithError& aQI)
|
|
: nsCOMPtr_base(0)
|
|
{
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
assign_from_qi_with_error(aQI, NS_GET_IID(nsISupports));
|
|
}
|
|
|
|
// Construct from |do_GetService(cid_expr)|.
|
|
MOZ_IMPLICIT nsCOMPtr(const nsGetServiceByCID aGS)
|
|
: nsCOMPtr_base(0)
|
|
{
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
assign_from_gs_cid(aGS, NS_GET_IID(nsISupports));
|
|
}
|
|
|
|
// Construct from |do_GetService(cid_expr, &rv)|.
|
|
MOZ_IMPLICIT nsCOMPtr(const nsGetServiceByCIDWithError& aGS)
|
|
: nsCOMPtr_base(0)
|
|
{
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
assign_from_gs_cid_with_error(aGS, NS_GET_IID(nsISupports));
|
|
}
|
|
|
|
// Construct from |do_GetService(contractid_expr)|.
|
|
MOZ_IMPLICIT nsCOMPtr(const nsGetServiceByContractID aGS)
|
|
: nsCOMPtr_base(0)
|
|
{
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
assign_from_gs_contractid(aGS, NS_GET_IID(nsISupports));
|
|
}
|
|
|
|
// Construct from |do_GetService(contractid_expr, &rv)|.
|
|
MOZ_IMPLICIT nsCOMPtr(const nsGetServiceByContractIDWithError& aGS)
|
|
: nsCOMPtr_base(0)
|
|
{
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
assign_from_gs_contractid_with_error(aGS, NS_GET_IID(nsISupports));
|
|
}
|
|
|
|
// And finally, anything else we might need to construct from can exploit
|
|
// the |nsCOMPtr_helper| facility
|
|
MOZ_IMPLICIT nsCOMPtr(const nsCOMPtr_helper& aHelper)
|
|
: nsCOMPtr_base(0)
|
|
{
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
assign_from_helper(aHelper, NS_GET_IID(nsISupports));
|
|
}
|
|
|
|
|
|
// Assignment operators
|
|
|
|
nsCOMPtr<nsISupports>& operator=(const nsCOMPtr<nsISupports>& aRhs)
|
|
{
|
|
assign_with_AddRef(aRhs.mRawPtr);
|
|
return *this;
|
|
}
|
|
|
|
nsCOMPtr<nsISupports>& operator=(nsISupports* aRhs)
|
|
{
|
|
assign_with_AddRef(aRhs);
|
|
return *this;
|
|
}
|
|
|
|
// Assign from |already_AddRefed|.
|
|
nsCOMPtr<nsISupports>& operator=(already_AddRefed<nsISupports>& aRhs)
|
|
{
|
|
assign_assuming_AddRef(aRhs.take());
|
|
return *this;
|
|
}
|
|
|
|
// Assign from |otherComPtr.forget()|.
|
|
nsCOMPtr<nsISupports>& operator=(already_AddRefed<nsISupports>&& aRhs)
|
|
{
|
|
assign_assuming_AddRef(aRhs.take());
|
|
return *this;
|
|
}
|
|
|
|
// Assign from |do_QueryInterface(expr)|.
|
|
nsCOMPtr<nsISupports>& operator=(const nsQueryInterface aRhs)
|
|
{
|
|
assign_from_qi(aRhs, NS_GET_IID(nsISupports));
|
|
return *this;
|
|
}
|
|
|
|
// Assign from |do_QueryInterface(expr, &rv)|.
|
|
nsCOMPtr<nsISupports>& operator=(const nsQueryInterfaceWithError& aRhs)
|
|
{
|
|
assign_from_qi_with_error(aRhs, NS_GET_IID(nsISupports));
|
|
return *this;
|
|
}
|
|
|
|
// Assign from |do_GetService(cid_expr)|.
|
|
nsCOMPtr<nsISupports>& operator=(const nsGetServiceByCID aRhs)
|
|
{
|
|
assign_from_gs_cid(aRhs, NS_GET_IID(nsISupports));
|
|
return *this;
|
|
}
|
|
|
|
// Assign from |do_GetService(cid_expr, &rv)|.
|
|
nsCOMPtr<nsISupports>& operator=(const nsGetServiceByCIDWithError& aRhs)
|
|
{
|
|
assign_from_gs_cid_with_error(aRhs, NS_GET_IID(nsISupports));
|
|
return *this;
|
|
}
|
|
|
|
// Assign from |do_GetService(contractid_expr)|.
|
|
nsCOMPtr<nsISupports>& operator=(const nsGetServiceByContractID aRhs)
|
|
{
|
|
assign_from_gs_contractid(aRhs, NS_GET_IID(nsISupports));
|
|
return *this;
|
|
}
|
|
|
|
// Assign from |do_GetService(contractid_expr, &rv)|.
|
|
nsCOMPtr<nsISupports>& operator=(const nsGetServiceByContractIDWithError& aRhs)
|
|
{
|
|
assign_from_gs_contractid_with_error(aRhs, NS_GET_IID(nsISupports));
|
|
return *this;
|
|
}
|
|
|
|
// And finally, anything else we might need to assign from can exploit the
|
|
// nsCOMPtr_helper facility
|
|
nsCOMPtr<nsISupports>& operator=(const nsCOMPtr_helper& aRhs)
|
|
{
|
|
assign_from_helper(aRhs, NS_GET_IID(nsISupports));
|
|
return *this;
|
|
}
|
|
|
|
// Exchange ownership with |aRhs|; can save a pair of refcount operations.
|
|
void swap(nsCOMPtr<nsISupports>& aRhs)
|
|
{
|
|
nsISupports* temp = aRhs.mRawPtr;
|
|
NSCAP_LOG_ASSIGNMENT(&aRhs, mRawPtr);
|
|
NSCAP_LOG_ASSIGNMENT(this, temp);
|
|
NSCAP_LOG_RELEASE(this, mRawPtr);
|
|
NSCAP_LOG_RELEASE(&aRhs, temp);
|
|
aRhs.mRawPtr = mRawPtr;
|
|
mRawPtr = temp;
|
|
}
|
|
|
|
// Exchange ownership with |aRhs|; can save a pair of refcount operations.
|
|
void swap(nsISupports*& aRhs)
|
|
{
|
|
nsISupports* temp = aRhs;
|
|
NSCAP_LOG_ASSIGNMENT(this, temp);
|
|
NSCAP_LOG_RELEASE(this, mRawPtr);
|
|
aRhs = mRawPtr;
|
|
mRawPtr = temp;
|
|
}
|
|
|
|
// Return the value of mRawPtr and null out mRawPtr. Useful for
|
|
// already_AddRefed return values.
|
|
already_AddRefed<nsISupports> forget()
|
|
{
|
|
nsISupports* temp = 0;
|
|
swap(temp);
|
|
return already_AddRefed<nsISupports>(temp);
|
|
}
|
|
|
|
// Set the target of aRhs to the value of mRawPtr and null out mRawPtr.
|
|
// Useful to avoid unnecessary AddRef/Release pairs with "out"
|
|
// parameters.
|
|
void forget(nsISupports** aRhs)
|
|
{
|
|
NS_ASSERTION(aRhs, "Null pointer passed to forget!");
|
|
*aRhs = 0;
|
|
swap(*aRhs);
|
|
}
|
|
|
|
// Other pointer operators
|
|
|
|
// Prefer the implicit conversion provided automatically by
|
|
// |operator nsISupports*() const|. Use |get()| to resolve ambiguity or to
|
|
// get a castable pointer.
|
|
nsISupports* get() const { return reinterpret_cast<nsISupports*>(mRawPtr); }
|
|
|
|
// Makes an nsCOMPtr act like its underlying raw pointer type whenever it is
|
|
// used in a context where a raw pointer is expected. It is this operator
|
|
// that makes an nsCOMPtr substitutable for a raw pointer.
|
|
//
|
|
// Prefer the implicit use of this operator to calling |get()|, except where
|
|
// necessary to resolve ambiguity/
|
|
operator nsISupports* () const { return get(); }
|
|
|
|
nsISupports* operator->() const MOZ_NO_ADDREF_RELEASE_ON_RETURN
|
|
{
|
|
MOZ_ASSERT(mRawPtr != 0,
|
|
"You can't dereference a NULL nsCOMPtr with operator->().");
|
|
return get();
|
|
}
|
|
|
|
// These are not intended to be used by clients. See |address_of| below.
|
|
nsCOMPtr<nsISupports>* get_address() { return this; }
|
|
const nsCOMPtr<nsISupports>* get_address() const { return this; }
|
|
|
|
public:
|
|
|
|
nsISupports& operator*() const
|
|
{
|
|
MOZ_ASSERT(mRawPtr != 0,
|
|
"You can't dereference a NULL nsCOMPtr with operator*().");
|
|
return *get();
|
|
}
|
|
|
|
nsISupports** StartAssignment()
|
|
{
|
|
#ifndef NSCAP_FEATURE_INLINE_STARTASSIGNMENT
|
|
return reinterpret_cast<nsISupports**>(begin_assignment());
|
|
#else
|
|
assign_assuming_AddRef(0);
|
|
return reinterpret_cast<nsISupports**>(&mRawPtr);
|
|
#endif
|
|
}
|
|
};
|
|
|
|
template<typename T>
|
|
inline void
|
|
ImplCycleCollectionUnlink(nsCOMPtr<T>& aField)
|
|
{
|
|
aField = nullptr;
|
|
}
|
|
|
|
template<typename T>
|
|
inline void
|
|
ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
|
|
nsCOMPtr<T>& aField,
|
|
const char* aName,
|
|
uint32_t aFlags = 0)
|
|
{
|
|
CycleCollectionNoteChild(aCallback, aField.get(), aName, aFlags);
|
|
}
|
|
|
|
#ifndef NSCAP_FEATURE_USE_BASE
|
|
template<class T>
|
|
void
|
|
nsCOMPtr<T>::assign_with_AddRef(nsISupports* aRawPtr)
|
|
{
|
|
if (aRawPtr) {
|
|
NSCAP_ADDREF(this, aRawPtr);
|
|
}
|
|
assign_assuming_AddRef(reinterpret_cast<T*>(aRawPtr));
|
|
}
|
|
|
|
template<class T>
|
|
void
|
|
nsCOMPtr<T>::assign_from_qi(const nsQueryInterface aQI, const nsIID& aIID)
|
|
{
|
|
void* newRawPtr;
|
|
if (NS_FAILED(aQI(aIID, &newRawPtr))) {
|
|
newRawPtr = 0;
|
|
}
|
|
assign_assuming_AddRef(static_cast<T*>(newRawPtr));
|
|
}
|
|
|
|
template<class T>
|
|
void
|
|
nsCOMPtr<T>::assign_from_qi_with_error(const nsQueryInterfaceWithError& aQI,
|
|
const nsIID& aIID)
|
|
{
|
|
void* newRawPtr;
|
|
if (NS_FAILED(aQI(aIID, &newRawPtr))) {
|
|
newRawPtr = 0;
|
|
}
|
|
assign_assuming_AddRef(static_cast<T*>(newRawPtr));
|
|
}
|
|
|
|
template<class T>
|
|
void
|
|
nsCOMPtr<T>::assign_from_gs_cid(const nsGetServiceByCID aGS, const nsIID& aIID)
|
|
{
|
|
void* newRawPtr;
|
|
if (NS_FAILED(aGS(aIID, &newRawPtr))) {
|
|
newRawPtr = 0;
|
|
}
|
|
assign_assuming_AddRef(static_cast<T*>(newRawPtr));
|
|
}
|
|
|
|
template<class T>
|
|
void
|
|
nsCOMPtr<T>::assign_from_gs_cid_with_error(const nsGetServiceByCIDWithError& aGS,
|
|
const nsIID& aIID)
|
|
{
|
|
void* newRawPtr;
|
|
if (NS_FAILED(aGS(aIID, &newRawPtr))) {
|
|
newRawPtr = 0;
|
|
}
|
|
assign_assuming_AddRef(static_cast<T*>(newRawPtr));
|
|
}
|
|
|
|
template<class T>
|
|
void
|
|
nsCOMPtr<T>::assign_from_gs_contractid(const nsGetServiceByContractID aGS,
|
|
const nsIID& aIID)
|
|
{
|
|
void* newRawPtr;
|
|
if (NS_FAILED(aGS(aIID, &newRawPtr))) {
|
|
newRawPtr = 0;
|
|
}
|
|
assign_assuming_AddRef(static_cast<T*>(newRawPtr));
|
|
}
|
|
|
|
template<class T>
|
|
void
|
|
nsCOMPtr<T>::assign_from_gs_contractid_with_error(
|
|
const nsGetServiceByContractIDWithError& aGS, const nsIID& aIID)
|
|
{
|
|
void* newRawPtr;
|
|
if (NS_FAILED(aGS(aIID, &newRawPtr))) {
|
|
newRawPtr = 0;
|
|
}
|
|
assign_assuming_AddRef(static_cast<T*>(newRawPtr));
|
|
}
|
|
|
|
template<class T>
|
|
void
|
|
nsCOMPtr<T>::assign_from_helper(const nsCOMPtr_helper& helper, const nsIID& aIID)
|
|
{
|
|
void* newRawPtr;
|
|
if (NS_FAILED(helper(aIID, &newRawPtr))) {
|
|
newRawPtr = 0;
|
|
}
|
|
assign_assuming_AddRef(static_cast<T*>(newRawPtr));
|
|
}
|
|
|
|
template<class T>
|
|
void**
|
|
nsCOMPtr<T>::begin_assignment()
|
|
{
|
|
assign_assuming_AddRef(0);
|
|
union
|
|
{
|
|
T** mT;
|
|
void** mVoid;
|
|
} result;
|
|
result.mT = &mRawPtr;
|
|
return result.mVoid;
|
|
}
|
|
#endif
|
|
|
|
template<class T>
|
|
inline nsCOMPtr<T>*
|
|
address_of(nsCOMPtr<T>& aPtr)
|
|
{
|
|
return aPtr.get_address();
|
|
}
|
|
|
|
template<class T>
|
|
inline const nsCOMPtr<T>*
|
|
address_of(const nsCOMPtr<T>& aPtr)
|
|
{
|
|
return aPtr.get_address();
|
|
}
|
|
|
|
/**
|
|
* This class is designed to be used for anonymous temporary objects in the
|
|
* argument list of calls that return COM interface pointers, e.g.,
|
|
*
|
|
* nsCOMPtr<IFoo> fooP;
|
|
* ...->QueryInterface(iid, getter_AddRefs(fooP))
|
|
*
|
|
* DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE. Use |getter_AddRefs()| instead.
|
|
*
|
|
* When initialized with a |nsCOMPtr|, as in the example above, it returns
|
|
* a |void**|, a |T**|, or an |nsISupports**| as needed, that the outer call
|
|
* (|QueryInterface| in this case) can fill in.
|
|
*
|
|
* This type should be a nested class inside |nsCOMPtr<T>|.
|
|
*/
|
|
template<class T>
|
|
class nsGetterAddRefs
|
|
{
|
|
public:
|
|
explicit nsGetterAddRefs(nsCOMPtr<T>& aSmartPtr)
|
|
: mTargetSmartPtr(aSmartPtr)
|
|
{
|
|
}
|
|
|
|
#if defined(NSCAP_FEATURE_TEST_DONTQUERY_CASES) || defined(NSCAP_LOG_EXTERNAL_ASSIGNMENT)
|
|
~nsGetterAddRefs()
|
|
{
|
|
#ifdef NSCAP_LOG_EXTERNAL_ASSIGNMENT
|
|
NSCAP_LOG_ASSIGNMENT(reinterpret_cast<void*>(address_of(mTargetSmartPtr)),
|
|
mTargetSmartPtr.get());
|
|
#endif
|
|
|
|
#ifdef NSCAP_FEATURE_TEST_DONTQUERY_CASES
|
|
mTargetSmartPtr.Assert_NoQueryNeeded();
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
operator void**()
|
|
{
|
|
return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
|
|
}
|
|
|
|
operator T**() { return mTargetSmartPtr.StartAssignment(); }
|
|
T*& operator*() { return *(mTargetSmartPtr.StartAssignment()); }
|
|
|
|
private:
|
|
nsCOMPtr<T>& mTargetSmartPtr;
|
|
};
|
|
|
|
|
|
template<>
|
|
class nsGetterAddRefs<nsISupports>
|
|
{
|
|
public:
|
|
explicit nsGetterAddRefs(nsCOMPtr<nsISupports>& aSmartPtr)
|
|
: mTargetSmartPtr(aSmartPtr)
|
|
{
|
|
}
|
|
|
|
#ifdef NSCAP_LOG_EXTERNAL_ASSIGNMENT
|
|
~nsGetterAddRefs()
|
|
{
|
|
NSCAP_LOG_ASSIGNMENT(reinterpret_cast<void*>(address_of(mTargetSmartPtr)),
|
|
mTargetSmartPtr.get());
|
|
}
|
|
#endif
|
|
|
|
operator void**()
|
|
{
|
|
return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
|
|
}
|
|
|
|
operator nsISupports**() { return mTargetSmartPtr.StartAssignment(); }
|
|
nsISupports*& operator*() { return *(mTargetSmartPtr.StartAssignment()); }
|
|
|
|
private:
|
|
nsCOMPtr<nsISupports>& mTargetSmartPtr;
|
|
};
|
|
|
|
template<class T>
|
|
inline nsGetterAddRefs<T>
|
|
getter_AddRefs(nsCOMPtr<T>& aSmartPtr)
|
|
{
|
|
return nsGetterAddRefs<T>(aSmartPtr);
|
|
}
|
|
|
|
template<class T, class DestinationType>
|
|
inline nsresult
|
|
CallQueryInterface(T* aSource, nsGetterAddRefs<DestinationType> aDestination)
|
|
{
|
|
return CallQueryInterface(aSource,
|
|
static_cast<DestinationType**>(aDestination));
|
|
}
|
|
|
|
|
|
// Comparing two |nsCOMPtr|s
|
|
|
|
template<class T, class U>
|
|
inline bool
|
|
operator==(const nsCOMPtr<T>& aLhs, const nsCOMPtr<U>& aRhs)
|
|
{
|
|
return static_cast<const T*>(aLhs.get()) == static_cast<const U*>(aRhs.get());
|
|
}
|
|
|
|
|
|
template<class T, class U>
|
|
inline bool
|
|
operator!=(const nsCOMPtr<T>& aLhs, const nsCOMPtr<U>& aRhs)
|
|
{
|
|
return static_cast<const T*>(aLhs.get()) != static_cast<const U*>(aRhs.get());
|
|
}
|
|
|
|
|
|
// Comparing an |nsCOMPtr| to a raw pointer
|
|
|
|
template<class T, class U>
|
|
inline bool
|
|
operator==(const nsCOMPtr<T>& aLhs, const U* aRhs)
|
|
{
|
|
return static_cast<const T*>(aLhs.get()) == aRhs;
|
|
}
|
|
|
|
template<class T, class U>
|
|
inline bool
|
|
operator==(const U* aLhs, const nsCOMPtr<T>& aRhs)
|
|
{
|
|
return aLhs == static_cast<const T*>(aRhs.get());
|
|
}
|
|
|
|
template<class T, class U>
|
|
inline bool
|
|
operator!=(const nsCOMPtr<T>& aLhs, const U* aRhs)
|
|
{
|
|
return static_cast<const T*>(aLhs.get()) != aRhs;
|
|
}
|
|
|
|
template<class T, class U>
|
|
inline bool
|
|
operator!=(const U* aLhs, const nsCOMPtr<T>& aRhs)
|
|
{
|
|
return aLhs != static_cast<const T*>(aRhs.get());
|
|
}
|
|
|
|
template<class T, class U>
|
|
inline bool
|
|
operator==(const nsCOMPtr<T>& aLhs, U* aRhs)
|
|
{
|
|
return static_cast<const T*>(aLhs.get()) == const_cast<const U*>(aRhs);
|
|
}
|
|
|
|
template<class T, class U>
|
|
inline bool
|
|
operator==(U* aLhs, const nsCOMPtr<T>& aRhs)
|
|
{
|
|
return const_cast<const U*>(aLhs) == static_cast<const T*>(aRhs.get());
|
|
}
|
|
|
|
template<class T, class U>
|
|
inline bool
|
|
operator!=(const nsCOMPtr<T>& aLhs, U* aRhs)
|
|
{
|
|
return static_cast<const T*>(aLhs.get()) != const_cast<const U*>(aRhs);
|
|
}
|
|
|
|
template<class T, class U>
|
|
inline bool
|
|
operator!=(U* aLhs, const nsCOMPtr<T>& aRhs)
|
|
{
|
|
return const_cast<const U*>(aLhs) != static_cast<const T*>(aRhs.get());
|
|
}
|
|
|
|
|
|
|
|
// Comparing an |nsCOMPtr| to |nullptr|
|
|
|
|
template<class T>
|
|
inline bool
|
|
operator==(const nsCOMPtr<T>& aLhs, decltype(nullptr))
|
|
{
|
|
return aLhs.get() == nullptr;
|
|
}
|
|
|
|
template<class T>
|
|
inline bool
|
|
operator==(decltype(nullptr), const nsCOMPtr<T>& aRhs)
|
|
{
|
|
return nullptr == aRhs.get();
|
|
}
|
|
|
|
template<class T>
|
|
inline bool
|
|
operator!=(const nsCOMPtr<T>& aLhs, decltype(nullptr))
|
|
{
|
|
return aLhs.get() != nullptr;
|
|
}
|
|
|
|
template<class T>
|
|
inline bool
|
|
operator!=(decltype(nullptr), const nsCOMPtr<T>& aRhs)
|
|
{
|
|
return nullptr != aRhs.get();
|
|
}
|
|
|
|
|
|
// Comparing any two [XP]COM objects for identity
|
|
|
|
inline bool
|
|
SameCOMIdentity(nsISupports* aLhs, nsISupports* aRhs)
|
|
{
|
|
return nsCOMPtr<nsISupports>(do_QueryInterface(aLhs)) ==
|
|
nsCOMPtr<nsISupports>(do_QueryInterface(aRhs));
|
|
}
|
|
|
|
|
|
|
|
template<class SourceType, class DestinationType>
|
|
inline nsresult
|
|
CallQueryInterface(nsCOMPtr<SourceType>& aSourcePtr, DestinationType** aDestPtr)
|
|
{
|
|
return CallQueryInterface(aSourcePtr.get(), aDestPtr);
|
|
}
|
|
|
|
template <class T>
|
|
RefPtr<T>::RefPtr(const nsCOMPtr_helper& aHelper)
|
|
{
|
|
void* newRawPtr;
|
|
if (NS_FAILED(aHelper(NS_GET_TEMPLATE_IID(T), &newRawPtr))) {
|
|
newRawPtr = 0;
|
|
}
|
|
mRawPtr = static_cast<T*>(newRawPtr);
|
|
}
|
|
|
|
template <class T>
|
|
RefPtr<T>&
|
|
RefPtr<T>::operator=(const nsCOMPtr_helper& aHelper)
|
|
{
|
|
void* newRawPtr;
|
|
if (NS_FAILED(aHelper(NS_GET_TEMPLATE_IID(T), &newRawPtr))) {
|
|
newRawPtr = 0;
|
|
}
|
|
assign_assuming_AddRef(static_cast<T*>(newRawPtr));
|
|
return *this;
|
|
}
|
|
|
|
|
|
#endif // !defined(nsCOMPtr_h___)
|