johnson 1.2.0 → 2.0.0.pre0

data/vendor/tracemonkey/xpconnect/src/xpc.msg

@@ -0,0 +1,217 @@
+/* -*- 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 Mozilla Communicator client code, released
+ * March 31, 1998.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1998
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   John Bandhauer <jband@netscape.com> (original author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of 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 ***** */
+
+/* Error Message definitions. */
+
+
+/* xpconnect specific codes (from nsIXPConnect.h) */
+
+XPC_MSG_DEF(NS_ERROR_XPC_NOT_ENOUGH_ARGS                , "Not enough arguments")
+XPC_MSG_DEF(NS_ERROR_XPC_NEED_OUT_OBJECT                , "'Out' argument must be an object")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_SET_OUT_VAL               , "Cannot set 'value' property of 'out' argument")
+XPC_MSG_DEF(NS_ERROR_XPC_NATIVE_RETURNED_FAILURE        , "Component returned failure code:")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_GET_INTERFACE_INFO        , "Cannot find interface information")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_GET_PARAM_IFACE_INFO      , "Cannot find interface information for parameter")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_GET_METHOD_INFO           , "Cannot find method information")
+XPC_MSG_DEF(NS_ERROR_XPC_UNEXPECTED                     , "Unexpected error in XPConnect")
+XPC_MSG_DEF(NS_ERROR_XPC_BAD_CONVERT_JS                 , "Could not convert JavaScript argument")
+XPC_MSG_DEF(NS_ERROR_XPC_BAD_CONVERT_NATIVE             , "Could not convert Native argument")
+XPC_MSG_DEF(NS_ERROR_XPC_BAD_CONVERT_JS_NULL_REF        , "Could not convert JavaScript argument (NULL value cannot be used for a C++ reference type)")
+XPC_MSG_DEF(NS_ERROR_XPC_BAD_OP_ON_WN_PROTO             , "Illegal operation on WrappedNative prototype object")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_CONVERT_WN_TO_FUN         , "Cannot convert WrappedNative to function")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_DEFINE_PROP_ON_WN         , "Cannot define new property in a WrappedNative")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_WATCH_WN_STATIC           , "Cannot place watchpoints on WrappedNative object static properties")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_EXPORT_WN_STATIC          , "Cannot export a WrappedNative object's static properties")
+XPC_MSG_DEF(NS_ERROR_XPC_SCRIPTABLE_CALL_FAILED         , "nsIXPCScriptable::Call failed")
+XPC_MSG_DEF(NS_ERROR_XPC_SCRIPTABLE_CTOR_FAILED         , "nsIXPCScriptable::Construct failed")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_CALL_WO_SCRIPTABLE        , "Cannot use wrapper as function unless it implements nsIXPCScriptable")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_CTOR_WO_SCRIPTABLE        , "Cannot use wrapper as constructor unless it implements nsIXPCScriptable")
+XPC_MSG_DEF(NS_ERROR_XPC_CI_RETURNED_FAILURE            , "ComponentManager::CreateInstance returned failure code:")
+XPC_MSG_DEF(NS_ERROR_XPC_GS_RETURNED_FAILURE            , "ServiceManager::GetService returned failure code:")
+XPC_MSG_DEF(NS_ERROR_XPC_BAD_CID                        , "Invalid ClassID or ContractID")
+XPC_MSG_DEF(NS_ERROR_XPC_BAD_IID                        , "Invalid InterfaceID")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_CREATE_WN                 , "Cannot create wrapper around native interface")
+XPC_MSG_DEF(NS_ERROR_XPC_JS_THREW_EXCEPTION             , "JavaScript component threw exception")
+XPC_MSG_DEF(NS_ERROR_XPC_JS_THREW_NATIVE_OBJECT         , "JavaScript component threw a native object that is not an exception")
+XPC_MSG_DEF(NS_ERROR_XPC_JS_THREW_JS_OBJECT             , "JavaScript component threw a JavaScript object")
+XPC_MSG_DEF(NS_ERROR_XPC_JS_THREW_NULL                  , "JavaScript component threw a null value as an exception")
+XPC_MSG_DEF(NS_ERROR_XPC_JS_THREW_STRING                , "JavaScript component threw a string as an exception")
+XPC_MSG_DEF(NS_ERROR_XPC_JS_THREW_NUMBER                , "JavaScript component threw a number as an exception")
+XPC_MSG_DEF(NS_ERROR_XPC_JAVASCRIPT_ERROR               , "JavaScript component caused a JavaScript error")
+XPC_MSG_DEF(NS_ERROR_XPC_JAVASCRIPT_ERROR_WITH_DETAILS  , "JavaScript component caused a JavaScript error (detailed report attached)")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_CONVERT_PRIMITIVE_TO_ARRAY, "Cannot convert primitive JavaScript value into an array")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_CONVERT_OBJECT_TO_ARRAY   , "Cannot convert JavaScript object into an array")
+XPC_MSG_DEF(NS_ERROR_XPC_NOT_ENOUGH_ELEMENTS_IN_ARRAY   , "JavaScript Array does not have as many elements as indicated by size argument")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_GET_ARRAY_INFO            , "Cannot find array information")
+XPC_MSG_DEF(NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING     , "JavaScript String does not have as many characters as indicated by size argument")
+XPC_MSG_DEF(NS_ERROR_XPC_SECURITY_MANAGER_VETO          , "Security Manager vetoed action")
+XPC_MSG_DEF(NS_ERROR_XPC_INTERFACE_NOT_SCRIPTABLE       , "Failed to build a wrapper because the interface that was not declared [scriptable]")
+XPC_MSG_DEF(NS_ERROR_XPC_INTERFACE_NOT_FROM_NSISUPPORTS , "Failed to build a wrapper because the interface does not inherit from nsISupports")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_GET_JSOBJECT_OF_DOM_OBJECT, "Cannot get JavaScript object for DOM object")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_SET_READ_ONLY_CONSTANT    , "Property is a constant and cannot be changed")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_SET_READ_ONLY_ATTRIBUTE   , "Property is a read only attribute and cannot be changed")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_SET_READ_ONLY_METHOD      , "Property is an interface method and cannot be changed")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_ADD_PROP_TO_WRAPPED_NATIVE, "Cannot add property to WrappedNative object")
+XPC_MSG_DEF(NS_ERROR_XPC_CALL_TO_SCRIPTABLE_FAILED      , "Call to nsIXPCScriptable interface for WrappedNative failed unexpecedly")
+XPC_MSG_DEF(NS_ERROR_XPC_JSOBJECT_HAS_NO_FUNCTION_NAMED , "JavaScript component does not have a method named:")
+XPC_MSG_DEF(NS_ERROR_XPC_BAD_ID_STRING                  , "Bad ID string")
+XPC_MSG_DEF(NS_ERROR_XPC_BAD_INITIALIZER_NAME           , "Bad initializer name in Constructor - Component has no method with that name")
+XPC_MSG_DEF(NS_ERROR_XPC_HAS_BEEN_SHUTDOWN              , "Operation failed because the XPConnect subsystem has been shutdown")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_MODIFY_PROP_ON_WN         , "Cannot modify properties of a WrappedNative")
+XPC_MSG_DEF(NS_ERROR_XPC_BAD_CONVERT_JS_ZERO_ISNOT_NULL , "Could not convert JavaScript argument - 0 was passed, expected object. Did you mean null?")
+
+
+/* common global codes (from nsError.h) */
+
+XPC_MSG_DEF(NS_OK                                  , "Success")
+XPC_MSG_DEF(NS_ERROR_NOT_INITIALIZED               , "Component not initialized")
+XPC_MSG_DEF(NS_ERROR_ALREADY_INITIALIZED           , "Component already initialized")
+XPC_MSG_DEF(NS_ERROR_NOT_IMPLEMENTED               , "Method not implemented")
+XPC_MSG_DEF(NS_NOINTERFACE                         , "Component does not have requested interface")
+XPC_MSG_DEF(NS_ERROR_NO_INTERFACE                  , "Component does not have requested interface")
+XPC_MSG_DEF(NS_ERROR_INVALID_POINTER               , "Invalid pointer")
+XPC_MSG_DEF(NS_ERROR_NULL_POINTER                  , "Null pointer")
+XPC_MSG_DEF(NS_ERROR_ABORT                         , "Abort")
+XPC_MSG_DEF(NS_ERROR_FAILURE                       , "Failure")
+XPC_MSG_DEF(NS_ERROR_UNEXPECTED                    , "Unexpected error")
+XPC_MSG_DEF(NS_ERROR_OUT_OF_MEMORY                 , "Out of Memory")
+XPC_MSG_DEF(NS_ERROR_ILLEGAL_VALUE                 , "Illegal value")
+XPC_MSG_DEF(NS_ERROR_INVALID_ARG                   , "Invalid argument")
+XPC_MSG_DEF(NS_ERROR_NO_AGGREGATION                , "Component does not support aggregation")
+XPC_MSG_DEF(NS_ERROR_NOT_AVAILABLE                 , "Component is not available")
+XPC_MSG_DEF(NS_ERROR_FACTORY_NOT_REGISTERED        , "Factory not registered")
+XPC_MSG_DEF(NS_ERROR_FACTORY_REGISTER_AGAIN        , "Factory not registered (may be tried again)")
+XPC_MSG_DEF(NS_ERROR_FACTORY_NOT_LOADED            , "Factory not loaded")
+XPC_MSG_DEF(NS_ERROR_FACTORY_NO_SIGNATURE_SUPPORT  , "Factory does not support signatures")
+XPC_MSG_DEF(NS_ERROR_FACTORY_EXISTS                , "Factory already exists")
+XPC_MSG_DEF(NS_ERROR_PROXY_INVALID_IN_PARAMETER    , "Invalid input parameter in call to proxy")
+XPC_MSG_DEF(NS_ERROR_PROXY_INVALID_OUT_PARAMETER   , "Invalid output parameter in call to proxy")
+
+/* added from nsError.h on Feb 28 2001... */
+
+XPC_MSG_DEF(NS_BASE_STREAM_CLOSED                   , "Stream closed")
+XPC_MSG_DEF(NS_BASE_STREAM_OSERROR                  , "Error from the operating system")
+XPC_MSG_DEF(NS_BASE_STREAM_ILLEGAL_ARGS             , "Illegal arguments")
+XPC_MSG_DEF(NS_BASE_STREAM_NO_CONVERTER             , "No converter for unichar streams")
+XPC_MSG_DEF(NS_BASE_STREAM_BAD_CONVERSION           , "Bad converter for unichar streams")
+XPC_MSG_DEF(NS_BASE_STREAM_WOULD_BLOCK              , "Stream would block")
+
+XPC_MSG_DEF(NS_ERROR_FILE_UNRECOGNIZED_PATH         , "File error: Unrecognized path")
+XPC_MSG_DEF(NS_ERROR_FILE_UNRESOLVABLE_SYMLINK      , "File error: Unresolvable symlink")
+XPC_MSG_DEF(NS_ERROR_FILE_EXECUTION_FAILED          , "File error: Execution failed")
+XPC_MSG_DEF(NS_ERROR_FILE_UNKNOWN_TYPE              , "File error: Unknown type")
+XPC_MSG_DEF(NS_ERROR_FILE_DESTINATION_NOT_DIR       , "File error: Destination not dir")
+XPC_MSG_DEF(NS_ERROR_FILE_TARGET_DOES_NOT_EXIST     , "File error: Target does not exist")
+XPC_MSG_DEF(NS_ERROR_FILE_COPY_OR_MOVE_FAILED       , "File error: Copy or move failed")
+XPC_MSG_DEF(NS_ERROR_FILE_ALREADY_EXISTS            , "File error: Already exists")
+XPC_MSG_DEF(NS_ERROR_FILE_INVALID_PATH              , "File error: Invalid path")
+XPC_MSG_DEF(NS_ERROR_FILE_DISK_FULL                 , "File error: Disk full")
+XPC_MSG_DEF(NS_ERROR_FILE_CORRUPTED                 , "File error: Corrupted")
+XPC_MSG_DEF(NS_ERROR_FILE_NOT_DIRECTORY             , "File error: Not directory")
+XPC_MSG_DEF(NS_ERROR_FILE_IS_DIRECTORY              , "File error: Is directory")
+XPC_MSG_DEF(NS_ERROR_FILE_IS_LOCKED                 , "File error: Is locked")
+XPC_MSG_DEF(NS_ERROR_FILE_TOO_BIG                   , "File error: Too big")
+XPC_MSG_DEF(NS_ERROR_FILE_NO_DEVICE_SPACE           , "File error: No device space")
+XPC_MSG_DEF(NS_ERROR_FILE_NAME_TOO_LONG             , "File error: Name too long")
+XPC_MSG_DEF(NS_ERROR_FILE_NOT_FOUND                 , "File error: Not found")
+XPC_MSG_DEF(NS_ERROR_FILE_READ_ONLY                 , "File error: Read only")
+XPC_MSG_DEF(NS_ERROR_FILE_DIR_NOT_EMPTY             , "File error: Dir not empty")
+XPC_MSG_DEF(NS_ERROR_FILE_ACCESS_DENIED             , "File error: Access denied")
+
+/* added from nsError.h on Sept 6 2001... */
+
+XPC_MSG_DEF(NS_ERROR_CANNOT_CONVERT_DATA            , "Data conversion error")
+XPC_MSG_DEF(NS_ERROR_OBJECT_IS_IMMUTABLE            , "Can not modify immutable data container")
+XPC_MSG_DEF(NS_ERROR_LOSS_OF_SIGNIFICANT_DATA       , "Data conversion failed because significant data would be lost")
+XPC_MSG_DEF(NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA   , "Data conversion succeeded but data was rounded to fit")
+
+#ifdef XPC_IDISPATCH_SUPPORT
+XPC_MSG_DEF(NS_ERROR_XPC_COM_UNKNOWN                , "Unknown COM error occured")
+XPC_MSG_DEF(NS_ERROR_XPC_COM_ERROR                  , "COM Error")
+XPC_MSG_DEF(NS_ERROR_XPC_COM_INVALID_CLASS_ID       , "Invalid class ID")
+XPC_MSG_DEF(NS_ERROR_XPC_COM_CREATE_FAILED          , "Unable to create an instance of the desired COM class")
+XPC_MSG_DEF(NS_ERROR_XPC_IDISPATCH_NOT_ENABLED      , "IDispatch support is not enabled")
+#endif
+
+/* network related codes (from nsNetError.h) */
+
+XPC_MSG_DEF(NS_BINDING_FAILED                       , "The async request failed for some unknown reason")
+XPC_MSG_DEF(NS_BINDING_ABORTED                      , "The async request failed because it was aborted by some user action")
+XPC_MSG_DEF(NS_BINDING_REDIRECTED                   , "The async request has been redirected to a different async request")
+XPC_MSG_DEF(NS_BINDING_RETARGETED                   , "The async request has been retargeted to a different handler")
+XPC_MSG_DEF(NS_ERROR_MALFORMED_URI                  , "The URI is malformed")
+XPC_MSG_DEF(NS_ERROR_UNKNOWN_PROTOCOL               , "The URI scheme corresponds to an unknown protocol handler")
+XPC_MSG_DEF(NS_ERROR_NO_CONTENT                     , "Channel opened successfully but no data will be returned")
+XPC_MSG_DEF(NS_ERROR_IN_PROGRESS                    , "The requested action could not be completed while the object is busy")
+XPC_MSG_DEF(NS_ERROR_ALREADY_OPENED                 , "Channel is already open")
+XPC_MSG_DEF(NS_ERROR_INVALID_CONTENT_ENCODING       , "The content encoding of the source document is incorrect")
+XPC_MSG_DEF(NS_ERROR_ALREADY_CONNECTED              , "The connection is already established")
+XPC_MSG_DEF(NS_ERROR_NOT_CONNECTED                  , "The connection does not exist")
+XPC_MSG_DEF(NS_ERROR_CONNECTION_REFUSED             , "The connection was refused")
+XPC_MSG_DEF(NS_ERROR_PROXY_CONNECTION_REFUSED       , "The connection to the proxy server was refused")
+XPC_MSG_DEF(NS_ERROR_NET_TIMEOUT                    , "The connection has timed out")
+XPC_MSG_DEF(NS_ERROR_OFFLINE                        , "The requested action could not be completed in the offline state")
+XPC_MSG_DEF(NS_ERROR_PORT_ACCESS_NOT_ALLOWED        , "Establishing a connection to an unsafe or otherwise banned port was prohibited")
+XPC_MSG_DEF(NS_ERROR_NET_RESET                      , "The connection was established, but no data was ever received")
+XPC_MSG_DEF(NS_ERROR_NET_INTERRUPT                  , "The connection was established, but the data transfer was interrupted")
+XPC_MSG_DEF(NS_ERROR_NOT_RESUMABLE                  , "This request is not resumable, but it was tried to resume it, or to request resume-specific data")
+XPC_MSG_DEF(NS_ERROR_ENTITY_CHANGED                 , "It was attempted to resume the request, but the entity has changed in the meantime")
+XPC_MSG_DEF(NS_ERROR_REDIRECT_LOOP                  , "The request failed as a result of a detected redirection loop")
+XPC_MSG_DEF(NS_ERROR_UNSAFE_CONTENT_TYPE            , "The request failed because the content type returned by the server was not a type expected by the channel")
+XPC_MSG_DEF(NS_ERROR_FTP_LOGIN                      , "FTP error while logging in")
+XPC_MSG_DEF(NS_ERROR_FTP_CWD                        , "FTP error while changing directory")
+XPC_MSG_DEF(NS_ERROR_FTP_PASV                       , "FTP error while changing to passive mode")
+XPC_MSG_DEF(NS_ERROR_FTP_PWD                        , "FTP error while retrieving current directory")
+XPC_MSG_DEF(NS_ERROR_FTP_LIST                       , "FTP error while retrieving a directory listing")
+XPC_MSG_DEF(NS_ERROR_UNKNOWN_HOST                   , "The lookup of the hostname failed")
+XPC_MSG_DEF(NS_ERROR_UNKNOWN_PROXY_HOST             , "The lookup of the proxy hostname failed")
+XPC_MSG_DEF(NS_ERROR_UNKNOWN_SOCKET_TYPE            , "The specified socket type does not exist")
+XPC_MSG_DEF(NS_ERROR_SOCKET_CREATE_FAILED           , "The specified socket type could not be created")
+XPC_MSG_DEF(NS_ERROR_CACHE_KEY_NOT_FOUND            , "Cache key could not be found")
+XPC_MSG_DEF(NS_ERROR_CACHE_DATA_IS_STREAM           , "Cache data is a stream")
+XPC_MSG_DEF(NS_ERROR_CACHE_DATA_IS_NOT_STREAM       , "Cache data is not a stream")
+XPC_MSG_DEF(NS_ERROR_CACHE_WAIT_FOR_VALIDATION      , "Cache entry exists but needs to be validated first")
+XPC_MSG_DEF(NS_ERROR_CACHE_ENTRY_DOOMED             , "Cache entry has been  doomed")
+XPC_MSG_DEF(NS_ERROR_CACHE_READ_ACCESS_DENIED       , "Read access to cache denied")
+XPC_MSG_DEF(NS_ERROR_CACHE_WRITE_ACCESS_DENIED      , "Write access to cache denied")
+XPC_MSG_DEF(NS_ERROR_CACHE_IN_USE                   , "Cache is currently in use")
+XPC_MSG_DEF(NS_ERROR_DOCUMENT_NOT_CACHED            , "Document does not exist in cache")
+XPC_MSG_DEF(NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS     , "The requested number of domain levels exceeds those present in the host string")
+XPC_MSG_DEF(NS_ERROR_HOST_IS_IP_ADDRESS             , "The host string is an IP address")

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

