johnson 1.2.0 → 2.0.0.pre0

data/vendor/tracemonkey/xpconnect/tests/components/xpctest_const.cpp

@@ -0,0 +1,76 @@
+/* -*- 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>
+ *
+ * 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 ***** */
+
+#include "nsISupports.h"
+#include "xpctest_const.h"
+#include "xpctest_private.h"
+
+class xpcTestConst : public nsIXPCTestConst {
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIXPCTESTCONST
+  xpcTestConst();
+};
+
+NS_IMPL_ISUPPORTS1(xpcTestConst, nsIXPCTestConst)
+
+xpcTestConst :: xpcTestConst() {
+    NS_ADDREF_THIS();
+}
+
+NS_IMETHODIMP
+xpctest::ConstructXPCTestConst(nsISupports *aOuter, REFNSIID aIID, void **aResult)
+{
+    nsresult rv;
+    NS_ASSERTION(aOuter == nsnull, "no aggregation");
+    xpcTestConst *obj = new xpcTestConst();
+    if(obj)
+    {
+        rv = obj->QueryInterface(aIID, aResult);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "unable to find correct interface");
+        NS_RELEASE(obj);
+    }
+    else
+    {
+        *aResult = nsnull;
+        rv = NS_ERROR_OUT_OF_MEMORY;
+    }
+    return rv;
+}

data/vendor/tracemonkey/xpconnect/tests/components/xpctest_domstring.cpp

