NS_IMETHODIMP
FetchDriver::GetInterface(const nsIID& aIID, void **aResult)
{
if (aIID.Equals(NS_GET_IID(nsIChannelEventSink))) {
*aResult = static_cast<nsIChannelEventSink*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
nsresult rv;
if (mNotificationCallbacks) {
rv = mNotificationCallbacks->GetInterface(aIID, aResult);
if (NS_SUCCEEDED(rv)) {
NS_ASSERTION(*aResult, "Lying nsIInterfaceRequestor implementation!");
return rv;
}
}
else if (aIID.Equals(NS_GET_IID(nsIStreamListener))) {
*aResult = static_cast<nsIStreamListener*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
else if (aIID.Equals(NS_GET_IID(nsIRequestObserver))) {
*aResult = static_cast<nsIRequestObserver*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
return QueryInterface(aIID, aResult);
}
// here nsScriptablePeer should return three interfaces it can be asked for by their iid's
// static casts are necessary to ensure that correct pointer is returned
NS_IMETHODIMP nsScriptablePeer::QueryInterface(const nsIID & aIID,
void **aInstancePtr)
{
if (!aInstancePtr)
return NS_ERROR_NULL_POINTER;
if (aIID.Equals(kIScriptableMplayerPluginIID)) {
*aInstancePtr = static_cast < nsIScriptableMplayerPlugin *> (this);
AddRef();
return NS_OK;
}
if (aIID.Equals(kIClassInfoIID)) {
*aInstancePtr = static_cast < nsIClassInfo *> (this);
AddRef();
return NS_OK;
}
if (aIID.Equals(kISupportsIID)) {
*aInstancePtr =
static_cast < nsISupports *>
(static_cast < nsIScriptableMplayerPlugin *> (this));
AddRef();
return NS_OK;
}
return NS_NOINTERFACE;
}
NS_IMETHODIMP CFactory::CreateInstance(nsISupports *aOuter,
const nsIID & iid,
void * *result)
{
fprintf(stderr,"In CreateInstance\n");
static NS_DEFINE_IID(kIPluginInstanceIID, NS_IPLUGININSTANCE_IID);
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
if (result == NULL) {
return NS_ERROR_UNEXPECTED;
}
*result = NULL;
if (NULL != aOuter) {
return NS_ERROR_NO_AGGREGATION;
}
if (! (iid.Equals(kIPluginInstanceIID) ||
iid.Equals(kISupportsIID)))
return NS_ERROR_NO_INTERFACE;
ICreater * ic = NULL;
m_pJavaService->QI(ICreater_IID,(void **) &ic);
CPluginInstance * pi = new CPluginInstance(ic,m_pServiceManager);
ic->release();
return pi->QueryInterface(iid,result);
}
NS_IMETHODIMP
HttpChannelParent::GetInterface(const nsIID& aIID, void **result)
{
if (aIID.Equals(NS_GET_IID(nsIAuthPromptProvider)) ||
aIID.Equals(NS_GET_IID(nsISecureBrowserUI))) {
if (mTabParent) {
return mTabParent->QueryInterface(aIID, result);
}
}
// Only support nsIAuthPromptProvider in Content process
if (XRE_IsParentProcess() &&
aIID.Equals(NS_GET_IID(nsIAuthPromptProvider))) {
*result = nullptr;
return NS_OK;
}
// Only support nsILoadContext if child channel's callbacks did too
if (aIID.Equals(NS_GET_IID(nsILoadContext)) && mLoadContext) {
nsCOMPtr<nsILoadContext> copy = mLoadContext;
copy.forget(result);
return NS_OK;
}
return QueryInterface(aIID, result);
}
// nsIInterfaceRequestor method
NS_IMETHODIMP
nsXPInstallManager::GetInterface(const nsIID & eventSinkIID, void* *_retval)
{
if (eventSinkIID.Equals(NS_GET_IID(nsIAuthPrompt))) {
*_retval = nsnull;
nsresult rv;
nsCOMPtr<nsIWindowWatcher> ww(do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIAuthPrompt> prompt;
rv = ww->GetNewAuthPrompter(nsnull, getter_AddRefs(prompt));
NS_ENSURE_SUCCESS(rv, rv);
nsIAuthPrompt *p = prompt.get();
NS_ADDREF(p);
*_retval = p;
return NS_OK;
}
else if (eventSinkIID.Equals(NS_GET_IID(nsIBadCertListener2))) {
// If we aren't chrome triggered fall back to the default dialogs
if (!mFromChrome)
return NS_ERROR_NO_INTERFACE;
}
return QueryInterface(eventSinkIID, (void**)_retval);
}
NS_IMETHODIMP
EventSource::GetInterface(const nsIID & aIID,
void **aResult)
{
if (aIID.Equals(NS_GET_IID(nsIChannelEventSink))) {
*aResult = static_cast<nsIChannelEventSink*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
if (aIID.Equals(NS_GET_IID(nsIAuthPrompt)) ||
aIID.Equals(NS_GET_IID(nsIAuthPrompt2))) {
nsresult rv = CheckInnerWindowCorrectness();
NS_ENSURE_SUCCESS(rv, NS_ERROR_UNEXPECTED);
nsCOMPtr<nsIPromptFactory> wwatch =
do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
// Get the an auth prompter for our window so that the parenting
// of the dialogs works as it should when using tabs.
nsCOMPtr<nsIDOMWindow> window;
if (GetOwner()) {
window = GetOwner()->GetOuterWindow();
}
return wwatch->GetPrompt(window, aIID, aResult);
}
return QueryInterface(aIID, aResult);
}
NS_IMETHODIMP
nsWebSocket::GetInterface(const nsIID &aIID, void **aResult)
{
NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
if (mDisconnected)
return NS_ERROR_FAILURE;
if (aIID.Equals(NS_GET_IID(nsIAuthPrompt)) ||
aIID.Equals(NS_GET_IID(nsIAuthPrompt2))) {
nsresult rv;
nsCOMPtr<nsIDocument> doc =
nsContentUtils::GetDocumentFromScriptContext(mScriptContext);
if (!doc)
return NS_ERROR_NOT_AVAILABLE;
nsCOMPtr<nsIPromptFactory> wwatch =
do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsPIDOMWindow> outerWindow = doc->GetWindow();
return wwatch->GetPrompt(outerWindow, aIID, aResult);
}
return NS_ERROR_UNEXPECTED;
}
NS_IMETHODIMP CFactory::QueryInterface(const nsIID & iid, void **ptr)
{
fprintf(stderr,"In QueryInterface\n");
static NS_DEFINE_IID(kIPluginIID, NS_IPLUGIN_IID);
static NS_DEFINE_IID(kIFactoryIID, NS_IFACTORY_IID);
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
static NS_DEFINE_IID(kIJVMPluginIID, NS_IJVMPLUGIN_IID);
static NS_DEFINE_IID(kIJVMConsoleIID, NS_IJVMCONSOLE_IID);
if (NULL == ptr) {
return NS_ERROR_NULL_POINTER;
}
if(iid.Equals(kISupportsIID) || iid.Equals(kIJVMPluginIID)) {
*ptr = (void*) (nsIJVMPlugin*) this;
} else if (iid.Equals(kIPluginIID)) {
*ptr = (void*) (nsIPlugin*) this;
} else if (iid.Equals(kIFactoryIID)) {
*ptr = (void*) (nsIFactory*) this;
} else if (iid.Equals(kIJVMConsoleIID)) {
fprintf(stderr,"Looking for the Console Interface\n");
*ptr = (void*) (nsIJVMConsole*) this;
} else {
return NS_NOINTERFACE;
}
AddRef();
return NS_OK;
}
NS_IMETHODIMP
FTPChannelParent::GetInterface(const nsIID& uuid, void** result)
{
if (uuid.Equals(NS_GET_IID(nsIAuthPromptProvider)) ||
uuid.Equals(NS_GET_IID(nsISecureBrowserUI))) {
if (mTabParent) {
return mTabParent->QueryInterface(uuid, result);
}
} else if (uuid.Equals(NS_GET_IID(nsIAuthPrompt)) ||
uuid.Equals(NS_GET_IID(nsIAuthPrompt2))) {
nsCOMPtr<nsIAuthPromptProvider> provider(do_QueryObject(mTabParent));
if (provider) {
return provider->GetAuthPrompt(nsIAuthPromptProvider::PROMPT_NORMAL,
uuid,
result);
}
}
// Only support nsILoadContext if child channel's callbacks did too
if (uuid.Equals(NS_GET_IID(nsILoadContext)) && mLoadContext) {
nsCOMPtr<nsILoadContext> copy = mLoadContext;
copy.forget(result);
return NS_OK;
}
return QueryInterface(uuid, result);
}
NS_IMETHODIMP
EmbedPromptFactory::GetPrompt(nsIDOMWindow* aParent, const nsIID& iid, void **result)
{
nsCOMPtr<nsIDOMWindow> parent(aParent);
if (!parent) { // if no parent provided, consult the window watcher:
nsresult rv;
nsCOMPtr<nsIWindowWatcher> wwatcher = do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
wwatcher->GetActiveWindow(getter_AddRefs(parent));
if (!parent) {
return NS_ERROR_FAILURE;
}
}
if (iid.Equals(NS_GET_IID(nsIAuthPrompt)) ||
iid.Equals(NS_GET_IID(nsIAuthPrompt2))) {
nsRefPtr<EmbedAuthPromptService> service = new EmbedAuthPromptService(parent);
*result = service.forget().get();
} else if (iid.Equals(NS_GET_IID(nsIPrompt))) {
nsRefPtr<EmbedPromptService> service = new EmbedPromptService(parent);
*result = service.forget().get();
}
return NS_OK;
}
NS_IMETHODIMP
SystemWorkerManager::GetInterface(const nsIID &aIID, void **aResult)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
if (aIID.Equals(NS_GET_IID(nsIRadioInterfaceLayer))) {
NS_IF_ADDREF(*reinterpret_cast<nsIRadioInterfaceLayer**>(aResult) = mRIL);
return NS_OK;
}
if (aIID.Equals(NS_GET_IID(nsIWifi))) {
return CallQueryInterface(mWifiWorker,
reinterpret_cast<nsIWifi**>(aResult));
}
#ifdef MOZ_WIDGET_GONK
if (aIID.Equals(NS_GET_IID(nsINetworkManager))) {
return CallQueryInterface(mNetdWorker,
reinterpret_cast<nsINetworkManager**>(aResult));
}
#endif
NS_WARNING("Got nothing for the requested IID!");
return NS_ERROR_NO_INTERFACE;
}
NS_INTERFACE_MAP_END
//*****************************************************************************
// nsChromeTreeOwner::nsIInterfaceRequestor
//*****************************************************************************
NS_IMETHODIMP nsChromeTreeOwner::GetInterface(const nsIID& aIID, void** aSink)
{
NS_ENSURE_ARG_POINTER(aSink);
if(aIID.Equals(NS_GET_IID(nsIPrompt))) {
NS_ENSURE_STATE(mXULWindow);
return mXULWindow->GetInterface(aIID, aSink);
}
if(aIID.Equals(NS_GET_IID(nsIAuthPrompt))) {
NS_ENSURE_STATE(mXULWindow);
return mXULWindow->GetInterface(aIID, aSink);
}
if(aIID.Equals(NS_GET_IID(nsIWebBrowserChrome))) {
NS_ENSURE_STATE(mXULWindow);
return mXULWindow->GetInterface(aIID, aSink);
}
if (aIID.Equals(NS_GET_IID(nsIEmbeddingSiteWindow))) {
NS_ENSURE_STATE(mXULWindow);
return mXULWindow->GetInterface(aIID, aSink);
}
if (aIID.Equals(NS_GET_IID(nsIXULWindow))) {
NS_ENSURE_STATE(mXULWindow);
return mXULWindow->QueryInterface(aIID, aSink);
}
return QueryInterface(aIID, aSink);
}
// Custom QueryInterface impl to deal with the IDispatch tearoff
NS_IMETHODIMP
nsScriptablePeer::QueryInterface(const nsIID & aIID, void **aInstancePtr)
{
NS_ASSERTION(aInstancePtr, "QueryInterface requires a non-NULL destination!");
if (!aInstancePtr)
return NS_ERROR_NULL_POINTER;
*aInstancePtr = nsnull;
nsISupports* foundInterface = nsnull;
if (aIID.Equals(NS_GET_IID(nsISupports)))
foundInterface = static_cast<nsISupports *>(static_cast<nsIClassInfo *>(this));
else if (aIID.Equals(NS_GET_IID(nsIClassInfo)))
foundInterface = static_cast<nsIClassInfo*>(this);
else if (aIID.Equals(NS_GET_IID(nsIMozAxPlugin)))
foundInterface = static_cast<nsIMozAxPlugin*>(this);
else if (memcmp(&aIID, &__uuidof(IDispatch), sizeof(nsID)) == 0)
{
HRESULT hr = mTearOff->QueryInterface(__uuidof(IDispatch), aInstancePtr);
if (SUCCEEDED(hr)) return NS_OK;
return E_FAIL;
}
NS_IF_ADDREF(foundInterface);
*aInstancePtr = foundInterface;
return (*aInstancePtr) ? NS_OK : NS_NOINTERFACE;
}
NS_IMETHODIMP
nsSanePluginFactoryImpl::QueryInterface(const nsIID &aIID,
void **aInstancePtr)
{
#ifdef DEBUG
printf("nsSanePluginFactoryImpl::QueryInterface()\n");
#endif
if (!aInstancePtr)
return NS_ERROR_NULL_POINTER;
if (aIID.Equals(kISupportsIID)) {
*aInstancePtr = static_cast<nsISupports*>(this);
} else if (aIID.Equals(kIFactoryIID)) {
*aInstancePtr = static_cast<nsISupports*>
(static_cast<nsIFactory*>(this));
} else if (aIID.Equals(kIPluginIID)) {
*aInstancePtr = static_cast<nsISupports*>
(static_cast<nsIPlugin*>(this));
} else {
*aInstancePtr = nsnull;
return NS_ERROR_NO_INTERFACE;
}
NS_ADDREF(reinterpret_cast<nsISupports*>(*aInstancePtr));
return NS_OK;
}
NS_IMETHODIMP
nsHTTPIndex::GetInterface(const nsIID &anIID, void **aResult )
{
if (anIID.Equals(NS_GET_IID(nsIFTPEventSink))) {
// If we don't have a container to store the logged data
// then don't report ourselves back to the caller
if (!mRequestor)
return NS_ERROR_NO_INTERFACE;
*aResult = static_cast<nsIFTPEventSink*>(this);
NS_ADDREF(this);
return NS_OK;
}
if (anIID.Equals(NS_GET_IID(nsIPrompt))) {
if (!mRequestor)
return NS_ERROR_NO_INTERFACE;
nsCOMPtr<nsPIDOMWindowOuter> aDOMWindow = do_GetInterface(mRequestor);
if (!aDOMWindow)
return NS_ERROR_NO_INTERFACE;
nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
return wwatch->GetNewPrompter(aDOMWindow, (nsIPrompt**)aResult);
}
if (anIID.Equals(NS_GET_IID(nsIAuthPrompt))) {
if (!mRequestor)
return NS_ERROR_NO_INTERFACE;
nsCOMPtr<nsPIDOMWindowOuter> aDOMWindow = do_GetInterface(mRequestor);
if (!aDOMWindow)
return NS_ERROR_NO_INTERFACE;
nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
return wwatch->GetNewAuthPrompter(aDOMWindow, (nsIAuthPrompt**)aResult);
}
if (anIID.Equals(NS_GET_IID(nsIProgressEventSink))) {
if (!mRequestor)
return NS_ERROR_NO_INTERFACE;
nsCOMPtr<nsIProgressEventSink> sink = do_GetInterface(mRequestor);
if (!sink)
return NS_ERROR_NO_INTERFACE;
*aResult = sink;
NS_ADDREF((nsISupports*)*aResult);
return NS_OK;
}
return NS_ERROR_NO_INTERFACE;
}
NS_METHOD
nsCLiveconnect::AggregatedQueryInterface(const nsIID& aIID, void** aInstancePtr)
{
NS_ENSURE_ARG_POINTER(aInstancePtr);
if (aIID.Equals(NS_GET_IID(nsISupports))) {
*aInstancePtr = GetInner();
}
else if (aIID.Equals(NS_GET_IID(nsILiveconnect))) {
*aInstancePtr = NS_STATIC_CAST(nsILiveconnect*, this);
}
NS_METHOD
nsSymantecDebugManager::AggregatedQueryInterface(const nsIID& aIID, void** aInstancePtr)
{
if (!aInstancePtr)
return NS_ERROR_INVALID_POINTER;
if (aIID.Equals(NS_GET_IID(nsISupports)))
*aInstancePtr = GetInner();
else if (aIID.Equals(kISymantecDebugManagerIID))
*aInstancePtr = NS_STATIC_CAST(nsISymantecDebugManager*, this);
else {
nsresult CPluginStreamPeer::QueryInterface(const nsIID& iid, void** ptr)
{
if (NULL == ptr) {
return NS_ERROR_NULL_POINTER;
}
if (iid.Equals(kIPluginStreamPeerIID) ||
iid.Equals(kISupportsIID)) {
*ptr = (void*) ((nsIPluginStreamPeer*)this);
AddRef();
return NS_OK;
}
return NS_NOINTERFACE;
}
NS_METHOD
CNSAdapter_SecureJNIEnv::QueryInterface(const nsIID& aIID, void** interfacePtr)
{
if (aIID.Equals(kISupportsIID) ||
aIID.Equals(kISecureEnvIID))
{
*interfacePtr = (nsISecureEnv*)this;
AddRef();
return NS_OK;
}
else
return NS_NOINTERFACE;
}
NS_INTERFACE_MAP_END
//*****************************************************************************
// nsDocShellTreeOwner::nsIInterfaceRequestor
//*****************************************************************************
NS_IMETHODIMP
nsDocShellTreeOwner::GetInterface(const nsIID& aIID, void** aSink)
{
NS_ENSURE_ARG_POINTER(aSink);
if (NS_SUCCEEDED(QueryInterface(aIID, aSink))) {
return NS_OK;
}
if (aIID.Equals(NS_GET_IID(nsIWebBrowserChromeFocus))) {
if (mWebBrowserChromeWeak != nullptr) {
return mWebBrowserChromeWeak->QueryReferent(aIID, aSink);
}
return mOwnerWin->QueryInterface(aIID, aSink);
}
if (aIID.Equals(NS_GET_IID(nsIPrompt))) {
nsCOMPtr<nsIPrompt> prompt;
EnsurePrompter();
prompt = mPrompter;
if (prompt) {
prompt.forget(aSink);
return NS_OK;
}
return NS_NOINTERFACE;
}
if (aIID.Equals(NS_GET_IID(nsIAuthPrompt))) {
nsCOMPtr<nsIAuthPrompt> prompt;
EnsureAuthPrompter();
prompt = mAuthPrompter;
if (prompt) {
prompt.forget(aSink);
return NS_OK;
}
return NS_NOINTERFACE;
}
nsCOMPtr<nsIInterfaceRequestor> req = GetOwnerRequestor();
if (req) {
return req->GetInterface(aIID, aSink);
}
return NS_NOINTERFACE;
}
NS_METHOD
nsCLiveconnectFactory::QueryInterface(const nsIID& aIID, void** aInstancePtr)
{
PR_ASSERT(NULL != aInstancePtr);
if (NULL == aInstancePtr) {
return NS_ERROR_NULL_POINTER;
}
if (aIID.Equals(kIFactoryIID) ||
aIID.Equals(kISupportsIID)) {
*aInstancePtr = (void*) this;
AddRef();
return NS_OK;
}
return NS_NOINTERFACE;
}
NS_METHOD
CSecurityContext::AggregatedQueryInterface(const nsIID& aIID, void** aInstancePtr)
{
if (aIID.Equals(kISupportsIID)) {
*aInstancePtr = GetInner();
AddRef();
return NS_OK;
}
if (aIID.Equals(kISecurityContextIID)) {
*aInstancePtr = (nsISecurityContext *)this;
AddRef();
return NS_OK;
}
return NS_NOINTERFACE;
}
nsresult
nsProgressManager::QueryInterface(const nsIID& iid, void** result)
{
if (iid.Equals(kITransferListenerIID)) {
(*result) = (void*) ((nsITransferListener*) this);
AddRef();
return NS_OK;
}
else if (iid.Equals(kISupportsIID)) {
(*result) = (void*) ((nsISupports*) this);
AddRef();
return NS_OK;
}
return NS_NOINTERFACE;
}
PRBool
Py_nsISupports::InterfaceFromPyISupports(PyObject *ob,
const nsIID &iid,
nsISupports **ppv)
{
nsISupports *pis;
PRBool rc = PR_FALSE;
if ( !Check(ob) )
{
PyErr_Format(PyExc_TypeError, "Objects of type '%s' can not be used as COM objects", ob->ob_type->tp_name);
goto done;
}
nsIID already_iid;
pis = GetI(ob, &already_iid);
if ( !pis )
goto done; /* exception was set by GetI() */
/* note: we don't (yet) explicitly hold a reference to pis */
if (iid.Equals(Py_nsIID_NULL)) {
// a bit of a hack - we are asking for the arbitary interface
// wrapped by this object, not some other specific interface -
// so no QI, just an AddRef();
Py_BEGIN_ALLOW_THREADS
pis->AddRef();
Py_END_ALLOW_THREADS
*ppv = pis;
} else {
// specific interface requested - if it is not already the
// specific interface, QI for it and discard pis.
if (iid.Equals(already_iid)) {
*ppv = pis;
pis->AddRef();
} else {
nsresult r;
Py_BEGIN_ALLOW_THREADS
r = pis->QueryInterface(iid, (void **)ppv);
Py_END_ALLOW_THREADS
if ( NS_FAILED(r) )
{
PyXPCOM_BuildPyException(r);
goto done;
}
/* note: the QI added a ref for the return value */
}
}
rc = PR_TRUE;
done:
return rc;
}
// Frames are not refcounted, no need to AddRef
NS_IMETHODIMP
nsFileControlFrame::QueryInterface(const nsIID& aIID, void** aInstancePtr)
{
NS_PRECONDITION(aInstancePtr, "null out param");
if (aIID.Equals(NS_GET_IID(nsIAnonymousContentCreator))) {
*aInstancePtr = static_cast<nsIAnonymousContentCreator*>(this);
return NS_OK;
}
if (aIID.Equals(NS_GET_IID(nsIFormControlFrame))) {
*aInstancePtr = static_cast<nsIFormControlFrame*>(this);
return NS_OK;
}
return nsAreaFrame::QueryInterface(aIID, aInstancePtr);
}
NS_IMETHODIMP
txStylesheetSink::GetInterface(const nsIID& aIID, void** aResult)
{
if (aIID.Equals(NS_GET_IID(nsIAuthPrompt))) {
NS_ENSURE_ARG(aResult);
*aResult = nullptr;
nsresult rv;
nsCOMPtr<nsIWindowWatcher> wwatcher =
do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIAuthPrompt> prompt;
rv = wwatcher->GetNewAuthPrompter(nullptr, getter_AddRefs(prompt));
NS_ENSURE_SUCCESS(rv, rv);
nsIAuthPrompt* rawPtr = nullptr;
prompt.swap(rawPtr);
*aResult = rawPtr;
return NS_OK;
}
return NS_ERROR_NO_INTERFACE;
}
/* void getInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result); */
NS_IMETHODIMP nsSDRContext::GetInterface(const nsIID & uuid, void * *result)
{
if (!uuid.Equals(NS_GET_IID(nsIPrompt)))
return NS_ERROR_NO_INTERFACE;
nsCOMPtr<nsIPrompt> prompter;
nsresult rv;
nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv));
if (NS_FAILED(rv))
return rv;
rv = wwatch->GetNewPrompter(0, getter_AddRefs(prompter));
if (!prompter)
return NS_ERROR_FAILURE;
nsCOMPtr<nsIPrompt> proxyPrompt;
rv = NS_GetProxyForObject(NS_PROXY_TO_MAIN_THREAD,
NS_GET_IID(nsIPrompt),
prompter,
NS_PROXY_SYNC,
getter_AddRefs(proxyPrompt));
if (!proxyPrompt)
return NS_ERROR_FAILURE;
*result = proxyPrompt;
NS_ADDREF((nsIPrompt*)*result);
return NS_OK;
}
NS_IMETHODIMP
FetchDriver::GetInterface(const nsIID& aIID, void **aResult)
{
if (aIID.Equals(NS_GET_IID(nsIStreamListener))) {
*aResult = static_cast<nsIStreamListener*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
if (aIID.Equals(NS_GET_IID(nsIRequestObserver))) {
*aResult = static_cast<nsIRequestObserver*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
return QueryInterface(aIID, aResult);
}
NS_IMETHODIMP
CheckPermissionsHelper::GetInterface(const nsIID& aIID,
void** aResult)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
if (aIID.Equals(NS_GET_IID(nsIObserver))) {
return QueryInterface(aIID, aResult);
}
if (aIID.Equals(NS_GET_IID(nsIDOMWindow))) {
return mWindow->QueryInterface(aIID, aResult);
}
*aResult = nullptr;
return NS_ERROR_NOT_AVAILABLE;
}
NS_IMETHODIMP
nsPrefetchNode::GetInterface(const nsIID &aIID, void **aResult)
{
if (aIID.Equals(NS_GET_IID(nsIChannelEventSink))) {
NS_ADDREF_THIS();
*aResult = static_cast<nsIChannelEventSink *>(this);
return NS_OK;
}
if (aIID.Equals(NS_GET_IID(nsIRedirectResultListener))) {
NS_ADDREF_THIS();
*aResult = static_cast<nsIRedirectResultListener *>(this);
return NS_OK;
}
return NS_ERROR_NO_INTERFACE;
}
