NS_IMETHODIMP
WSPProxy::QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
if (aIID.Equals(NS_GET_IID(nsISupports))) {
*aInstancePtr = static_cast<nsIXPTCProxy*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
if(mXPTCStub && mIID && aIID.Equals(*mIID)) {
*aInstancePtr = mXPTCStub;
NS_ADDREF_THIS();
return NS_OK;
}
else if (aIID.Equals(NS_GET_IID(nsIWebServiceProxy))) {
*aInstancePtr = static_cast<nsIWebServiceProxy*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
else if (aIID.Equals(NS_GET_IID(nsIClassInfo))) {
*aInstancePtr = static_cast<nsIClassInfo*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
return NS_ERROR_NO_INTERFACE;
}
NS_IMETHODIMP
RDFContentSinkImpl::QueryInterface(REFNSIID iid, void** result)
{
NS_PRECONDITION(result, "null ptr");
if (! result)
return NS_ERROR_NULL_POINTER;
NS_DEFINE_IID(kIContentSinkIID, NS_ICONTENT_SINK_IID);
NS_DEFINE_IID(kIExpatSinkIID, NS_IEXPATSINK_IID);
NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
NS_DEFINE_IID(kIXMLContentSinkIID, NS_IXMLCONTENT_SINK_IID);
NS_DEFINE_IID(kIRDFContentSinkIID, NS_IRDFCONTENTSINK_IID);
*result = nullptr;
if (iid.Equals(kIRDFContentSinkIID) ||
iid.Equals(kIXMLContentSinkIID) ||
iid.Equals(kIContentSinkIID) ||
iid.Equals(kISupportsIID)) {
*result = static_cast<nsIXMLContentSink*>(this);
AddRef();
return NS_OK;
}
else if (iid.Equals(kIExpatSinkIID)) {
*result = static_cast<nsIExpatSink*>(this);
AddRef();
return NS_OK;
}
return NS_NOINTERFACE;
}
nsresult nsUnicodeToX11Johab::QueryInterface(REFNSIID aIID,
void** aInstancePtr)
{
if (NULL == aInstancePtr) {
return NS_ERROR_NULL_POINTER;
}
*aInstancePtr = NULL;
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
if (aIID.Equals(NS_GET_IID(nsIUnicodeEncoder))) {
*aInstancePtr = (void*) ((nsIUnicodeEncoder*)this);
NS_ADDREF_THIS();
return NS_OK;
}
if (aIID.Equals(NS_GET_IID(nsICharRepresentable))) {
*aInstancePtr = (void*) ((nsICharRepresentable*)this);
NS_ADDREF_THIS();
return NS_OK;
}
if (aIID.Equals(kISupportsIID)) {
*aInstancePtr = (void*) ((nsISupports*)((nsIUnicodeEncoder*)this));
NS_ADDREF_THIS();
return NS_OK;
}
return NS_NOINTERFACE;
}
NS_IMETHODIMP
nsInstallVersion::QueryInterface(REFNSIID aIID,void** aInstancePtr)
{
if (aInstancePtr == NULL)
{
return NS_ERROR_NULL_POINTER;
}
// Always NULL result, in case of failure
*aInstancePtr = NULL;
if ( aIID.Equals(kIScriptObjectOwnerIID))
{
*aInstancePtr = (void*) ((nsIScriptObjectOwner*)this);
AddRef();
return NS_OK;
}
else if ( aIID.Equals(kIInstallVersion_IID) )
{
*aInstancePtr = (void*) ((nsIDOMInstallVersion*)this);
AddRef();
return NS_OK;
}
else if ( aIID.Equals(kISupportsIID) )
{
*aInstancePtr = (void*)(nsISupports*)(nsIScriptObjectOwner*)this;
AddRef();
return NS_OK;
}
return NS_NOINTERFACE;
}
NS_IMETHODIMP
WSPProxy::QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
if((mIID && aIID.Equals(*mIID)) || aIID.Equals(NS_GET_IID(nsISupports))) {
*aInstancePtr = NS_STATIC_CAST(nsXPTCStubBase*, this);
NS_ADDREF_THIS();
return NS_OK;
}
NS_IMETHODIMP
nsXPCWrappedJS::QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
if (nullptr == aInstancePtr) {
NS_PRECONDITION(false, "null pointer");
return NS_ERROR_NULL_POINTER;
}
*aInstancePtr = nullptr;
if ( aIID.Equals(NS_GET_IID(nsXPCOMCycleCollectionParticipant)) ) {
*aInstancePtr = NS_CYCLE_COLLECTION_PARTICIPANT(nsXPCWrappedJS);
return NS_OK;
}
if (aIID.Equals(NS_GET_IID(nsCycleCollectionISupports))) {
*aInstancePtr =
NS_CYCLE_COLLECTION_CLASSNAME(nsXPCWrappedJS)::Upcast(this);
return NS_OK;
}
if (!IsValid())
return NS_ERROR_UNEXPECTED;
if (aIID.Equals(NS_GET_IID(nsIXPConnectWrappedJSUnmarkGray))) {
*aInstancePtr = nullptr;
// No need to null check mJSObj because IsValid() call above did
// that already.
JS::ExposeObjectToActiveJS(mJSObj);
// Just return some error value since one isn't supposed to use
// nsIXPConnectWrappedJSUnmarkGray objects for anything.
return NS_ERROR_FAILURE;
}
// Always check for this first so that our 'outer' can get this interface
// from us without recurring into a call to the outer's QI!
if (aIID.Equals(NS_GET_IID(nsIXPConnectWrappedJS))) {
NS_ADDREF(this);
*aInstancePtr = (void*) static_cast<nsIXPConnectWrappedJS*>(this);
return NS_OK;
}
nsISupports* outer = GetAggregatedNativeObject();
if (outer)
return outer->QueryInterface(aIID, aInstancePtr);
// else...
return mClass->DelegatedQueryInterface(this, aIID, aInstancePtr);
}
NS_IMETHODIMP
nsXTFWeakTearoff::QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
NS_PRECONDITION(aInstancePtr, "null out param");
if (aIID.Equals(mIID) || aIID.Equals(NS_GET_IID(nsISupports))) {
*aInstancePtr = mXPTCStub;
NS_ADDREF_THIS();
return NS_OK;
}
// we can't map QI onto the obj, because the xpcom wrapper otherwise
// QI-accumulates all interfaces defined on mObj
// else return mObj->QueryInterface(aIID, aInstancePtr);
*aInstancePtr = nsnull;
return NS_ERROR_NO_INTERFACE;
}
NS_IMETHODIMP
nsDBFolderInfo::QueryInterface(REFNSIID iid, void** result)
{
if (! result)
return NS_ERROR_NULL_POINTER;
*result = nsnull;
if(iid.Equals(NS_GET_IID(nsIDBFolderInfo)) ||
iid.Equals(NS_GET_IID(nsISupports)))
{
*result = static_cast<nsIDBFolderInfo*>(this);
AddRef();
return NS_OK;
}
return NS_NOINTERFACE;
}
//NS_IMPL_QUERY_INTERFACE_INHERITED1(Class, Super, AdditionalInterface)
NS_IMETHODIMP EditAggregateTxn::QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
if (!aInstancePtr) return NS_ERROR_NULL_POINTER;
if (aIID.Equals(EditAggregateTxn::GetCID())) {
*aInstancePtr = NS_STATIC_CAST(EditAggregateTxn*, this);
NS_ADDREF_THIS();
return NS_OK;
}
NS_IMETHODIMP
nsAsyncStreamListener::QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
if (!aInstancePtr) return NS_ERROR_NULL_POINTER;
if (aIID.Equals(NS_GET_IID(nsIAsyncStreamListener))) {
*aInstancePtr = NS_STATIC_CAST(nsIAsyncStreamListener*, this);
NS_ADDREF_THIS();
return NS_OK;
}
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
NS_IMETHODIMP
nsXTFElementWrapper::QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
NS_PRECONDITION(aInstancePtr, "null out param");
NS_IMPL_QUERY_CYCLE_COLLECTION(nsXTFElementWrapper)
if (aIID.Equals(NS_GET_IID(nsIClassInfo)) ||
aIID.Equals(NS_GET_IID(nsXPCClassInfo))) {
*aInstancePtr = static_cast<nsIClassInfo*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
if (aIID.Equals(NS_GET_IID(nsIXPCScriptable))) {
*aInstancePtr = static_cast<nsIXPCScriptable*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
if (aIID.Equals(NS_GET_IID(nsIXTFElementWrapper))) {
*aInstancePtr = static_cast<nsIXTFElementWrapper*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
nsresult rv = nsXTFElementWrapperBase::QueryInterface(aIID, aInstancePtr);
if (NS_SUCCEEDED(rv)) {
return rv;
}
// try to get get the interface from our wrapped element:
nsCOMPtr<nsISupports> inner;
QueryInterfaceInner(aIID, getter_AddRefs(inner));
if (inner) {
rv = NS_NewXTFInterfaceAggregator(aIID, inner,
static_cast<nsIContent*>(this),
aInstancePtr);
return rv;
}
return NS_ERROR_NO_INTERFACE;
}
NS_IMETHODIMP
xpctestNoisy::QueryInterface(REFNSIID iid, void** result)
{
if (! result)
return NS_ERROR_NULL_POINTER;
if (iid.Equals(NS_GET_IID(nsIXPCTestNoisy)) ||
iid.Equals(NS_GET_IID(nsISupports))) {
*result = static_cast<nsIXPCTestNoisy*>(this);
printf("Noisy %d - QueryInterface called and succeeding\n", mID);
NS_ADDREF(this);
return NS_OK;
}
else {
*result = nsnull;
printf("Noisy %d - QueryInterface for interface I don't do\n", mID);
return NS_NOINTERFACE;
}
}
//----------------------------------------------------------------------
// implementation helpers:
PRBool
nsXTFElementWrapper::QueryInterfaceInner(REFNSIID aIID, void** result)
{
// We must ensure that the inner element has a distinct xpconnect
// identity, so we mustn't aggregate nsIXPConnectWrappedJS:
if (aIID.Equals(NS_GET_IID(nsIXPConnectWrappedJS))) return PR_FALSE;
GetXTFElement()->QueryInterface(aIID, result);
return (*result!=nsnull);
}
/* QueryInterface implementation for this class. */
NS_IMETHODIMP className::QueryInterface( REFNSIID anIID, void **anInstancePtr ) {
nsresult rv = NS_OK;
///* ATENTIE */ printf("QueryInterface!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n\n");
/* Check for place to return result. */
if( !anInstancePtr ) rv = NS_ERROR_NULL_POINTER;
else {
*anInstancePtr = 0;
if ( anIID.Equals( NS_GET_IID(nsIHelperAppLauncherDialog) ) ) {
*anInstancePtr = (void*) (nsIHelperAppLauncherDialog*)this;
NS_ADDREF_THIS();
}
else if ( anIID.Equals( NS_GET_IID(nsISupports) ) ) {
*anInstancePtr = (void*) ( (nsISupports*) (interfaceName*)this );
NS_ADDREF_THIS();
}
else rv = NS_NOINTERFACE;
}
return rv;
}
NS_IMETHODIMP
nsScrollbarButtonFrame::QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
if (aIID.Equals(NS_GET_IID(nsITimerCallback))) {
*aInstancePtr = (void*)(nsITimerCallback*) this;
NS_ADDREF_THIS();
return NS_OK;
}
return nsButtonBoxFrame::QueryInterface(aIID, aInstancePtr);
}
NS_IMETHODIMP
nsProxyEventObject::QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
if( aIID.Equals(GetClass()->GetProxiedIID()) )
{
*aInstancePtr = static_cast<nsISupports*>(mXPTCStub);
NS_ADDREF_THIS();
return NS_OK;
}
return mProxyObject->QueryInterface(aIID, aInstancePtr);
}
nsresult
xpcAccessibleHyperText::QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
*aInstancePtr = nullptr;
HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
if (!text->IsTextRole())
return NS_ERROR_NO_INTERFACE;
if (aIID.Equals(NS_GET_IID(nsIAccessibleText)))
*aInstancePtr = static_cast<nsIAccessibleText*>(text);
else if (aIID.Equals(NS_GET_IID(nsIAccessibleEditableText)))
*aInstancePtr = static_cast<nsIAccessibleEditableText*>(text);
else if (aIID.Equals(NS_GET_IID(nsIAccessibleHyperText)))
*aInstancePtr = static_cast<nsIAccessibleHyperText*>(text);
else
return NS_ERROR_NO_INTERFACE;
NS_ADDREF(text);
return NS_OK;
}
NS_IMETHODIMP
nsSVGClipPathFrame::QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
if (nsnull == aInstancePtr) {
return NS_ERROR_NULL_POINTER;
}
if (aIID.Equals(nsSVGClipPathFrame::GetCID())) {
*aInstancePtr = (void*)(nsSVGClipPathFrame*)this;
NS_ADDREF_THIS();
return NS_OK;
}
return (nsSVGDefsFrame::QueryInterface(aIID, aInstancePtr));
}
NS_IMETHODIMP
nsXPCWrappedJS::QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
if (nullptr == aInstancePtr) {
NS_PRECONDITION(0, "null pointer");
return NS_ERROR_NULL_POINTER;
}
if ( aIID.Equals(NS_GET_IID(nsXPCOMCycleCollectionParticipant)) ) {
*aInstancePtr = NS_CYCLE_COLLECTION_PARTICIPANT(nsXPCWrappedJS);
return NS_OK;
}
if (aIID.Equals(NS_GET_IID(nsCycleCollectionISupports))) {
*aInstancePtr =
NS_CYCLE_COLLECTION_CLASSNAME(nsXPCWrappedJS)::Upcast(this);
return NS_OK;
}
if (!IsValid())
return NS_ERROR_UNEXPECTED;
// Always check for this first so that our 'outer' can get this interface
// from us without recurring into a call to the outer's QI!
if (aIID.Equals(NS_GET_IID(nsIXPConnectWrappedJS))) {
NS_ADDREF(this);
*aInstancePtr = (void*) static_cast<nsIXPConnectWrappedJS*>(this);
return NS_OK;
}
nsISupports* outer = GetAggregatedNativeObject();
if (outer)
return outer->QueryInterface(aIID, aInstancePtr);
// else...
return mClass->DelegatedQueryInterface(this, aIID, aInstancePtr);
}
NS_IMETHODIMP
InvokeTestTarget::QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
if (NULL == aInstancePtr) {
return NS_ERROR_NULL_POINTER;
}
*aInstancePtr = NULL;
if (aIID.Equals(kTheCID)) {
*aInstancePtr = (void*) static_cast<InvokeTestTargetInterface*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
if (aIID.Equals(NS_GET_IID(nsISupports))) {
*aInstancePtr = (void*) static_cast<nsISupports*>(static_cast<InvokeTestTargetInterface*>(this));
NS_ADDREF_THIS();
return NS_OK;
}
return NS_NOINTERFACE;
}
NS_IMETHODIMP
nsPopupBoxObject::QueryInterface(REFNSIID iid, void** aResult)
{
if (!aResult)
return NS_ERROR_NULL_POINTER;
if (iid.Equals(NS_GET_IID(nsIPopupBoxObject))) {
*aResult = (nsIPopupBoxObject*)this;
NS_ADDREF(this);
return NS_OK;
}
return nsBoxObject::QueryInterface(iid, aResult);
}
NS_IMETHODIMP
RDFContentSinkImpl::QueryInterface(REFNSIID iid, void** result)
{
NS_PRECONDITION(result, "null ptr");
if (! result)
return NS_ERROR_NULL_POINTER;
*result = nsnull;
if (iid.Equals(kIRDFContentSinkIID) ||
iid.Equals(kIXMLContentSinkIID) ||
iid.Equals(kIContentSinkIID) ||
iid.Equals(kISupportsIID)) {
*result = static_cast<nsIXMLContentSink*>(this);
AddRef();
return NS_OK;
}
else if (iid.Equals(kIExpatSinkIID)) {
*result = static_cast<nsIExpatSink*>(this);
AddRef();
return NS_OK;
}
return NS_NOINTERFACE;
}
NS_IMETHODIMP nsDeviceContextSpecBeOS :: QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
if (nsnull == aInstancePtr)
return NS_ERROR_NULL_POINTER;
if (aIID.Equals(kIDeviceContextSpecIID))
{
nsIDeviceContextSpec* tmp = this;
*aInstancePtr = (void*) tmp;
NS_ADDREF_THIS();
return NS_OK;
}
#ifdef USE_POSTSCRIPT
if (aIID.Equals(kIDeviceContextSpecPSIID))
{
nsIDeviceContextSpecPS* tmp = this;
*aInstancePtr = (void*) tmp;
NS_ADDREF_THIS();
return NS_OK;
}
#endif /* USE_POSTSCRIPT */
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
if (aIID.Equals(kISupportsIID))
{
nsIDeviceContextSpec* tmp = this;
nsISupports* tmp2 = tmp;
*aInstancePtr = (void*) tmp2;
NS_ADDREF_THIS();
return NS_OK;
}
return NS_NOINTERFACE;
}
nsresult
nsXULListboxAccessible::QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
nsresult rv = XULSelectControlAccessible::QueryInterface(aIID, aInstancePtr);
if (*aInstancePtr)
return rv;
if (aIID.Equals(NS_GET_IID(nsIAccessibleTable)) && IsMulticolumn()) {
*aInstancePtr = static_cast<nsIAccessibleTable*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
return NS_ERROR_NO_INTERFACE;
}
// QueryInterface implementation for nsXMLElement
NS_IMETHODIMP
nsXMLElement::QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
NS_ENSURE_ARG_POINTER(aInstancePtr);
*aInstancePtr = nsnull;
nsresult rv = nsGenericElement::QueryInterface(aIID, aInstancePtr);
if (NS_SUCCEEDED(rv))
return rv;
nsISupports *inst = nsnull;
if (aIID.Equals(NS_GET_IID(nsIDOMNode))) {
inst = NS_STATIC_CAST(nsIDOMNode *, this);
} else if (aIID.Equals(NS_GET_IID(nsIDOMElement))) {
NS_IMETHODIMP nsNewsDatabase::QueryInterface(REFNSIID aIID,
void **aInstancePtr) {
if (!aInstancePtr) return NS_ERROR_NULL_POINTER;
*aInstancePtr = nullptr;
if (aIID.Equals(NS_GET_IID(nsINewsDatabase))) {
*aInstancePtr = static_cast<nsINewsDatabase *>(this);
}
if (*aInstancePtr) {
AddRef();
return NS_OK;
}
return nsMsgDatabase::QueryInterface(aIID, aInstancePtr);
}
nsresult NS_FASTCALL
NS_TableDrivenQI(void* aThis, const QITableEntry* entries,
REFNSIID aIID, void **aInstancePtr)
{
while (entries->iid) {
if (aIID.Equals(*entries->iid)) {
nsISupports* r =
reinterpret_cast<nsISupports*>
(reinterpret_cast<char*>(aThis) + entries->offset);
NS_ADDREF(r);
*aInstancePtr = r;
return NS_OK;
}
++entries;
}
*aInstancePtr = nullptr;
return NS_ERROR_NO_INTERFACE;
}
NS_IMETHODIMP
nsImapMoveCopyMsgTxn::QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
if (!aInstancePtr) return NS_ERROR_NULL_POINTER;
*aInstancePtr = nsnull;
if (aIID.Equals(NS_GET_IID(nsImapMoveCopyMsgTxn)))
{
*aInstancePtr = static_cast<nsImapMoveCopyMsgTxn*>(this);
}
if (*aInstancePtr)
{
NS_ADDREF_THIS();
return NS_OK;
}
return nsMsgTxn::QueryInterface(aIID, aInstancePtr);
}
NS_METHOD
nsCLiveconnectFactory::CreateInstance(nsISupports *aOuter, REFNSIID aIID, void **aResult)
{
if (!aResult)
return NS_ERROR_INVALID_POINTER;
*aResult = NULL;
if (aOuter && !aIID.Equals(kISupportsIID))
return NS_ERROR_INVALID_ARG;
nsCLiveconnect* liveconnect = new nsCLiveconnect(aOuter);
if (liveconnect == NULL)
return NS_ERROR_OUT_OF_MEMORY;
nsresult result = liveconnect->AggregatedQueryInterface(aIID, aResult);
if (NS_FAILED(result))
delete liveconnect;
return result;
}
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END
NS_IMETHODIMP
nsXPCWrappedJS::AggregatedQueryInterface(REFNSIID aIID, void** aInstancePtr)
{
MOZ_ASSERT(IsAggregatedToNative(), "bad AggregatedQueryInterface call");
if (!IsValid())
return NS_ERROR_UNEXPECTED;
// Put this here rather that in DelegatedQueryInterface because it needs
// to be in QueryInterface before the possible delegation to 'outer', but
// we don't want to do this check twice in one call in the normal case:
// once in QueryInterface and once in DelegatedQueryInterface.
if (aIID.Equals(NS_GET_IID(nsIXPConnectWrappedJS))) {
NS_ADDREF(this);
*aInstancePtr = (void*) static_cast<nsIXPConnectWrappedJS*>(this);
return NS_OK;
}
return mClass->DelegatedQueryInterface(this, aIID, aInstancePtr);
}
