johnson 1.2.0 → 2.0.0.pre0

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

@@ -0,0 +1,383 @@
+/* -*- 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 XPCDispInterface.cpp
+ * XPCDispInterface implementation
+ * This file contains the implementation of the XPCDispInterface class
+ */
+
+#include "xpcprivate.h"
+
+/**
+ * Is this function reflectable
+ * This function determines if we should reflect a particular method of an
+ * interface
+ */
+inline
+PRBool IsReflectable(FUNCDESC * pFuncDesc)
+{
+    return (pFuncDesc->wFuncFlags&FUNCFLAG_FRESTRICTED) == 0 &&
+           pFuncDesc->funckind == FUNC_DISPATCH || 
+           pFuncDesc->funckind == FUNC_PUREVIRTUAL ||
+           pFuncDesc->funckind == FUNC_VIRTUAL;
+}
+
+XPCDispInterface::Allocator::Allocator(JSContext * cx, ITypeInfo * pTypeInfo) :
+    mMemIDs(nsnull), mCount(0), mIDispatchMembers(0), mCX(cx), 
+    mTypeInfo(pTypeInfo)
+{
+    TYPEATTR * attr;
+    HRESULT hr = pTypeInfo->GetTypeAttr(&attr);
+    if(SUCCEEDED(hr))
+    {
+        mIDispatchMembers = attr->cFuncs;
+        mMemIDs = new DISPID[mIDispatchMembers];
+        pTypeInfo->ReleaseTypeAttr(attr);
+        // Bail if we couldn't create the buffer
+        if(!mMemIDs)
+            return;
+    }
+    for(UINT iMethod = 0; iMethod < mIDispatchMembers; iMethod++ )
+    {
+        FUNCDESC* pFuncDesc;
+        if(SUCCEEDED(pTypeInfo->GetFuncDesc(iMethod, &pFuncDesc)))
+        {
+            // Only add the function to our list if it is at least at nesting level
+            // 2 (i.e. defined in an interface derived from IDispatch).
+            if(IsReflectable(pFuncDesc))
+                Add(pFuncDesc->memid);
+            pTypeInfo->ReleaseFuncDesc(pFuncDesc);
+        }
+    }
+}
+
+void XPCDispInterface::Allocator::Add(DISPID memID)
+{
+    NS_ASSERTION(Valid(), "Add should never be called if out of memory");
+    // Start from the end and work backwards, the last item is the most
+    // likely to match
+    PRUint32 index = mCount;
+    while(index > 0)
+    {
+        if(mMemIDs[--index] == memID)
+            return;
+    };
+    NS_ASSERTION(Count() < mIDispatchMembers, "mCount should always be less "
+                                             "than the IDispatch member count "
+                                             "here");
+    mMemIDs[mCount++] = memID;
+    return;
+}
+
+inline
+PRUint32 XPCDispInterface::Allocator::Count() const 
+{
+    return mCount;
+}
+
+XPCDispInterface*
+XPCDispInterface::NewInstance(JSContext* cx, nsISupports * pIface)
+{
+    CComQIPtr<IDispatch> pDispatch(reinterpret_cast<IUnknown*>(pIface));
+
+    if(pDispatch)
+    {
+        unsigned int count;
+        HRESULT hr = pDispatch->GetTypeInfoCount(&count);
+        if(SUCCEEDED(hr) && count > 0)
+        {
+            CComPtr<ITypeInfo> pTypeInfo;
+            hr = pDispatch->GetTypeInfo(0,LOCALE_SYSTEM_DEFAULT, &pTypeInfo);
+            if(SUCCEEDED(hr))
+            {
+                Allocator allocator(cx, pTypeInfo);
+                return allocator.Allocate();
+            }
+        }
+    }
+    return nsnull;
+}
+
+/**
+ * Sets a members type based on COM's INVOKEKIND
+ */
+static
+void ConvertInvokeKind(INVOKEKIND invokeKind, XPCDispInterface::Member & member)
+{
+    switch (invokeKind)
+    {
+        case INVOKE_FUNC:
+        {
+            member.SetFunction();
+        }
+        break;
+        case INVOKE_PROPERTYGET:
+        {
+            member.MakeGetter();
+        }
+        break;
+        case INVOKE_PROPERTYPUT:
+        {
+            member.MakeSetter();
+        }
+        break;
+        // TODO: Handle putref
+        default:
+        {
+            NS_ERROR("Invalid invoke kind found in COM type info");
+        }
+        break;
+    }
+}
+
+static
+PRBool InitializeMember(JSContext * cx, ITypeInfo * pTypeInfo,
+                        FUNCDESC * pFuncDesc, 
+                        XPCDispInterface::Member * pInfo)
+{
+    pInfo->SetMemID(pFuncDesc->memid);
+    BSTR name;
+    UINT nameCount;
+    if(FAILED(pTypeInfo->GetNames(
+        pFuncDesc->memid,
+        &name,
+        1,
+        &nameCount)))
+        return PR_FALSE;
+    if(nameCount != 1)
+        return PR_FALSE;
+    JSString* str = JS_InternUCStringN(cx,
+                                       reinterpret_cast<const jschar *>(name),
+                                       ::SysStringLen(name));
+    ::SysFreeString(name);
+    if(!str)
+        return PR_FALSE;
+    // Initialize
+    pInfo = new (pInfo) XPCDispInterface::Member;
+    if(!pInfo)
+        return PR_FALSE;
+    pInfo->SetName(STRING_TO_JSVAL(str));
+    pInfo->ResetType();
+    ConvertInvokeKind(pFuncDesc->invkind, *pInfo);
+    pInfo->SetTypeInfo(pFuncDesc->memid, pTypeInfo, pFuncDesc);
+    return PR_TRUE;
+}
+
+static
+XPCDispInterface::Member * FindExistingMember(XPCDispInterface::Member * first,
+                                              XPCDispInterface::Member * last,
+                                              MEMBERID memberID)
+{
+    // Iterate backward since the last one in is the most likely match
+    XPCDispInterface::Member * cur = last;
+    if (cur != first)
+    {
+        do 
+        {
+            --cur;
+            if(cur->GetMemID() == memberID)
+                return cur;
+        } while(cur != first);
+    } 
+    // no existing property, return the new one
+    return last;
+}
+
+PRBool XPCDispInterface::InspectIDispatch(JSContext * cx, ITypeInfo * pTypeInfo, PRUint32 members)
+{
+    HRESULT hResult;
+
+    XPCDispInterface::Member * pInfo = mMembers;
+    mMemberCount = 0;
+    for(PRUint32 index = 0; index < members; index++ )
+    {
+        FUNCDESC* pFuncDesc;
+        hResult = pTypeInfo->GetFuncDesc(index, &pFuncDesc );
+        if(FAILED(hResult))
+            continue;
+        if(IsReflectable(pFuncDesc))
+        {
+            switch(pFuncDesc->invkind)
+            {
+                case INVOKE_PROPERTYPUT:
+                case INVOKE_PROPERTYPUTREF:
+                case INVOKE_PROPERTYGET:
+                {
+                    XPCDispInterface::Member * pExisting = FindExistingMember(mMembers, pInfo, pFuncDesc->memid);
+                    if(pExisting == pInfo)
+                    {
+                        if(InitializeMember(cx, pTypeInfo, pFuncDesc, pInfo))
+                        {
+                            ++pInfo;
+                            ++mMemberCount;
+                        }
+                    }
+                    else
+                    {
+                        ConvertInvokeKind(pFuncDesc->invkind, *pExisting);
+                    }
+                    if(pFuncDesc->invkind == INVOKE_PROPERTYGET)
+                    {
+                        pExisting->SetGetterFuncDesc(pFuncDesc);
+                    }
+                }
+                break;
+                case INVOKE_FUNC:
+                {
+                    if(InitializeMember(cx, pTypeInfo, pFuncDesc, pInfo))
+                    {
+                        ++pInfo;
+                        ++mMemberCount;
+                    }
+                }
+                break;
+                default:
+                    pTypeInfo->ReleaseFuncDesc(pFuncDesc);
+                break;
+            }
+        }
+        else
+        {
+            pTypeInfo->ReleaseFuncDesc(pFuncDesc);
+        }
+    }
+    return PR_TRUE;
+}
+
+/**
+ * Compares a PRUnichar and a JS string ignoring case
+ * @param ccx an XPConnect call context
+ * @param lhr the PRUnichar string to be compared
+ * @param lhsLength the length of the PRUnichar string
+ * @param rhs the JS value that is the other string to compare
+ * @return true if the strings are equal
+ */
+inline
+PRBool CaseInsensitiveCompare(XPCCallContext& ccx, const PRUnichar* lhs, size_t lhsLength, jsval rhs)
+{
+    if(lhsLength == 0)
+        return PR_FALSE;
+    size_t rhsLength;
+    PRUnichar* rhsString = xpc_JSString2PRUnichar(ccx, rhs, &rhsLength);
+    return rhsString && 
+        lhsLength == rhsLength &&
+        _wcsnicmp(lhs, rhsString, lhsLength) == 0;
+}
+
+const XPCDispInterface::Member* XPCDispInterface::FindMemberCI(XPCCallContext& ccx, jsval name) const
+{
+    size_t nameLength;
+    PRUnichar* sName = xpc_JSString2PRUnichar(ccx, name, &nameLength);
+    if(!sName)
+        return nsnull;
+    // Iterate backwards over the members array (more efficient)
+    const Member* member = mMembers + mMemberCount;
+    while(member > mMembers)
+    {
+        --member;
+        if(CaseInsensitiveCompare(ccx, sName, nameLength, member->GetName()))
+        {
+            return member;
+        }
+    }
+    return nsnull;
+}
+
+JSBool XPCDispInterface::Member::GetValue(XPCCallContext& ccx,
+                                          XPCNativeInterface * iface, 
+                                          jsval * retval) const
+{
+    // This is a method or attribute - we'll be needing a function object
+
+    // We need to use the safe context for this thread because we don't want
+    // to parent the new (and cached forever!) function object to the current
+    // JSContext's global object. That would be bad!
+    if((mType & RESOLVED) == 0)
+    {
+        JSContext* cx = ccx.GetSafeJSContext();
+        if(!cx)
+            return JS_FALSE;
+
+        intN argc;
+        intN flags;
+        JSNative callback;
+        // Is this a function or a parameterized getter/setter
+        if(IsFunction() || IsParameterizedProperty())
+        {
+            argc = GetParamCount();
+            flags = 0;
+            callback = XPC_IDispatch_CallMethod;
+        }
+        else
+        {
+            if(IsSetter())
+            {
+                flags = JSFUN_GETTER | JSFUN_SETTER;
+            }
+            else
+            {
+                flags = JSFUN_GETTER;
+            }
+            argc = 0;
+            callback = XPC_IDispatch_GetterSetter;
+        }
+
+        JSFunction *fun = JS_NewFunction(cx, callback, argc, flags, nsnull,
+                                         JS_GetStringBytes(JSVAL_TO_STRING(mName)));
+        if(!fun)
+            return JS_FALSE;
+
+        JSObject* funobj = JS_GetFunctionObject(fun);
+        if(!funobj)
+            return JS_FALSE;
+
+        // Store ourselves and our native interface within the JSObject
+        if(!JS_SetReservedSlot(ccx, funobj, 0, PRIVATE_TO_JSVAL(this)))
+            return JS_FALSE;
+
+        if(!JS_SetReservedSlot(ccx, funobj, 1, PRIVATE_TO_JSVAL(iface)))
+            return JS_FALSE;
+
+        {   // scoped lock
+            XPCAutoLock lock(ccx.GetRuntime()->GetMapLock());
+            const_cast<Member*>(this)->mVal = OBJECT_TO_JSVAL(funobj);
+            const_cast<Member*>(this)->mType |= RESOLVED;
+        }
+    }
+    *retval = mVal;
+    return JS_TRUE;
+}

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