@@ -0,0 +1,148 @@
+/* ***** 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 Mozilla code.
+ *
+ * The Initial Developer of the Original Code is Alex Fritze.
+ * Portions created by the Initial Developer are Copyright (C) 2004
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Alex Fritze <alex@croczilla.com> (original author)
+ *
+ * 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 ***** */
+
+#include "xpcJSWeakReference.h"
+#include "xpcprivate.h"
+
+xpcJSWeakReference::xpcJSWeakReference()
+{
+}
+
+NS_IMPL_ISUPPORTS1(xpcJSWeakReference, xpcIJSWeakReference)
+
+nsresult xpcJSWeakReference::Init()
+{
+    nsresult rv;
+    
+    nsXPConnect* xpc = nsXPConnect::GetXPConnect();
+    if (!xpc) return NS_ERROR_UNEXPECTED;
+    
+    nsAXPCNativeCallContext *cc = nsnull;
+    rv = xpc->GetCurrentNativeCallContext(&cc);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    JSContext *cx = nsnull;
+    rv = cc->GetJSContext(&cx);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    PRUint32 argc = 0;
+    rv = cc->GetArgc(&argc);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (argc != 1) return NS_ERROR_FAILURE;
+    
+    jsval *argv = nsnull;
+    rv = cc->GetArgvPtr(&argv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    JSAutoRequest ar(cx);
+
+    if (JSVAL_IS_NULL(argv[0])) return NS_ERROR_FAILURE;
+    
+    JSObject *obj;
+    if (!JS_ValueToObject(cx, argv[0], &obj))
+        return NS_ERROR_FAILURE;
+    
+    XPCCallContext ccx(NATIVE_CALLER, cx);
+    
+    nsRefPtr<nsXPCWrappedJS> wrapped;
+    rv = nsXPCWrappedJS::GetNewOrUsed(ccx,
+                                      obj,
+                                      NS_GET_IID(nsISupports),
+                                      nsnull,
+                                      getter_AddRefs(wrapped));
+    if (!wrapped) {
+        NS_ERROR("can't get nsISupportsWeakReference wrapper for obj");
+        return rv;
+    }
+
+    return static_cast<nsISupportsWeakReference*>(wrapped)->
+        GetWeakReference(getter_AddRefs(mWrappedJSObject));
+}
+
+NS_IMETHODIMP
+xpcJSWeakReference::Get()
+{
+    nsresult rv;
+
+    nsXPConnect* xpc = nsXPConnect::GetXPConnect();
+    if (!xpc)
+        return NS_ERROR_UNEXPECTED;
+
+    nsAXPCNativeCallContext* cc = nsnull;
+    rv = xpc->GetCurrentNativeCallContext(&cc);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    JSContext *cx;
+    cc->GetJSContext(&cx);
+    if (!cx)
+        return NS_ERROR_UNEXPECTED;
+
+    jsval *retval = nsnull;
+    cc->GetRetValPtr(&retval);
+    if (!retval)
+        return NS_ERROR_UNEXPECTED;
+    *retval = JSVAL_NULL;
+
+    nsCOMPtr<nsIXPConnectWrappedJS> wrappedObj;
+
+    if (mWrappedJSObject &&
+        NS_SUCCEEDED(mWrappedJSObject->QueryReferent(NS_GET_IID(nsIXPConnectWrappedJS), getter_AddRefs(wrappedObj))) &&
+        wrappedObj) {
+        JSObject *obj;
+        wrappedObj->GetJSObject(&obj);
+        if (obj)
+        {
+            // Most users of XPCWrappedJS don't need to worry about
+            // re-wrapping because things are implicitly rewrapped by
+            // xpcconvert. However, because we're doing this directly
+            // through the native call context, we need to call
+            // nsXPConnect::GetWrapperForObject. But it takes a lot of
+            // arguments! It turns out that the thisObject hook on XPConnect
+            // objects does the right thing though, so...
+
+            if (obj->map->ops->thisObject &&
+                !(obj = obj->map->ops->thisObject(cx, obj)))
+            {
+                return NS_ERROR_FAILURE;
+            }
+
+            *retval = OBJECT_TO_JSVAL(obj);
+        }
+    }
+
+    return NS_OK;
+}

data/vendor/tracemonkey/xpconnect/src/xpcJSWeakReference.h

@@ -0,0 +1,56 @@
+/* ***** 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 Mozilla code.
+ *
+ * The Initial Developer of the Original Code is Alex Fritze.
+ * Portions created by the Initial Developer are Copyright (C) 2004
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Alex Fritze <alex@croczilla.com> (original author)
+ *
+ * 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 ***** */
+
+#ifndef xpcjsweakreference_h___
+#define xpcjsweakreference_h___
+
+#include "xpcIJSWeakReference.h"
+#include "nsIWeakReference.h"
+
+class xpcJSWeakReference : public xpcIJSWeakReference
+{
+public:
+    xpcJSWeakReference();
+    nsresult Init();
+
+    NS_DECL_ISUPPORTS
+    NS_DECL_XPCIJSWEAKREFERENCE
+    
+private:
+    nsCOMPtr<nsIWeakReference> mWrappedJSObject;
+};
+
+#endif // xpcjsweakreference_h___

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

@@ -0,0 +1,579 @@
+/* -*- 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 Mozilla Communicator client code, released
+ * March 31, 1998.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1998
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   John Bandhauer <jband@netscape.com> (original author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of 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 ***** */
+
+/* Call context. */
+
+#include "xpcprivate.h"
+
+XPCCallContext::XPCCallContext(XPCContext::LangType callerLanguage,
+                               JSContext* cx    /* = nsnull  */,
+                               JSObject* obj    /* = nsnull  */,
+                               JSObject* funobj /* = nsnull  */,
+                               jsval name       /* = 0       */,
+                               uintN argc       /* = NO_ARGS */,
+                               jsval *argv      /* = nsnull  */,
+                               jsval *rval      /* = nsnull  */)
+    :   mState(INIT_FAILED),
+        mXPC(nsXPConnect::GetXPConnect()),
+        mThreadData(nsnull),
+        mXPCContext(nsnull),
+        mJSContext(cx),
+        mContextPopRequired(JS_FALSE),
+        mDestroyJSContextInDestructor(JS_FALSE),
+        mCallerLanguage(callerLanguage),
+        mCallee(nsnull)
+{
+    // Mark our internal string wrappers as not used. Make sure we do
+    // this before any early returns, as the destructor will assert
+    // based on this.
+    StringWrapperEntry *se =
+        reinterpret_cast<StringWrapperEntry*>(&mStringWrapperData);
+
+    PRUint32 i;
+    for(i = 0; i < XPCCCX_STRING_CACHE_SIZE; ++i)
+    {
+        se[i].mInUse = PR_FALSE;
+    }
+
+    if(!mXPC)
+        return;
+
+    mThreadData = XPCPerThreadData::GetData(mJSContext);
+
+    if(!mThreadData)
+        return;
+
+    XPCJSContextStack* stack = mThreadData->GetJSContextStack();
+    JSContext* topJSContext;
+
+    if(!stack || NS_FAILED(stack->Peek(&topJSContext)))
+    {
+        // If we don't have a stack we're probably in shutdown.
+        NS_ASSERTION(!stack, "Bad, Peek failed!");
+        mJSContext = nsnull;
+        return;
+    }
+
+    if(!mJSContext)
+    {
+        // This is slightly questionable. If called without an explicit
+        // JSContext (generally a call to a wrappedJS) we will use the JSContext
+        // on the top of the JSContext stack - if there is one - *before*
+        // falling back on the safe JSContext.
+        // This is good AND bad because it makes calls from JS -> native -> JS
+        // have JS stack 'continuity' for purposes of stack traces etc.
+        // Note: this *is* what the pre-XPCCallContext xpconnect did too.
+
+        if(topJSContext)
+            mJSContext = topJSContext;
+        else if(NS_FAILED(stack->GetSafeJSContext(&mJSContext)) || !mJSContext)
+            return;
+    }
+
+    // Get into the request as early as we can to avoid problems with scanning
+    // callcontexts on other threads from within the gc callbacks.
+
+    if(mCallerLanguage == NATIVE_CALLER)
+        JS_BeginRequest(mJSContext);
+
+    if(topJSContext != mJSContext)
+    {
+        if(NS_FAILED(stack->Push(mJSContext)))
+        {
+            NS_ERROR("bad!");
+            return;
+        }
+        mContextPopRequired = JS_TRUE;
+    }
+
+    mXPCContext = XPCContext::GetXPCContext(mJSContext);
+    mPrevCallerLanguage = mXPCContext->SetCallingLangType(mCallerLanguage);
+
+    // hook into call context chain for our thread
+    mPrevCallContext = mThreadData->SetCallContext(this);
+
+    // We only need to addref xpconnect once so only do it if this is the first
+    // context in the chain.
+    if(!mPrevCallContext)
+        NS_ADDREF(mXPC);
+
+    mState = HAVE_CONTEXT;
+
+    if(!obj)
+        return;
+
+    mMethodIndex = 0xDEAD;
+    mOperandJSObject = obj;
+
+    mState = HAVE_OBJECT;
+
+    mTearOff = nsnull;
+    mWrapper = XPCWrappedNative::GetWrappedNativeOfJSObject(mJSContext, obj,
+                                                            funobj,
+                                                            &mCurrentJSObject,
+                                                            &mTearOff);
+    if(!mWrapper)
+        return;
+
+    DEBUG_CheckWrapperThreadSafety(mWrapper);
+
+    mFlattenedJSObject = mWrapper->GetFlatJSObject();
+
+    if(mTearOff)
+        mScriptableInfo = nsnull;
+    else
+        mScriptableInfo = mWrapper->GetScriptableInfo();
+
+    if(name)
+        SetName(name);
+
+    if(argc != NO_ARGS)
+        SetArgsAndResultPtr(argc, argv, rval);
+
+    CHECK_STATE(HAVE_OBJECT);
+}
+
+void
+XPCCallContext::SetName(jsval name)
+{
+    CHECK_STATE(HAVE_OBJECT);
+
+    mName = name;
+
+#ifdef XPC_IDISPATCH_SUPPORT
+    mIDispatchMember = nsnull;
+#endif
+    if(mTearOff)
+    {
+        mSet = nsnull;
+        mInterface = mTearOff->GetInterface();
+        mMember = mInterface->FindMember(name);
+        mStaticMemberIsLocal = JS_TRUE;
+        if(mMember && !mMember->IsConstant())
+            mMethodIndex = mMember->GetIndex();
+    }
+    else
+    {
+        mSet = mWrapper ? mWrapper->GetSet() : nsnull;
+
+        if(mSet &&
+           mSet->FindMember(name, &mMember, &mInterface,
+                            mWrapper->HasProto() ?
+                                mWrapper->GetProto()->GetSet() :
+                                nsnull,
+                            &mStaticMemberIsLocal))
+        {
+            if(mMember && !mMember->IsConstant())
+                mMethodIndex = mMember->GetIndex();
+        }
+        else
+        {
+            mMember = nsnull;
+            mInterface = nsnull;
+            mStaticMemberIsLocal = JS_FALSE;
+        }
+    }
+
+    mState = HAVE_NAME;
+}
+
+void
+XPCCallContext::SetCallInfo(XPCNativeInterface* iface, XPCNativeMember* member,
+                            JSBool isSetter)
+{
+    CHECK_STATE(HAVE_CONTEXT);
+
+    // We are going straight to the method info and need not do a lookup
+    // by id.
+
+    // don't be tricked if method is called with wrong 'this'
+    if(mTearOff && mTearOff->GetInterface() != iface)
+        mTearOff = nsnull;
+
+    mSet = nsnull;
+    mInterface = iface;
+    mMember = member;
+    mMethodIndex = mMember->GetIndex() + (isSetter ? 1 : 0);
+    mName = mMember->GetName();
+
+    if(mState < HAVE_NAME)
+        mState = HAVE_NAME;
+#ifdef XPC_IDISPATCH_SUPPORT
+    mIDispatchMember = nsnull;
+#endif
+}
+
+void
+XPCCallContext::SetArgsAndResultPtr(uintN argc,
+                                    jsval *argv,
+                                    jsval *rval)
+{
+    CHECK_STATE(HAVE_OBJECT);
+
+    if(mState < HAVE_NAME)
+    {
+        mSet = nsnull;
+        mInterface = nsnull;
+        mMember = nsnull;
+#ifdef XPC_IDISPATCH_SUPPORT
+        mIDispatchMember = nsnull;
+#endif
+        mStaticMemberIsLocal = JS_FALSE;
+    }
+
+    mArgc   = argc;
+    mArgv   = argv;
+    mRetVal = rval;
+
+    mReturnValueWasSet = JS_FALSE;
+    mState = HAVE_ARGS;
+}
+
+nsresult
+XPCCallContext::CanCallNow()
+{
+    nsresult rv;
+    
+    if(!HasInterfaceAndMember())
+        return NS_ERROR_UNEXPECTED;
+    if(mState < HAVE_ARGS)
+        return NS_ERROR_UNEXPECTED;
+
+    if(!mTearOff)
+    {
+        mTearOff = mWrapper->FindTearOff(*this, mInterface, JS_FALSE, &rv);
+        if(!mTearOff || mTearOff->GetInterface() != mInterface)
+        {
+            mTearOff = nsnull;    
+            return NS_FAILED(rv) ? rv : NS_ERROR_UNEXPECTED;
+        }
+    }
+
+    // Refresh in case FindTearOff extended the set
+    mSet = mWrapper->GetSet();
+
+    mState = READY_TO_CALL;
+    return NS_OK;
+}
+
+void
+XPCCallContext::SystemIsBeingShutDown()
+{
+    // XXX This is pretty questionable since the per thread cleanup stuff
+    // can be making this call on one thread for call contexts on another
+    // thread.
+    NS_WARNING("Shutting Down XPConnect even through there is a live XPCCallContext");
+    mThreadData = nsnull;
+    mXPCContext = nsnull;
+    mState = SYSTEM_SHUTDOWN;
+    if(mPrevCallContext)
+        mPrevCallContext->SystemIsBeingShutDown();
+}
+
+XPCCallContext::~XPCCallContext()
+{
+    // do cleanup...
+
+    PRBool shouldReleaseXPC = PR_FALSE;
+
+    if(mXPCContext)
+    {
+        mXPCContext->SetCallingLangType(mPrevCallerLanguage);
+
+#ifdef DEBUG
+        XPCCallContext* old = mThreadData->SetCallContext(mPrevCallContext);
+        NS_ASSERTION(old == this, "bad pop from per thread data");
+#else
+        (void) mThreadData->SetCallContext(mPrevCallContext);
+#endif
+
+        shouldReleaseXPC = mPrevCallContext == nsnull;
+    }
+
+    if(mContextPopRequired)
+    {
+        XPCJSContextStack* stack = mThreadData->GetJSContextStack();
+        NS_ASSERTION(stack, "bad!");
+        if(stack)
+        {
+#ifdef DEBUG
+            JSContext* poppedCX;
+            nsresult rv = stack->Pop(&poppedCX);
+            NS_ASSERTION(NS_SUCCEEDED(rv) && poppedCX == mJSContext, "bad pop");
+#else
+            (void) stack->Pop(nsnull);
+#endif
+        }
+    }
+
+    if(mJSContext)
+    {
+        if(mCallerLanguage == NATIVE_CALLER)
+            JS_EndRequest(mJSContext);
+        
+        if(mDestroyJSContextInDestructor)
+        {
+#ifdef DEBUG_xpc_hacker
+            printf("!xpc - doing deferred destruction of JSContext @ %0x\n", 
+                   mJSContext);
+#endif
+            NS_ASSERTION(!mThreadData->GetJSContextStack() || 
+                         !mThreadData->GetJSContextStack()->
+                            DEBUG_StackHasJSContext(mJSContext),
+                         "JSContext still in threadjscontextstack!");
+        
+            JS_DestroyContext(mJSContext);
+        }
+        else
+        {
+            // Don't clear newborns if JS frames (compilation or execution)
+            // are active!  Doing so violates ancient invariants in the JS
+            // engine, and it's not necessary to fix JS component leaks.
+            if(!JS_IsRunning(mJSContext))
+                JS_ClearNewbornRoots(mJSContext);
+        }
+    }
+
+#ifdef DEBUG
+    {
+        StringWrapperEntry *se =
+            reinterpret_cast<StringWrapperEntry*>(&mStringWrapperData);
+
+        PRUint32 i;
+        for(i = 0; i < XPCCCX_STRING_CACHE_SIZE; ++i)
+        {
+            NS_ASSERTION(!se[i].mInUse, "Uh, string wrapper still in use!");
+        }
+    }
+#endif
+
+    if(shouldReleaseXPC && mXPC)
+        NS_RELEASE(mXPC);
+}
+
+XPCReadableJSStringWrapper *
+XPCCallContext::NewStringWrapper(PRUnichar *str, PRUint32 len)
+{
+    StringWrapperEntry *se =
+        reinterpret_cast<StringWrapperEntry*>(&mStringWrapperData);
+
+    PRUint32 i;
+    for(i = 0; i < XPCCCX_STRING_CACHE_SIZE; ++i)
+    {
+        StringWrapperEntry& ent = se[i];
+
+        if(!ent.mInUse)
+        {
+            ent.mInUse = PR_TRUE;
+
+            // Construct the string using placement new.
+
+            return new (&ent.mString) XPCReadableJSStringWrapper(str, len);
+        }
+    }
+
+    // All our internal string wrappers are used, allocate a new string.
+
+    return new XPCReadableJSStringWrapper(str, len);
+}
+
+void
+XPCCallContext::DeleteString(nsAString *string)
+{
+    StringWrapperEntry *se =
+        reinterpret_cast<StringWrapperEntry*>(&mStringWrapperData);
+
+    PRUint32 i;
+    for(i = 0; i < XPCCCX_STRING_CACHE_SIZE; ++i)
+    {
+        StringWrapperEntry& ent = se[i];
+        if(string == &ent.mString)
+        {
+            // One of our internal strings is no longer in use, mark
+            // it as such and destroy the string.
+
+            ent.mInUse = PR_FALSE;
+            ent.mString.~XPCReadableJSStringWrapper();
+
+            return;
+        }
+    }
+
+    // We're done with a string that's not one of our internal
+    // strings, delete it.
+    delete string;
+}
+
+/* readonly attribute nsISupports Callee; */
+NS_IMETHODIMP
+XPCCallContext::GetCallee(nsISupports * *aCallee)
+{
+    nsISupports* temp = mWrapper ? mWrapper->GetIdentityObject() : nsnull;
+    NS_IF_ADDREF(temp);
+    *aCallee = temp;
+    return NS_OK;
+}
+
+/* readonly attribute PRUint16 CalleeMethodIndex; */
+NS_IMETHODIMP
+XPCCallContext::GetCalleeMethodIndex(PRUint16 *aCalleeMethodIndex)
+{
+    *aCalleeMethodIndex = mMethodIndex;
+    return NS_OK;
+}
+
+/* readonly attribute nsIXPConnectWrappedNative CalleeWrapper; */
+NS_IMETHODIMP
+XPCCallContext::GetCalleeWrapper(nsIXPConnectWrappedNative * *aCalleeWrapper)
+{
+    nsIXPConnectWrappedNative* temp = mWrapper;
+    NS_IF_ADDREF(temp);
+    *aCalleeWrapper = temp;
+    return NS_OK;
+}
+
+/* readonly attribute XPCNativeInterface CalleeInterface; */
+NS_IMETHODIMP
+XPCCallContext::GetCalleeInterface(nsIInterfaceInfo * *aCalleeInterface)
+{
+    nsIInterfaceInfo* temp = mInterface->GetInterfaceInfo();
+    NS_IF_ADDREF(temp);
+    *aCalleeInterface = temp;
+    return NS_OK;
+}
+
+/* readonly attribute nsIClassInfo CalleeClassInfo; */
+NS_IMETHODIMP
+XPCCallContext::GetCalleeClassInfo(nsIClassInfo * *aCalleeClassInfo)
+{
+    nsIClassInfo* temp = mWrapper ? mWrapper->GetClassInfo() : nsnull;
+    NS_IF_ADDREF(temp);
+    *aCalleeClassInfo = temp;
+    return NS_OK;
+}
+
+/* readonly attribute JSContextPtr JSContext; */
+NS_IMETHODIMP
+XPCCallContext::GetJSContext(JSContext * *aJSContext)
+{
+    *aJSContext = mJSContext;
+    return NS_OK;
+}
+
+/* readonly attribute PRUint32 Argc; */
+NS_IMETHODIMP
+XPCCallContext::GetArgc(PRUint32 *aArgc)
+{
+    *aArgc = (PRUint32) mArgc;
+    return NS_OK;
+}
+
+/* readonly attribute JSValPtr ArgvPtr; */
+NS_IMETHODIMP
+XPCCallContext::GetArgvPtr(jsval * *aArgvPtr)
+{
+    *aArgvPtr = mArgv;
+    return NS_OK;
+}
+
+/* readonly attribute JSValPtr RetValPtr; */
+NS_IMETHODIMP
+XPCCallContext::GetRetValPtr(jsval * *aRetValPtr)
+{
+    *aRetValPtr = mRetVal;
+    return NS_OK;
+}
+
+/* attribute PRBool ReturnValueWasSet; */
+NS_IMETHODIMP
+XPCCallContext::GetReturnValueWasSet(PRBool *aReturnValueWasSet)
+{
+    *aReturnValueWasSet = mReturnValueWasSet;
+    return NS_OK;
+}
+NS_IMETHODIMP
+XPCCallContext::SetReturnValueWasSet(PRBool aReturnValueWasSet)
+{
+    mReturnValueWasSet = aReturnValueWasSet;
+    return NS_OK;
+}
+
+#ifdef XPC_IDISPATCH_SUPPORT
+
+void
+XPCCallContext::SetIDispatchInfo(XPCNativeInterface* iface, 
+                                 void * member)
+{
+    CHECK_STATE(HAVE_CONTEXT);
+
+    // We are going straight to the method info and need not do a lookup
+    // by id.
+
+    // don't be tricked if method is called with wrong 'this'
+    if(mTearOff && mTearOff->GetInterface() != iface)
+        mTearOff = nsnull;
+
+    mSet = nsnull;
+    mInterface = iface;
+    mMember = nsnull;
+    mIDispatchMember = member;
+    mName = reinterpret_cast<XPCDispInterface::Member*>(member)->GetName();
+
+    if(mState < HAVE_NAME)
+        mState = HAVE_NAME;
+}
+
+#endif
+
+NS_IMETHODIMP
+XPCCallContext::GetPreviousCallContext(nsAXPCNativeCallContext **aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = GetPrevCallContext();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+XPCCallContext::GetLanguage(PRUint16 *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = GetCallerLanguage();
+  return NS_OK;
+}