@@ -0,0 +1,118 @@
+/* -*- 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) 2001
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Mike Shaver <shaver@mozilla.org>
+ *
+ * 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 ***** */
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "xpctest_domstring.h"
+#include "xpctest_private.h"
+
+class xpcTestDOMString : public nsIXPCTestDOMString {
+public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIXPCTESTDOMSTRING
+    xpcTestDOMString();
+    virtual ~xpcTestDOMString();
+private:
+    nsString mStr;
+};
+
+NS_IMPL_ISUPPORTS1(xpcTestDOMString, nsIXPCTestDOMString)
+
+xpcTestDOMString::xpcTestDOMString()
+{
+    NS_ADDREF_THIS();
+}
+
+xpcTestDOMString::~xpcTestDOMString()
+{
+}
+
+NS_IMETHODIMP
+xpcTestDOMString::HereHaveADOMString(const nsAString &str)
+{
+    // assignment will share buffer if possible
+    mStr = str;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+xpcTestDOMString::DontKeepThisOne(const nsAString &str)
+{
+    nsCString c; c.AssignWithConversion(str);
+    fprintf(stderr, "xpcTestDOMString::DontKeepThisOne: \"%s\"\n", c.get());
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+xpcTestDOMString::GiveDOMStringTo(nsIXPCTestDOMString *recv)
+{
+    NS_NAMED_LITERAL_STRING(myString, "A DOM String, Just For You");
+    return recv->HereHaveADOMString(myString);
+}
+
+NS_IMETHODIMP
+xpcTestDOMString::PassDOMStringThroughTo(const nsAString &str,
+                                         nsIXPCTestDOMString *recv)
+{
+    return recv->HereHaveADOMString(str);
+}
+
+
+NS_IMETHODIMP
+xpctest::ConstructXPCTestDOMString(nsISupports *aOuter, REFNSIID aIID,
+                                   void **aResult)
+{
+    nsresult rv;
+    NS_ASSERTION(!aOuter, "no aggregation");
+    xpcTestDOMString *obj = new xpcTestDOMString();
+    if (obj)
+    {
+        rv = obj->QueryInterface(aIID, aResult);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "unable to find correct interface");
+        NS_RELEASE(obj);
+    }
+    else
+    {
+        *aResult = nsnull;
+        rv = NS_ERROR_OUT_OF_MEMORY;
+    }
+    return rv;
+}
+

data/vendor/tracemonkey/xpconnect/tests/components/xpctest_echo.cpp

@@ -0,0 +1,616 @@
+/* -*- 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>
+ *
+ * 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 ***** */
+
+/* implement nsIEcho for testing. */
+
+#include "xpctest_private.h"
+
+#if defined(WIN32) && !defined(XPCONNECT_STANDALONE)
+#define IMPLEMENT_TIMER_STUFF 1
+#endif
+
+class xpctestEcho : public nsIEcho
+#ifdef IMPLEMENT_TIMER_STUFF
+, public nsITimerCallback
+#endif // IMPLEMENT_TIMER_STUFF
+{
+public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIECHO
+
+#ifdef IMPLEMENT_TIMER_STUFF
+    NS_DECL_NSITIMERCALLBACK
+#endif // IMPLEMENT_TIMER_STUFF
+
+    xpctestEcho();
+    virtual ~xpctestEcho();
+private:
+    nsIEcho* mReceiver;
+    char*    mString;
+    PRInt32  mSomeValue;
+};
+
+/***************************************************************************/
+
+#ifdef IMPLEMENT_TIMER_STUFF
+NS_IMPL_ISUPPORTS2(xpctestEcho, nsIEcho, nsITimerCallback)
+#else
+NS_IMPL_ISUPPORTS1(xpctestEcho, nsIEcho)
+#endif // IMPLEMENT_TIMER_STUFF
+
+xpctestEcho::xpctestEcho()
+    : mReceiver(nsnull), mString(nsnull), mSomeValue(0)
+{
+    NS_ADDREF_THIS();
+}
+
+xpctestEcho::~xpctestEcho()
+{
+    NS_IF_RELEASE(mReceiver);
+    if(mString)
+        nsMemory::Free(mString);
+}
+
+NS_IMETHODIMP xpctestEcho::SetReceiver(nsIEcho* aReceiver)
+{
+    NS_IF_ADDREF(aReceiver);
+    NS_IF_RELEASE(mReceiver);
+    mReceiver = aReceiver;
+    return NS_OK;
+}
+
+NS_IMETHODIMP xpctestEcho::SendOneString(const char* str)
+{
+    if(mReceiver)
+        return mReceiver->SendOneString(str);
+    return NS_OK;
+}
+
+NS_IMETHODIMP xpctestEcho::In2OutOneInt(int input, int* output)
+{
+    *output = input;
+    return NS_OK;
+}
+
+/* DOMString In2OutOneDOMString (in DOMString input); */
+NS_IMETHODIMP xpctestEcho::In2OutOneDOMString(const nsAString & input, 
+                                              nsAString & _retval)
+{
+    _retval.Assign(input);
+    return NS_OK;
+}
+
+/* DOMString EchoIn2OutOneDOMString (in DOMString input); */
+NS_IMETHODIMP xpctestEcho::EchoIn2OutOneDOMString(const nsAString & input, nsAString & _retval)
+{
+    if(mReceiver)
+        return mReceiver->EchoIn2OutOneDOMString(input, _retval);
+    return NS_OK;
+}
+
+/* AString In2OutOneAString (in AString input); */
+NS_IMETHODIMP xpctestEcho::In2OutOneAString(const nsAString & input, 
+                                              nsAString & _retval)
+{
+    _retval.Assign(input);
+    return NS_OK;
+}
+
+/* AString EchoIn2OutOneAString (in AString input); */
+NS_IMETHODIMP xpctestEcho::EchoIn2OutOneAString(const nsAString & input, nsAString & _retval)
+{
+    if(mReceiver)
+        return mReceiver->EchoIn2OutOneAString(input, _retval);
+    return NS_OK;
+}
+
+
+/* UTF8String In2OutOneUTF8String (in UTF8String input); */
+NS_IMETHODIMP xpctestEcho::In2OutOneUTF8String(const nsACString & input, 
+                                              nsACString & _retval)
+{
+    _retval.Assign(input);
+    return NS_OK;
+}
+
+/* UTF8String EchoIn2OutOneUTF8String (in UTF8String input); */
+NS_IMETHODIMP xpctestEcho::EchoIn2OutOneUTF8String(const nsACString & input, 
+                                                   nsACString & _retval)
+{
+    if(mReceiver)
+        return mReceiver->EchoIn2OutOneUTF8String(input, _retval);
+    return NS_OK;
+}
+
+/* CString In2OutOneCString (in CString input); */
+NS_IMETHODIMP xpctestEcho::In2OutOneCString(const nsACString & input, 
+                                            nsACString & _retval)
+{
+    _retval.Assign(input);
+    return NS_OK;
+}
+
+/* CString EchoIn2OutOneCString (in CString input); */
+NS_IMETHODIMP xpctestEcho::EchoIn2OutOneCString(const nsACString & input, 
+                                                nsACString & _retval)
+{
+    if(mReceiver)
+        return mReceiver->EchoIn2OutOneCString(input, _retval);
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP xpctestEcho::In2OutAddTwoInts(int input1,
+                                       int input2,
+                                       int* output1,
+                                       int* output2,
+                                       int* result)
+{
+    *output1 = input1;
+    *output2 = input2;
+    *result = input1+input2;
+    return NS_OK;
+}
+
+NS_IMETHODIMP xpctestEcho::In2OutOneString(const char* input, char** output)
+{
+    char* p;
+    int len;
+    if(input && output &&
+       (nsnull != (p = (char*)nsMemory::Alloc(len=strlen(input)+1))))
+    {
+        memcpy(p, input, len);
+        *output = p;
+        return NS_OK;
+    }
+    if(output)
+        *output = nsnull;
+    return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP xpctestEcho::SimpleCallNoEcho()
+{
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+xpctestEcho::SendManyTypes(PRUint8              p1,
+                      PRInt16             p2,
+                      PRInt32             p3,
+                      PRInt64             p4,
+                      PRUint8              p5,
+                      PRUint16            p6,
+                      PRUint32            p7,
+                      PRUint64            p8,
+                      float             p9,
+                      double            p10,
+                      PRBool            p11,
+                      char              p12,
+                      PRUnichar            p13,
+                      const nsID*       p14,
+                      const char*       p15,
+                      const PRUnichar*  p16)
+{
+    if(mReceiver)
+        return mReceiver->SendManyTypes(p1, p2, p3, p4, p5, p6, p7, p8, p9,
+                                        p10, p11, p12, p13, p14, p15, p16);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+xpctestEcho::SendInOutManyTypes(PRUint8*    p1,
+                           PRInt16*   p2,
+                           PRInt32*   p3,
+                           PRInt64*   p4,
+                           PRUint8*    p5,
+                           PRUint16*  p6,
+                           PRUint32*  p7,
+                           PRUint64*  p8,
+                           float*   p9,
+                           double*  p10,
+                           PRBool*  p11,
+                           char*    p12,
+                           PRUnichar*  p13,
+                           nsID**   p14,
+                           char**   p15,
+                           PRUnichar** p16)
+{
+    if(mReceiver)
+        return mReceiver->SendInOutManyTypes(p1, p2, p3, p4, p5, p6, p7, p8, p9,
+                                             p10, p11, p12, p13, p14, p15, p16);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+xpctestEcho::MethodWithNative(int p1, void* p2)
+{
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+xpctestEcho::ReturnCode(int code)
+{
+    return (nsresult) code;
+}
+
+NS_IMETHODIMP
+xpctestEcho::FailInJSTest(int fail)
+{
+    if(mReceiver)
+        return mReceiver->FailInJSTest(fail);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+xpctestEcho::SharedString(const char **str)
+{
+    *str = "a static string";
+/*
+    // to do non-shared we clone the string:
+    char buf[] = "a static string";
+    int len;
+    *str = (char*)nsMemory::Alloc(len=strlen(buf)+1);
+    memcpy(*str, buf, len);
+*/
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+xpctestEcho::ReturnCode_NS_OK()
+{return NS_OK;}
+
+NS_IMETHODIMP
+xpctestEcho::ReturnCode_NS_ERROR_NULL_POINTER()
+{return NS_ERROR_NULL_POINTER;}
+
+NS_IMETHODIMP
+xpctestEcho::ReturnCode_NS_ERROR_UNEXPECTED()
+{return NS_ERROR_UNEXPECTED;}
+
+NS_IMETHODIMP
+xpctestEcho::ReturnCode_NS_ERROR_OUT_OF_MEMORY()
+{return NS_ERROR_OUT_OF_MEMORY;}
+
+NS_IMETHODIMP
+xpctestEcho::ReturnInterface(nsISupports *obj, nsISupports **_retval)
+{
+    if(!_retval)
+        return NS_ERROR_NULL_POINTER;
+    if(obj)
+        NS_ADDREF(obj);
+    *_retval = obj;
+    return NS_OK;
+}
+
+/* nsIStackFrame GetStack (); */
+NS_IMETHODIMP
+xpctestEcho::GetStack(nsIStackFrame **_retval)
+{
+    nsIStackFrame* stack = nsnull;
+    if(!_retval)
+        return NS_ERROR_NULL_POINTER;
+
+    nsresult rv;
+    nsCOMPtr<nsIXPConnect> xpc(do_GetService(nsIXPConnect::GetCID(), &rv));
+    if(NS_SUCCEEDED(rv))
+    {
+        nsIStackFrame* jsstack;
+        if(NS_SUCCEEDED(xpc->GetCurrentJSStack(&jsstack)) && jsstack)
+        {
+            xpc->CreateStackFrameLocation(nsIProgrammingLanguage::CPLUSPLUS,
+                                          __FILE__,
+                                          "xpctestEcho::GetStack",
+                                          __LINE__,
+                                          jsstack,
+                                          &stack);
+            NS_RELEASE(jsstack);
+        }
+    }
+
+    if(stack)
+    {
+        *_retval = stack;
+        return NS_OK;
+    }
+    return NS_ERROR_FAILURE;
+}
+
+/* void SetReceiverReturnOldReceiver (inout nsIEcho aReceiver); */
+NS_IMETHODIMP
+xpctestEcho::SetReceiverReturnOldReceiver(nsIEcho **aReceiver)
+{
+    if(!aReceiver)
+        return NS_ERROR_NULL_POINTER;
+
+    nsIEcho* oldReceiver = mReceiver;
+    mReceiver = *aReceiver;
+    if(mReceiver)
+        NS_ADDREF(mReceiver);
+
+    /* don't release the reference, that is the caller's problem */
+    *aReceiver = oldReceiver;
+    return NS_OK;
+}
+
+/* void MethodWithForwardDeclaredParam (in nsITestXPCSomeUselessThing sut); */
+NS_IMETHODIMP
+xpctestEcho::MethodWithForwardDeclaredParam(nsITestXPCSomeUselessThing *sut)
+{
+    return NS_OK;
+}
+
+/* void PseudoQueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result); */
+NS_IMETHODIMP
+xpctestEcho::PseudoQueryInterface(const nsIID & uuid, void * *result)
+{
+    if(!result)
+        return NS_ERROR_NULL_POINTER;
+    if(mReceiver)
+        return mReceiver->PseudoQueryInterface(uuid, result);
+    return NS_OK;
+}        
+
+/* void DebugDumpJSStack (); */
+NS_IMETHODIMP
+xpctestEcho::DebugDumpJSStack()
+{
+    nsresult rv;
+    nsCOMPtr<nsIXPConnect> xpc(do_GetService(nsIXPConnect::GetCID(), &rv));
+    if(NS_SUCCEEDED(rv))
+    {
+        rv = xpc->DebugDumpJSStack(JS_TRUE, JS_TRUE, JS_TRUE);
+    }
+    return rv;
+}        
+
+/* attribute string aString; */
+NS_IMETHODIMP 
+xpctestEcho::GetAString(char * *aAString)
+{
+    printf(">>>> xpctestEcho::GetAString called\n");
+    if(mString)
+        *aAString = (char*) nsMemory::Clone(mString, strlen(mString)+1);
+    else
+        *aAString = nsnull;
+    return NS_OK;
+}
+NS_IMETHODIMP 
+xpctestEcho::SetAString(const char * aAString)
+{
+    printf("<<<< xpctestEcho::SetAString called\n");
+    if(mString)
+        nsMemory::Free(mString);
+    if(aAString)
+        mString = (char*) nsMemory::Clone(aAString, strlen(aAString)+1);
+    else
+        mString = nsnull;
+    return NS_OK;
+}
+
+
+
+/***************************************************/
+
+// some tests of nsIXPCNativeCallContext
+
+#define GET_CALL_CONTEXT \
+  nsresult rv; \
+  nsAXPCNativeCallContext *cc = nsnull; \
+  nsCOMPtr<nsIXPConnect> xpc(do_GetService(nsIXPConnect::GetCID(), &rv)); \
+  if(NS_SUCCEEDED(rv)) \
+    rv = xpc->GetCurrentNativeCallContext(&cc) /* no ';' */        
+
+/* void printArgTypes (); */
+NS_IMETHODIMP
+xpctestEcho::PrintArgTypes(void)
+{
+    GET_CALL_CONTEXT;
+    if(NS_FAILED(rv) || !cc)
+        return NS_ERROR_FAILURE;
+
+    nsCOMPtr<nsISupports> callee;
+    if(NS_FAILED(cc->GetCallee(getter_AddRefs(callee))) ||
+       callee != static_cast<nsIEcho*>(this))
+        return NS_ERROR_FAILURE;
+
+    PRUint32 argc;
+    if(NS_SUCCEEDED(cc->GetArgc(&argc)))
+        printf("argc = %d  ", (int)argc);
+    else
+        return NS_ERROR_FAILURE;
+
+    jsval* argv;
+    if(NS_FAILED(cc->GetArgvPtr(&argv)))
+        return NS_ERROR_FAILURE;
+
+    printf("argv types = [");
+
+    for(PRUint32 i = 0; i < argc; i++)
+    {
+        const char* type = "<unknown>";
+        if(JSVAL_IS_OBJECT(argv[i]))
+        {
+            if(JSVAL_IS_NULL(argv[i]))
+                type = "null";
+            else
+                type = "object";
+        }
+        else if (JSVAL_IS_BOOLEAN(argv[i]))
+            type = "boolean";
+        else if (JSVAL_IS_STRING(argv[i]))
+            type = "string";
+        else if (JSVAL_IS_DOUBLE(argv[i]))
+            type = "double";
+        else if (JSVAL_IS_INT(argv[i]))
+            type = "int";
+        else if (JSVAL_IS_VOID(argv[i]))
+            type = "void";
+
+        printf(type);
+
+        if(i < argc-1)
+            printf(", ");
+    }
+    printf("]\n");
+    
+    return NS_OK;
+}
+
+/* void throwArg (); */
+NS_IMETHODIMP
+xpctestEcho::ThrowArg(void)
+{
+    GET_CALL_CONTEXT;
+    if(NS_FAILED(rv) || !cc)
+        return NS_ERROR_FAILURE;
+
+    nsCOMPtr<nsISupports> callee;
+    if(NS_FAILED(cc->GetCallee(getter_AddRefs(callee))) || 
+       callee != static_cast<nsIEcho*>(this))
+        return NS_ERROR_FAILURE;
+
+    PRUint32 argc;
+    if(NS_FAILED(cc->GetArgc(&argc)) || !argc)
+        return NS_OK;
+
+    jsval* argv;
+    JSContext* cx;
+    if(NS_FAILED(cc->GetArgvPtr(&argv)) ||
+       NS_FAILED(cc->GetJSContext(&cx)))
+        return NS_ERROR_FAILURE;
+
+    JS_SetPendingException(cx, argv[0]);
+    return NS_OK;
+}
+
+/* void callReceiverSometimeLater (); */
+NS_IMETHODIMP
+xpctestEcho::CallReceiverSometimeLater(void)
+{
+    // Mac does not even compile this code and Unix build systems
+    // have build order problems with linking to the static timer lib
+    // as it is built today. This is only test code and we can stand to 
+    // have it only work on Win32 for now.
+
+#ifdef IMPLEMENT_TIMER_STUFF
+    nsCOMPtr<nsITimer> timer;
+    nsresult rv;
+    timer = do_CreateInstance("@mozilla.org/timer;1", &rv);
+    if(NS_FAILED(rv))
+        return NS_ERROR_FAILURE;
+    timer->InitWithCallback(static_cast<nsITimerCallback*>(this), 2000,
+                            nsITimer::TYPE_ONE_SHOT);
+    return NS_OK;
+#else
+    return NS_ERROR_NOT_IMPLEMENTED;
+#endif // IMPLEMENT_TIMER_STUFF
+}
+
+#ifdef IMPLEMENT_TIMER_STUFF
+NS_IMETHODIMP
+xpctestEcho::Notify(nsITimer *timer)
+{
+    if(mReceiver)
+        mReceiver->CallReceiverSometimeLater();
+    NS_RELEASE(timer);
+    return NS_OK;
+}        
+#endif // IMPLEMENT_TIMER_STUFF
+
+/* readonly attribute short throwInGetter; */
+NS_IMETHODIMP
+xpctestEcho::GetThrowInGetter(PRInt16 *aThrowInGetter)
+{
+    return NS_ERROR_FAILURE;
+}        
+
+/* void callFunction (in nsITestXPCFunctionCallback callback, in string s); */
+NS_IMETHODIMP 
+xpctestEcho::CallFunction(nsITestXPCFunctionCallback *callback, const char *s)
+{
+    return callback->Call(s);
+}
+
+/* void callFunction (in nsITestXPCFunctionCallback callback, in string s); */
+NS_IMETHODIMP 
+xpctestEcho::CallFunctionWithThis(nsITestXPCFunctionCallback *callback, nsISupports* self, const char *s)
+{
+    return callback->CallWithThis(self, s);
+}
+
+/* attribute PRInt32 SomeValue; */
+NS_IMETHODIMP 
+xpctestEcho::GetSomeValue(PRInt32 *aSomeValue)
+{
+    *aSomeValue = mSomeValue;
+    return NS_OK;
+}
+
+NS_IMETHODIMP xpctestEcho::SetSomeValue(PRInt32 aSomeValue)
+
+{
+    mSomeValue = aSomeValue;
+    return NS_OK;
+}
+
+/***************************************************************************/
+
+// static
+NS_IMETHODIMP
+xpctest::ConstructEcho(nsISupports *aOuter, REFNSIID aIID, void **aResult)
+{
+    nsresult rv;
+    NS_ASSERTION(aOuter == nsnull, "no aggregation");
+    xpctestEcho* obj = new xpctestEcho();
+
+    if(obj)
+    {
+        rv = obj->QueryInterface(aIID, aResult);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "unable to find correct interface");
+        NS_RELEASE(obj);
+    }
+    else
+    {
+        *aResult = nsnull;
+        rv = NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    return rv;
+}