johnson 1.2.0 → 2.0.0.pre0

data/vendor/tracemonkey/xpconnect/src/XPCDispTearOff.cpp

@@ -0,0 +1,547 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is the IDispatch implementation for XPConnect.
+ *
+ * The Initial Developer of the Original Code is
+ * David Bradley.
+ * Portions created by the Initial Developer are Copyright (C) 2002
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+/**
+ * \file XPCDispTearOff.cpp
+ * Contains the implementation of the XPCDispTearoff class
+ */
+#include "xpcprivate.h"
+
+/**
+ * Sets the COM error from a result code and text message. This is the base
+ * implementation for subsequent string based overrides
+ * @param hResult the COM error code to be used
+ * @param message the message to put in the error
+ * @return the error code passed in via hResult
+ */
+static HRESULT Error(HRESULT hResult, const CComBSTR & message)
+{
+    CComPtr<ICreateErrorInfo> pCreateError;
+    CComPtr<IErrorInfo> pError;
+    HRESULT result = CreateErrorInfo(&pCreateError);
+    if(FAILED(result))
+        return E_NOTIMPL;
+    result = pCreateError->QueryInterface(&pError);
+    if(FAILED(result))
+        return E_NOTIMPL;
+    result = pCreateError->SetDescription(message);
+    if(FAILED(result))
+        return E_NOTIMPL;
+    result = pCreateError->SetGUID(IID_IDispatch);
+    if(FAILED(result))
+        return E_NOTIMPL;
+    CComBSTR source(L"@mozilla.XPCDispatchTearOff");
+    result = pCreateError->SetSource(source);
+    if(FAILED(result))
+        return E_NOTIMPL;
+    result = SetErrorInfo(0, pError);
+    if(FAILED(result))
+        return E_NOTIMPL;
+    return hResult;
+}
+
+
+/**
+ * Sets the COM error from a result code and text message
+ * @param hResult the COM error code to be used
+ * @param message the message to put in the error
+ * @return the error code passed in via hResult
+ */
+inline
+HRESULT Error(HRESULT hResult, const char * message)
+{
+    CComBSTR someText(message);
+    return Error(hResult, someText);
+}
+
+/**
+ * Helper function that converts an exception to a string
+ * @param exception
+ * @return the description of the exception
+ */
+static void BuildMessage(nsIException * exception, nsCString & result)
+{
+    nsXPIDLCString msg;
+    exception->GetMessageMoz(getter_Copies(msg));
+    nsXPIDLCString filename;
+    exception->GetFilename(getter_Copies(filename));
+
+    PRUint32 lineNumber;
+    if(NS_FAILED(exception->GetLineNumber(&lineNumber)))
+        lineNumber = 0;
+    result = "Error in file ";
+    result += filename;
+    result += ",#";
+    result.AppendInt(lineNumber);
+    result += " : ";
+    result += msg;
+}
+
+/**
+ * Sets the COM error given an nsIException
+ * @param exception the exception being set
+ */
+inline
+static void SetCOMError(nsIException * exception)
+{
+    nsCString message;
+    BuildMessage(exception, message);
+    Error(E_FAIL, message.get());
+}
+
+XPCDispatchTearOff::XPCDispatchTearOff(nsIXPConnectWrappedJS * wrappedJS) :
+    mWrappedJS(wrappedJS),
+    mCOMTypeInfo(nsnull),
+    mRefCnt(0)
+{
+}
+
+XPCDispatchTearOff::~XPCDispatchTearOff()
+{
+    NS_IF_RELEASE(mCOMTypeInfo);
+}
+
+NS_COM_IMPL_ADDREF(XPCDispatchTearOff)
+NS_COM_IMPL_RELEASE(XPCDispatchTearOff)
+
+// See bug 127982:
+//
+// Microsoft's InlineIsEqualGUID global function is multiply defined
+// in ATL and/or SDKs with varying namespace requirements. To save the control
+// from future grief, this method is used instead. 
+static inline BOOL _IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
+{
+   return (
+	  ((PLONG) &rguid1)[0] == ((PLONG) &rguid2)[0] &&
+	  ((PLONG) &rguid1)[1] == ((PLONG) &rguid2)[1] &&
+	  ((PLONG) &rguid1)[2] == ((PLONG) &rguid2)[2] &&
+	  ((PLONG) &rguid1)[3] == ((PLONG) &rguid2)[3]);
+}
+
+STDMETHODIMP XPCDispatchTearOff::InterfaceSupportsErrorInfo(REFIID riid)
+{
+    static const IID* arr[] = 
+    {
+        &IID_IDispatch,
+    };
+
+    for(int i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
+    {
+        if(_IsEqualGUID(*arr[i],riid))
+            return S_OK;
+    }
+    return S_FALSE;
+}
+
+STDMETHODIMP XPCDispatchTearOff::QueryInterface(const struct _GUID & guid,
+                                              void ** pPtr)
+{
+    if(IsEqualIID(guid, IID_IDispatch))
+    {
+        *pPtr = static_cast<IDispatch*>(this);
+        NS_ADDREF_THIS();
+        return NS_OK;
+    }
+
+    if(IsEqualIID(guid, IID_ISupportErrorInfo))
+    {
+        *pPtr = static_cast<IDispatch*>(this);
+        NS_ADDREF_THIS();
+        return NS_OK;
+    }
+
+    return mWrappedJS->QueryInterface(XPCDispIID2nsIID(guid), pPtr);
+}
+
+STDMETHODIMP XPCDispatchTearOff::GetTypeInfoCount(unsigned int FAR * pctinfo)
+{
+    *pctinfo = 1;
+    return S_OK;
+}
+
+XPCDispTypeInfo * XPCDispatchTearOff::GetCOMTypeInfo()
+{
+    // If one was already created return it
+    if(mCOMTypeInfo)
+        return mCOMTypeInfo;
+    // Build a new one, save the pointer and return it
+    XPCCallContext ccx(NATIVE_CALLER);
+    if(!ccx.IsValid())
+        return nsnull;
+    JSObject* obj = GetJSObject();
+    if(!obj)
+        return nsnull;
+    mCOMTypeInfo = XPCDispTypeInfo::New(ccx, obj);
+    NS_IF_ADDREF(mCOMTypeInfo);
+    return mCOMTypeInfo;
+}
+
+STDMETHODIMP XPCDispatchTearOff::GetTypeInfo(unsigned int, LCID, 
+                                         ITypeInfo FAR* FAR* ppTInfo)
+{
+    *ppTInfo = GetCOMTypeInfo();
+    NS_ADDREF(*ppTInfo);
+    return S_OK;
+}
+
+STDMETHODIMP XPCDispatchTearOff::GetIDsOfNames(REFIID riid, 
+                                           OLECHAR FAR* FAR* rgszNames, 
+                                           unsigned int cNames, LCID  lcid,
+                                           DISPID FAR* rgDispId)
+{
+    ITypeInfo * pTypeInfo = GetCOMTypeInfo();
+    if(pTypeInfo != nsnull)
+    {
+        return pTypeInfo->GetIDsOfNames(rgszNames, cNames, rgDispId);
+    }
+    return S_OK;
+}
+
+void
+xpcWrappedJSErrorReporter(JSContext *cx, const char *message,
+                          JSErrorReport *report);
+
+STDMETHODIMP XPCDispatchTearOff::Invoke(DISPID dispIdMember, REFIID riid, 
+                                        LCID lcid, WORD wFlags,
+                                        DISPPARAMS FAR* pDispParams, 
+                                        VARIANT FAR* pVarResult, 
+                                        EXCEPINFO FAR* pExcepInfo, 
+                                        unsigned int FAR* puArgErr)
+{
+    XPCDispTypeInfo* pTypeInfo = GetCOMTypeInfo();
+    if(!pTypeInfo)
+    {
+        return E_FAIL;
+    }
+    XPCCallContext ccx(NATIVE_CALLER);
+    XPCContext* xpcc;
+    JSContext* cx;
+    if(ccx.IsValid())
+    {
+        xpcc = ccx.GetXPCContext();
+        cx = ccx.GetJSContext();
+    }
+    else
+    {
+        xpcc = nsnull;
+        cx = nsnull;
+    }
+    // Get the name as a flat string
+    // This isn't that efficient, but we have to make the conversion somewhere
+    NS_LossyConvertUTF16toASCII name(pTypeInfo->GetNameForDispID(dispIdMember));
+    if(name.IsEmpty())
+        return E_FAIL;
+    // Decide if this is a getter or setter
+    PRBool getter = (wFlags & DISPATCH_PROPERTYGET) != 0;
+    PRBool setter = (wFlags & DISPATCH_PROPERTYPUT) != 0;
+    // It's a property
+    if(getter || setter)
+    {
+        jsval val;
+        uintN err;
+        JSObject* obj;
+        if(getter)
+        {
+            // Get the property and convert the value
+            obj = GetJSObject();
+            if(!obj)
+                return E_FAIL;
+            if(!JS_GetProperty(cx, obj, name.get(), &val))
+            {
+                nsCString msg("Unable to retrieve property ");
+                msg += name;
+                return Error(E_FAIL, msg.get());
+            }
+            if(!XPCDispConvert::JSToCOM(ccx, val, *pVarResult, err))
+            {
+                nsCString msg("Failed to convert value from JS property ");
+                msg += name;
+                return Error(E_FAIL, msg.get());
+            }
+        }
+        else if(pDispParams->cArgs > 0)
+        {
+            // Convert the property and then set it
+            if(!XPCDispConvert::COMToJS(ccx, pDispParams->rgvarg[0], val, err))
+            {
+                nsCString msg("Failed to convert value for JS property ");
+                msg += name;
+                return Error(E_FAIL, msg.get());
+            }
+            AUTO_MARK_JSVAL(ccx, &val);
+            obj = GetJSObject();
+            if(!obj)
+                return Error(E_FAIL, "The JS wrapper did not return a JS object");
+            if(!JS_SetProperty(cx, obj, name.get(), &val))
+            {
+                nsCString msg("Unable to set property ");
+                msg += name;
+                return Error(E_FAIL, msg.get());
+            }
+        }
+    }
+    else // We're invoking a function
+    {
+        jsval* stackbase = nsnull;
+        jsval* sp = nsnull;
+        uint8 i;
+        uint8 argc = pDispParams->cArgs;
+        uint8 stack_size;
+        jsval result;
+        uint8 paramCount=0;
+        nsresult retval = NS_ERROR_FAILURE;
+        nsresult pending_result = NS_OK;
+        JSBool success;
+        JSBool readyToDoTheCall = JS_FALSE;
+        uint8 outConversionFailedIndex;
+        JSObject* obj;
+        jsval fval;
+        nsCOMPtr<nsIException> xpc_exception;
+        void* mark;
+        JSBool foundDependentParam;
+        JSObject* thisObj;
+        AutoScriptEvaluate scriptEval(ccx);
+        XPCJSRuntime* rt = ccx.GetRuntime();
+        int j;
+
+        thisObj = obj = GetJSObject();;
+
+        if(!cx || !xpcc)
+            goto pre_call_clean_up;
+
+        scriptEval.StartEvaluating(xpcWrappedJSErrorReporter);
+
+        xpcc->SetPendingResult(pending_result);
+        xpcc->SetException(nsnull);
+        ccx.GetThreadData()->SetException(nsnull);
+
+        // We use js_AllocStack, js_Invoke, and js_FreeStack so that the gcthings
+        // we use as args will be rooted by the engine as we do conversions and
+        // prepare to do the function call. This adds a fair amount of complexity,
+        // but is a good optimization compared to calling JS_AddRoot for each item.
+
+        // setup stack
+
+        // allocate extra space for function and 'this'
+        stack_size = argc + 2;
+
+
+        // In the xpidl [function] case we are making sure now that the 
+        // JSObject is callable. If it is *not* callable then we silently 
+        // fallback to looking up the named property...
+        // (because jst says he thinks this fallback is 'The Right Thing'.)
+        //
+        // In the normal (non-function) case we just lookup the property by 
+        // name and as long as the object has such a named property we go ahead
+        // and try to make the call. If it turns out the named property is not
+        // a callable object then the JS engine will throw an error and we'll
+        // pass this along to the caller as an exception/result code.
+        fval = OBJECT_TO_JSVAL(obj);
+        if(JS_TypeOfValue(ccx, fval) != JSTYPE_FUNCTION && 
+            !JS_GetProperty(cx, obj, name.get(), &fval))
+        {
+            // XXX We really want to factor out the error reporting better and
+            // specifically report the failure to find a function with this name.
+            // This is what we do below if the property is found but is not a
+            // function. We just need to factor better so we can get to that
+            // reporting path from here.
+            goto pre_call_clean_up;
+        }
+
+        // if stack_size is zero then we won't be needing a stack
+        if(stack_size && !(stackbase = sp = js_AllocStack(cx, stack_size, &mark)))
+        {
+            retval = NS_ERROR_OUT_OF_MEMORY;
+            goto pre_call_clean_up;
+        }
+
+        // this is a function call, so push function and 'this'
+        if(stack_size != argc)
+        {
+            *sp++ = fval;
+            *sp++ = OBJECT_TO_JSVAL(thisObj);
+        }
+
+        // make certain we leave no garbage in the stack
+        for(i = 0; i < argc; i++)
+        {
+            sp[i] = JSVAL_VOID;
+        }
+
+        uintN err;
+        // build the args
+        // NOTE: COM expects args in DISPPARAMS to be in reverse order
+        for (j = argc - 1; j >= 0; --j )
+        {
+            jsval val;
+            if((pDispParams->rgvarg[j].vt & VT_BYREF) == 0)
+            {
+                if(!XPCDispConvert::COMToJS(ccx, pDispParams->rgvarg[j], val, err))
+                    goto pre_call_clean_up;
+                *sp++ = val;
+            }
+            else
+            {
+                // create an 'out' object
+                JSObject* out_obj = JS_NewObject(cx, nsnull, nsnull, nsnull);
+                if(!out_obj)
+                {
+                    retval = NS_ERROR_OUT_OF_MEMORY;
+                    goto pre_call_clean_up;
+                }
+                // We'll assume in/out
+                // TODO: I'm not sure we tell out vs in/out
+                JS_SetPropertyById(cx, out_obj,
+                        rt->GetStringID(XPCJSRuntime::IDX_VALUE),
+                        &val);
+                *sp++ = OBJECT_TO_JSVAL(out_obj);
+            }
+        }
+
+        readyToDoTheCall = JS_TRUE;
+
+pre_call_clean_up:
+
+        if(!readyToDoTheCall)
+            goto done;
+
+        // do the deed - note exceptions
+
+        JS_ClearPendingException(cx);
+
+        if(!JSVAL_IS_PRIMITIVE(fval))
+        {
+            success = js_Invoke(cx, argc, stackbase, 0);
+            result = stackbase[0];
+        }
+        else
+        {
+            // The property was not an object so can't be a function.
+            // Let's build and 'throw' an exception.
+
+            static const nsresult code =
+                    NS_ERROR_XPC_JSOBJECT_HAS_NO_FUNCTION_NAMED;
+            static const char format[] = "%s \"%s\"";
+            const char * msg;
+            char* sz = nsnull;
+
+            if(nsXPCException::NameAndFormatForNSResult(code, nsnull, &msg) && msg)
+                sz = JS_smprintf(format, msg, name);
+
+            nsCOMPtr<nsIException> e;
+
+            XPCConvert::ConstructException(code, sz, "IDispatch", name.get(),
+                                           nsnull, getter_AddRefs(e), nsnull, nsnull);
+            xpcc->SetException(e);
+            if(sz)
+                JS_smprintf_free(sz);
+        }
+
+        if(!success)
+        {
+            retval = nsXPCWrappedJSClass::CheckForException(ccx, name.get(),
+                                                            "IDispatch",
+                                                            PR_FALSE);
+            goto done;
+        }
+
+        ccx.GetThreadData()->SetException(nsnull); // XXX necessary?
+
+        // convert out args and result
+        // NOTE: this is the total number of native params, not just the args
+        // Convert independent params only.
+        // When we later convert the dependent params (if any) we will know that
+        // the params upon which they depend will have already been converted -
+        // regardless of ordering.
+
+        outConversionFailedIndex = paramCount;
+        foundDependentParam = JS_FALSE;
+        if(JSVAL_IS_VOID(result) || XPCDispConvert::JSToCOM(ccx, result, *pVarResult, err))
+        {
+            for(i = 0; i < paramCount; i++)
+            {
+                jsval val;
+                if(JSVAL_IS_PRIMITIVE(stackbase[i+2]) ||
+                        !JS_GetPropertyById(cx, JSVAL_TO_OBJECT(stackbase[i+2]),
+                            rt->GetStringID(XPCJSRuntime::IDX_VALUE),
+                            &val))
+                {
+                    outConversionFailedIndex = i;
+                    break;
+                }
+
+            }
+        }
+
+        if(outConversionFailedIndex != paramCount)
+        {
+            // We didn't manage all the result conversions!
+            // We have to cleanup any junk that *did* get converted.
+
+            for(PRUint32 index = 0; index < outConversionFailedIndex; index++)
+            {
+                if((pDispParams->rgvarg[index].vt & VT_BYREF) != 0)
+                {
+                    VariantClear(pDispParams->rgvarg + i);
+                }
+            }
+        }
+        else
+        {
+            // set to whatever the JS code might have set as the result
+            retval = pending_result;
+        }
+
+done:
+        if(sp)
+            js_FreeStack(cx, mark);
+
+        // TODO: I think we may need to translate this error, 
+        // for now we'll pass through
+        return retval;
+    }
+    return S_OK;
+}
+
+inline
+JSObject* XPCDispatchTearOff::GetJSObject()
+{
+    JSObject* obj;
+    if(NS_SUCCEEDED(mWrappedJS->GetJSObject(&obj)))
+        return obj;
+    return nsnull;
+}