@@ -0,0 +1,516 @@
+/* -*- 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 XPCDispObject.cpp
+ * Contains the XPCDispObject class implementation,
+ * XPC_IDispatch_GetterSetter, and XPC_IDispatch_CallMethod
+ */
+#include "xpcprivate.h"
+#include "nsIActiveXSecurityPolicy.h"
+
+/**
+ * This is COM's IDispatch IID, but in XPCOM's nsID type
+ */
+const nsID NSID_IDISPATCH = { 0x00020400, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 } };
+
+PRBool
+XPCDispObject::WrapIDispatch(IDispatch *pDispatch, XPCCallContext &ccx,
+                             JSObject *obj, jsval *rval)
+{
+    if(!pDispatch)
+    {
+        return PR_FALSE;
+    }
+
+    // Wrap the desired COM object
+    nsCOMPtr<nsIXPConnectJSObjectHolder> holder;
+    nsresult rv = ccx.GetXPConnect()->WrapNative(
+        ccx, obj, reinterpret_cast<nsISupports*>(pDispatch), NSID_IDISPATCH,
+        getter_AddRefs(holder));
+    if(NS_FAILED(rv) || !holder)
+    {
+        return PR_FALSE;
+    }
+    JSObject * jsobj;
+    if(NS_FAILED(holder->GetJSObject(&jsobj)))
+        return PR_FALSE;
+    *rval = OBJECT_TO_JSVAL(jsobj);
+    return PR_TRUE;
+}
+
+HRESULT XPCDispObject::SecurityCheck(XPCCallContext & ccx, const CLSID & aCID,
+                                     IDispatch ** createdObject)
+{
+    nsresult rv;
+    nsCOMPtr<nsIDispatchSupport> dispSupport = do_GetService(NS_IDISPATCH_SUPPORT_CONTRACTID, &rv);
+    if(NS_FAILED(rv)) return E_UNEXPECTED;
+
+    PRUint32 hostingFlags = nsIActiveXSecurityPolicy::HOSTING_FLAGS_HOST_NOTHING;
+    dispSupport->GetHostingFlags(nsnull, &hostingFlags);
+    PRBool allowSafeObjects;
+    if(hostingFlags & (nsIActiveXSecurityPolicy::HOSTING_FLAGS_SCRIPT_SAFE_OBJECTS))
+        allowSafeObjects = PR_TRUE;
+    else
+        allowSafeObjects = PR_FALSE;
+    PRBool allowAnyObjects;
+    if(hostingFlags & (nsIActiveXSecurityPolicy::HOSTING_FLAGS_SCRIPT_ALL_OBJECTS))
+        allowAnyObjects = PR_TRUE;
+    else
+        allowAnyObjects = PR_FALSE;
+    if(!allowSafeObjects && !allowAnyObjects)
+        return E_FAIL;
+
+    PRBool classExists = PR_FALSE;
+    PRBool ok = PR_FALSE;
+    const nsCID & ourCID = XPCDispCLSID2nsCID(aCID);
+    dispSupport->IsClassSafeToHost(ccx, ourCID, PR_FALSE, &classExists, &ok);
+    if(classExists && !ok)
+        return E_FAIL;
+
+    // Test if the object is scriptable
+    PRBool isScriptable = PR_FALSE;
+    if(!allowAnyObjects)
+    {
+        PRBool classExists = PR_FALSE;
+        dispSupport->IsClassMarkedSafeForScripting(ourCID, &classExists, &isScriptable);
+        if(!classExists)
+            return REGDB_E_CLASSNOTREG;
+    }
+
+    // Create the object
+    CComPtr<IDispatch> disp;
+    // If createdObject isn't null we need to create the object
+    if (createdObject)
+    {
+        HRESULT hr = disp.CoCreateInstance(aCID);
+        if(FAILED(hr))
+            return hr;
+        // if we don't allow just any object, and it wasn't marked 
+        // safe for scripting then ask the object (MS idea of security)
+        if (!allowAnyObjects && !isScriptable)
+        {
+            dispSupport->IsObjectSafeForScripting(disp, NSID_IDISPATCH, &isScriptable);
+            if(!isScriptable)
+                return E_FAIL;
+        }
+        disp.CopyTo(createdObject);
+    }
+
+    return S_OK;
+}
+
+HRESULT XPCDispObject::COMCreateInstance(XPCCallContext & ccx, BSTR className,
+                                         PRBool enforceSecurity,
+                                         IDispatch ** result)
+{
+    NS_ENSURE_ARG_POINTER(result);
+    // Turn the string into a CLSID
+    _bstr_t bstrName(className);
+    CLSID classID = CLSID_NULL;
+    HRESULT hr = CLSIDFromString(bstrName, &classID);
+    if(FAILED(hr))
+        hr = CLSIDFromProgID(bstrName, &classID);
+    if(FAILED(hr) || ::IsEqualCLSID(classID, CLSID_NULL))
+        return hr;
+    
+    // If the caller cares about security do the necessary checks
+    // This results in the object being instantiated, so we'll use
+    // it
+    if(enforceSecurity)
+        return SecurityCheck(ccx, classID, result);
+    
+    CComPtr<IDispatch> disp;
+    hr = disp.CoCreateInstance(classID);
+    if(FAILED(hr))
+        return hr;
+
+    disp.CopyTo(result);
+
+    return S_OK;
+}
+
+// static
+JSBool XPCDispObject::Dispatch(XPCCallContext& ccx, IDispatch * disp,
+                               DISPID dispID, CallMode mode, 
+                               XPCDispParams * params,
+                               jsval* retval,
+                               XPCDispInterface::Member * member,
+                               XPCJSRuntime* rt)
+{
+    _variant_t dispResult;
+    jsval val;
+    uintN err;
+    uintN argc = params->GetParamCount();
+    // Figure out what we're doing (getter/setter/method)
+    WORD dispFlags;
+    if(mode == CALL_SETTER)
+    {
+        dispFlags = DISPATCH_PROPERTYPUT;
+    }
+    else if(mode == CALL_GETTER)
+    {
+        dispFlags = DISPATCH_PROPERTYGET;
+    }
+    else
+    {
+        dispFlags = DISPATCH_METHOD;
+    }
+    HRESULT invokeResult;
+    EXCEPINFO exception;
+    // Scope the lock
+    {
+        // avoid deadlock in case the native method blocks somehow
+        AutoJSSuspendRequest req(ccx);  // scoped suspend of request
+        // call IDispatch's invoke
+        invokeResult= disp->Invoke(
+            dispID,                  // IDispatch ID
+            IID_NULL,                // Reserved must be IID_NULL
+            LOCALE_SYSTEM_DEFAULT,   // The locale context, use the system's
+            dispFlags,               // Type of Invoke call
+            params->GetDispParams(), // Parameters
+            &dispResult,             // Where the result is stored
+            &exception,              // Exception information
+            0);                      // Index of an argument error
+    }
+    if(SUCCEEDED(invokeResult))
+    {
+        *retval = JSVAL_VOID;
+        if(mode == CALL_METHOD)
+        {
+            NS_ASSERTION(member, "member must not be null if this is a method");
+            for(PRUint32 index = 0; index < argc; ++index)
+            {
+                const XPCDispInterface::Member::ParamInfo & paramInfo = member->GetParamInfo(index);
+                if(paramInfo.IsOut())
+                {
+                    if(!XPCDispConvert::COMToJS(ccx, params->GetParamRef(index), val, err))
+                        return ThrowBadParam(err, index, ccx);
+
+                    if(paramInfo.IsRetVal())
+                    {
+                        *retval = val;
+                    }
+                    else
+                    {
+                        jsval * argv = ccx.GetArgv();
+                        // Out, in/out parameters must be objects
+                        if(!JSVAL_IS_OBJECT(argv[index]) ||
+                            !JS_SetPropertyById(ccx, JSVAL_TO_OBJECT(argv[index]),
+                                rt->GetStringID(XPCJSRuntime::IDX_VALUE), &val))
+                            return ThrowBadParam(NS_ERROR_XPC_CANT_SET_OUT_VAL, index, ccx);
+                    }
+                }
+            }
+        }
+        if(dispResult.vt != VT_EMPTY)
+        {
+            if(!XPCDispConvert::COMToJS(ccx, dispResult, val, err))
+            {
+                ThrowBadParam(err, 0, ccx);
+            }
+            *retval = val;
+        }
+    }
+    // Set the result and throw the error if one occured
+    ccx.GetXPCContext()->SetLastResult(invokeResult);
+
+    if(NS_FAILED(invokeResult))
+    {
+        XPCThrower::ThrowCOMError(ccx, invokeResult, NS_ERROR_XPC_COM_ERROR, 
+                                  invokeResult == DISP_E_EXCEPTION ? 
+                                      &exception : nsnull);
+        return JS_FALSE;
+    }
+    return JS_TRUE;
+}
+
+JSBool XPCDispObject::Invoke(XPCCallContext & ccx, CallMode mode)
+{
+    nsresult rv = ccx.CanCallNow();
+    if(NS_FAILED(rv))
+    {
+        // If the security manager is complaining then this is not really an
+        // internal error in xpconnect. So, no reason to botch the assertion.
+        NS_ASSERTION(rv == NS_ERROR_XPC_SECURITY_MANAGER_VETO, 
+                     "hmm? CanCallNow failed in XPCDispObject::Invoke. "
+                     "We are finding out about this late!");
+        XPCThrower::Throw(rv, ccx);
+        return JS_FALSE;
+    }
+
+    // TODO: Remove type cast and change GetIDispatchMember to use the correct type
+    XPCDispInterface::Member* member = reinterpret_cast<XPCDispInterface::Member*>(ccx.GetIDispatchMember());
+    XPCJSRuntime* rt = ccx.GetRuntime();
+    XPCContext* xpcc = ccx.GetXPCContext();
+    XPCPerThreadData* tls = ccx.GetThreadData();
+    
+    jsval* argv = ccx.GetArgv();
+    uintN argc = ccx.GetArgc();
+
+    tls->SetException(nsnull);
+    xpcc->SetLastResult(NS_ERROR_UNEXPECTED);
+
+    // set up the method index and do the security check if needed
+
+    PRUint32 secFlag;
+    PRUint32 secAction;
+
+    switch(mode)
+    {
+        case CALL_METHOD:
+            secFlag   = nsIXPCSecurityManager::HOOK_CALL_METHOD;
+            secAction = nsIXPCSecurityManager::ACCESS_CALL_METHOD;
+            break;
+        case CALL_GETTER:
+            secFlag   = nsIXPCSecurityManager::HOOK_GET_PROPERTY;
+            secAction = nsIXPCSecurityManager::ACCESS_GET_PROPERTY;
+            break;
+        case CALL_SETTER:
+            secFlag   = nsIXPCSecurityManager::HOOK_SET_PROPERTY;
+            secAction = nsIXPCSecurityManager::ACCESS_SET_PROPERTY;
+            break;
+        default:
+            NS_ASSERTION(0,"bad value");
+            return JS_FALSE;
+    }
+    jsval name = member->GetName();
+
+    nsIXPCSecurityManager* sm = xpcc->GetAppropriateSecurityManager(secFlag);
+    XPCWrappedNative* wrapper = ccx.GetWrapper();
+    if(sm && NS_FAILED(sm->CanAccess(secAction, &ccx, ccx,
+                                     ccx.GetFlattenedJSObject(),
+                                     wrapper->GetIdentityObject(),
+                                     wrapper->GetClassInfo(), name,
+                                     wrapper->GetSecurityInfoAddr())))
+    {
+        // the security manager vetoed. It should have set an exception.
+        return JS_FALSE;
+    }
+
+    IDispatch * pObj = reinterpret_cast<IDispatch*>
+                                       (ccx.GetTearOff()->GetNative());
+    PRUint32 args = member->GetParamCount();
+    uintN err;
+    // Make sure setter has one argument
+    if(mode == CALL_SETTER)
+        args = 1;
+    // Allow for optional parameters. We'll let COM handle the error if there
+    // are not enough parameters
+    if(argc < args)
+        args = argc;
+    XPCDispParams * params = new XPCDispParams(args);
+    jsval val;
+    // If this is a setter, we just need to convert the first parameter
+    if(mode == CALL_SETTER)
+    {
+        params->SetNamedPropID();
+        if(!XPCDispConvert::JSToCOM(ccx, argv[0], params->GetParamRef(0), err))
+        {
+            delete params;
+            return ThrowBadParam(err, 0, ccx);
+        }
+    }
+    else if(mode != CALL_GETTER)    // This is a function
+    {
+        // Convert the arguments to the function
+        for(PRUint32 index = 0; index < args; ++index)
+        {
+            const XPCDispInterface::Member::ParamInfo & paramInfo = member->GetParamInfo(index);
+            if(paramInfo.IsIn())
+            {
+                val = argv[index];
+                if(paramInfo.IsOut())
+                {
+                    if(JSVAL_IS_PRIMITIVE(val) ||
+                        !JS_GetPropertyById(ccx, JSVAL_TO_OBJECT(val),
+                            rt->GetStringID(XPCJSRuntime::IDX_VALUE), &val))
+                    {
+                        delete params;
+                        return ThrowBadParam(NS_ERROR_XPC_NEED_OUT_OBJECT, index, ccx);
+                    }
+                    paramInfo.InitializeOutputParam(params->GetOutputBuffer(index), params->GetParamRef(index));
+                }
+                if(!XPCDispConvert::JSToCOM(ccx, val, params->GetParamRef(index), err, paramInfo.IsOut()))
+                {
+                    delete params;
+                    return ThrowBadParam(err, index, ccx);
+                }
+            }
+            else
+            {
+                paramInfo.InitializeOutputParam(params->GetOutputBuffer(index), params->GetParamRef(index));
+            }
+        }
+    }
+    // If this is a parameterized property
+    if(member->IsParameterizedProperty())
+    {
+        // We need to get a parameterized property object to return to JS
+        // NewInstance takes ownership of params
+        if(XPCDispParamPropJSClass::NewInstance(ccx, wrapper,
+                                                member->GetDispID(),
+                                                params, &val))
+        {
+            ccx.SetRetVal(val);
+            if(!JS_IdToValue(ccx, 1, &val))
+            {
+                // This shouldn't fail
+                NS_ERROR("JS_IdToValue failed in XPCDispParamPropJSClass::NewInstance");
+                return JS_FALSE;
+            }
+            JS_SetCallReturnValue2(ccx, val);
+            return JS_TRUE;
+        }
+        // NewInstance would only fail if there was an out of memory problem
+        JS_ReportOutOfMemory(ccx);
+        delete params;
+        return JS_FALSE;
+    }
+    JSBool retval = Dispatch(ccx, pObj, member->GetDispID(), mode, params, &val, member, rt);
+    if(retval && mode == CALL_SETTER)
+    {
+        ccx.SetRetVal(argv[0]);
+    }
+    else
+    {
+        ccx.SetRetVal(val);
+    }
+    delete params;
+    return retval;
+}
+
+static
+JSBool GetMember(XPCCallContext& ccx, JSObject* funobj, XPCNativeInterface*& iface, XPCDispInterface::Member*& member)
+{
+    jsval val;
+    if(!JS_GetReservedSlot(ccx, funobj, 1, &val))
+        return JS_FALSE;
+    if(!JSVAL_IS_INT(val))
+        return JS_FALSE;
+    iface = reinterpret_cast<XPCNativeInterface*>(JSVAL_TO_PRIVATE(val));
+    if(!JS_GetReservedSlot(ccx, funobj, 0, &val))
+        return JS_FALSE;
+    if(!JSVAL_IS_INT(val))
+        return JS_FALSE;
+    member = reinterpret_cast<XPCDispInterface::Member*>(JSVAL_TO_PRIVATE(val));
+    return JS_TRUE;
+}
+
+// Handy macro used in callbacks below.
+#define THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper)                         \
+    PR_BEGIN_MACRO                                                           \
+    if(!wrapper)                                                             \
+    {                                                                        \
+        XPCThrower::Throw(NS_ERROR_XPC_BAD_OP_ON_WN_PROTO, cx);              \
+        return JS_FALSE;                                                     \
+    }                                                                        \
+    if(!wrapper->IsValid())                                                  \
+    {                                                                        \
+        XPCThrower::Throw(NS_ERROR_XPC_HAS_BEEN_SHUTDOWN, cx);               \
+        return JS_FALSE;                                                     \
+    }                                                                        \
+    PR_END_MACRO
+
+/**
+ * Callback for functions
+ * This callback is called by JS when a function on a JSObject proxying
+ * for an IDispatch instance
+ * @param cx A pointer to a JS context
+ * @param obj JS object that the parameterized property is on
+ * @param argc Number of arguments in this call
+ * @param argv The parameters passed in if any
+ * @param vp The return value
+ * @return Returns JS_TRUE if the operation succeeded
+ */
+JSBool
+XPC_IDispatch_CallMethod(JSContext* cx, JSObject* obj, uintN argc,
+                         jsval* argv, jsval* vp)
+{
+    NS_ASSERTION(JS_TypeOfValue(cx, argv[-2]) == JSTYPE_FUNCTION, "bad function");
+    JSObject* funobj = JSVAL_TO_OBJECT(argv[-2]);
+    XPCCallContext ccx(JS_CALLER, cx, obj, funobj, 0, argc, argv, vp);
+    XPCWrappedNative* wrapper = ccx.GetWrapper();
+    THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper);
+    ccx.SetArgsAndResultPtr(argc, argv, vp);
+
+    XPCDispInterface::Member* member;
+    XPCNativeInterface* iface;
+#ifdef DEBUG
+    PRBool ok =
+#endif
+    GetMember(ccx, funobj, iface, member);
+    NS_ASSERTION(ok, "GetMember faild in XPC_IDispatch_CallMethod");
+    ccx.SetIDispatchInfo(iface, member);
+
+    return XPCDispObject::Invoke(ccx, XPCDispObject::CALL_METHOD);
+}
+
+/**
+ * Callback for properties
+ * This callback is called by JS when a property is set or retrieved on a 
+ * JSObject proxying for an IDispatch instance
+ * @param cx A pointer to a JS context
+ * @param obj JS object that the parameterized property is on
+ * @param argc Number of arguments in this call
+ * @param argv The parameters passed in if any
+ * @param vp The return value
+ * @return Returns JS_TRUE if the operation succeeded
+ */
+JSBool
+XPC_IDispatch_GetterSetter(JSContext *cx, JSObject *obj, uintN argc,
+                           jsval *argv, jsval *vp)
+{
+    NS_ASSERTION(JS_TypeOfValue(cx, argv[-2]) == JSTYPE_FUNCTION, "bad function");
+    JSObject* funobj = JSVAL_TO_OBJECT(argv[-2]);
+
+    XPCCallContext ccx(JS_CALLER, cx, obj, funobj);
+    XPCWrappedNative* wrapper = ccx.GetWrapper();
+    THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper);
+
+    ccx.SetArgsAndResultPtr(argc, argv, vp);
+    XPCDispInterface::Member* member;
+    XPCNativeInterface* iface;
+#ifdef DEBUG
+    PRBool ok =
+#endif
+    GetMember(ccx, funobj, iface, member);
+    NS_ASSERTION(ok, "GetMember faild in XPC_IDispatch_CallMethod");
+
+    ccx.SetIDispatchInfo(iface, member);
+    return XPCDispObject::Invoke(ccx, argc != 0 ? XPCDispObject::CALL_SETTER : XPCDispObject::CALL_GETTER);
+}