johnson 1.2.0 → 2.0.0.pre0

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

@@ -0,0 +1,355 @@
+/* -*- 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 nsITestVariant for testing. */
+
+#include "xpctest_private.h"
+#include "nsString.h"
+
+class nsTestVariant : public nsITestVariant
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSITESTVARIANT
+
+  nsTestVariant();
+  virtual ~nsTestVariant();
+};
+
+NS_IMPL_ISUPPORTS1(nsTestVariant, nsITestVariant)
+
+nsTestVariant::nsTestVariant()
+{
+}
+
+nsTestVariant::~nsTestVariant()
+{
+}
+
+/* nsIVariant passThruVariant (in nsIVariant value); */
+NS_IMETHODIMP nsTestVariant::PassThruVariant(nsIVariant *value, nsIVariant **_retval)
+{
+    *_retval = value;
+    NS_IF_ADDREF(*_retval);
+    return NS_OK;
+}
+
+/* PRUint16 returnVariantType (in nsIVariant value); */
+NS_IMETHODIMP nsTestVariant::ReturnVariantType(nsIVariant *value, PRUint16 *_retval)
+{
+    return value->GetDataType(_retval);
+}
+
+#define MEMBER_COPY(type_)                                                    \
+    rv = inVar->GetAs##type_(&du.u.m##type_##Value);                          \
+    if(NS_FAILED(rv)) return rv;                                              \
+    rv = outVar->SetAs##type_(du.u.m##type_##Value);                          \
+    NS_ENSURE_SUCCESS(rv,rv);
+
+#define MEMBER_COPY_CAST(type_, cast_)                                        \
+    rv = inVar->GetAs##type_( (cast_*) &du.u.m##type_##Value);                \
+    if(NS_FAILED(rv)) return rv;                                              \
+    rv = outVar->SetAs##type_( (cast_) du.u.m##type_##Value);                 \
+    NS_ENSURE_SUCCESS(rv,rv);
+
+static nsresult ConvertAndCopyVariant(nsIVariant *inVar, PRUint16 type, nsIVariant **_retval)
+{
+    nsresult rv;
+    
+    nsCOMPtr<nsIWritableVariant> outVar;
+    outVar = do_CreateInstance("@mozilla.org/variant;1");
+    if(!outVar)
+        return NS_ERROR_FAILURE;
+
+    PRUint16 inVarType;
+    rv = inVar->GetDataType(&inVarType);
+    if(NS_FAILED(rv))
+        return rv;
+
+    nsDiscriminatedUnion du;
+    nsVariant::Initialize(&du);
+
+    switch(type)
+    {
+    case nsIDataType::VTYPE_INT8:
+        MEMBER_COPY_CAST(Int8, PRUint8)
+        break;
+    case nsIDataType::VTYPE_INT16:
+        MEMBER_COPY(Int16)
+        break;
+    case nsIDataType::VTYPE_INT32:        
+        MEMBER_COPY(Int32)
+        break;
+    case nsIDataType::VTYPE_INT64:        
+        MEMBER_COPY(Int64)
+        break;
+    case nsIDataType::VTYPE_UINT8:        
+        MEMBER_COPY(Uint8)
+        break;
+    case nsIDataType::VTYPE_UINT16:        
+        MEMBER_COPY(Uint16)
+        break;
+    case nsIDataType::VTYPE_UINT32:        
+        MEMBER_COPY(Uint32)
+        break;
+    case nsIDataType::VTYPE_UINT64:        
+        MEMBER_COPY(Uint64)
+        break;
+    case nsIDataType::VTYPE_FLOAT:        
+        MEMBER_COPY(Float)
+        break;
+    case nsIDataType::VTYPE_DOUBLE:        
+        MEMBER_COPY(Double)
+        break;
+    case nsIDataType::VTYPE_BOOL:        
+        MEMBER_COPY(Bool)
+        break;
+    case nsIDataType::VTYPE_CHAR:        
+        MEMBER_COPY(Char)
+        break;
+    case nsIDataType::VTYPE_WCHAR:        
+        MEMBER_COPY(WChar)
+        break;
+    case nsIDataType::VTYPE_VOID:        
+        if(inVarType != nsIDataType::VTYPE_VOID)
+            return NS_ERROR_CANNOT_CONVERT_DATA;
+        rv = outVar->SetAsVoid();
+        NS_ENSURE_SUCCESS(rv,rv);
+        break;
+    case nsIDataType::VTYPE_ID:        
+        MEMBER_COPY(ID)
+        break;
+    case nsIDataType::VTYPE_ASTRING:        
+    case nsIDataType::VTYPE_DOMSTRING:
+    {
+        nsAutoString str;
+        rv = inVar->GetAsAString(str);
+        if(NS_FAILED(rv)) return rv;
+        rv = outVar->SetAsAString(str);
+        NS_ENSURE_SUCCESS(rv,rv);
+        break;
+    }
+    case nsIDataType::VTYPE_UTF8STRING:
+    {
+        nsUTF8String str;
+        rv = inVar->GetAsAUTF8String(str);
+        if(NS_FAILED(rv)) return rv;
+        rv = outVar->SetAsAUTF8String(str);
+        NS_ENSURE_SUCCESS(rv,rv);
+        break;
+    }
+    case nsIDataType::VTYPE_CSTRING:
+    {
+        nsCAutoString str;
+        rv = inVar->GetAsACString(str);
+        if(NS_FAILED(rv)) return rv;
+        rv = outVar->SetAsACString(str);
+        NS_ENSURE_SUCCESS(rv,rv);
+        break;
+    }    
+    case nsIDataType::VTYPE_CHAR_STR:        
+    {
+        char* str;
+        rv = inVar->GetAsString(&str);
+        if(NS_FAILED(rv)) return rv;
+        rv = outVar->SetAsString(str);
+        if(str) nsMemory::Free(str);
+        NS_ENSURE_SUCCESS(rv,rv);
+        break;
+    }
+    case nsIDataType::VTYPE_STRING_SIZE_IS:        
+    {
+        char* str;
+        PRUint32 size;
+        rv = inVar->GetAsStringWithSize(&size, &str);
+        if(NS_FAILED(rv)) return rv;
+        rv = outVar->SetAsStringWithSize(size, str);
+        if(str) nsMemory::Free(str);
+        NS_ENSURE_SUCCESS(rv,rv);
+        break;
+    }
+    case nsIDataType::VTYPE_WCHAR_STR:        
+    {
+        PRUnichar* str;
+        rv = inVar->GetAsWString(&str);
+        if(NS_FAILED(rv)) return rv;
+        rv = outVar->SetAsWString(str);
+        if(str) nsMemory::Free((char*)str);
+        NS_ENSURE_SUCCESS(rv,rv);
+        break;
+    }
+    case nsIDataType::VTYPE_WSTRING_SIZE_IS:        
+    {
+        PRUnichar* str;
+        PRUint32 size;
+        rv = inVar->GetAsWStringWithSize(&size, &str);
+        if(NS_FAILED(rv)) return rv;
+        rv = outVar->SetAsWStringWithSize(size, str);
+        if(str) nsMemory::Free((char*)str);
+        NS_ENSURE_SUCCESS(rv,rv);
+        break;
+    }
+    case nsIDataType::VTYPE_INTERFACE:        
+    {
+        nsISupports* ptr;
+        rv = inVar->GetAsISupports(&ptr);
+        if(NS_FAILED(rv)) return rv;
+        rv = outVar->SetAsISupports(ptr);
+        NS_IF_RELEASE(ptr);
+        NS_ENSURE_SUCCESS(rv,rv);
+        break;
+    }
+    case nsIDataType::VTYPE_INTERFACE_IS:        
+    {
+        nsISupports* ptr;
+        nsIID* iid;
+        rv = inVar->GetAsInterface(&iid, (void**)&ptr);
+        if(NS_FAILED(rv)) return rv;
+        rv = outVar->SetAsInterface(*iid, ptr);
+        NS_IF_RELEASE(ptr);
+        if(iid) nsMemory::Free((char*)iid);
+        NS_ENSURE_SUCCESS(rv,rv);
+        break;
+    }
+        break;
+    case nsIDataType::VTYPE_ARRAY:
+        rv = inVar->GetAsArray(&du.u.array.mArrayType,
+                               &du.u.array.mArrayInterfaceID,
+                               &du.u.array.mArrayCount,
+                               &du.u.array.mArrayValue);
+        if(NS_FAILED(rv)) return rv;
+        du.mType = type;
+        rv = outVar->SetAsArray(du.u.array.mArrayType,
+                                &du.u.array.mArrayInterfaceID,
+                                du.u.array.mArrayCount,
+                                du.u.array.mArrayValue);
+        NS_ENSURE_SUCCESS(rv,rv);
+        break;
+    case nsIDataType::VTYPE_EMPTY_ARRAY:
+        if(inVarType != nsIDataType::VTYPE_EMPTY_ARRAY)
+            return NS_ERROR_CANNOT_CONVERT_DATA;
+        rv = outVar->SetAsEmptyArray();
+        NS_ENSURE_SUCCESS(rv,rv);
+        break;        
+    case nsIDataType::VTYPE_EMPTY:
+        if(inVarType != nsIDataType::VTYPE_EMPTY)
+            return NS_ERROR_CANNOT_CONVERT_DATA;
+        rv = outVar->SetAsEmpty();
+        NS_ENSURE_SUCCESS(rv,rv);
+        break;
+    default:
+        NS_ERROR("bad type in variant!");
+        break;
+    }
+
+    nsVariant::Cleanup(&du);
+    *_retval = outVar;
+    NS_IF_ADDREF(*_retval);
+    return NS_OK;
+}        
+
+
+/* nsIVariant copyVariant (in nsIVariant value); */
+NS_IMETHODIMP nsTestVariant::CopyVariant(nsIVariant *value, nsIVariant **_retval)
+{
+    PRUint16 type;
+    if(NS_FAILED(value->GetDataType(&type)))
+        return NS_ERROR_FAILURE;
+    return ConvertAndCopyVariant(value, type, _retval);
+}
+
+/* nsIVariant copyVariantAsType (in nsIVariant value, in PRUint16 type); */
+NS_IMETHODIMP nsTestVariant::CopyVariantAsType(nsIVariant *value, PRUint16 type, nsIVariant **_retval)
+{
+    return ConvertAndCopyVariant(value, type, _retval);
+}
+
+/* nsIVariant copyVariantAsTypeTwice (in nsIVariant value, in PRUint16 type1, in PRUint16 type2); */
+NS_IMETHODIMP nsTestVariant::CopyVariantAsTypeTwice(nsIVariant *value, PRUint16 type1, PRUint16 type2, nsIVariant **_retval)
+{
+    nsCOMPtr<nsIVariant> temp;
+    nsresult rv = ConvertAndCopyVariant(value, type1, getter_AddRefs(temp));
+    if(NS_FAILED(rv))
+        return rv;
+    return ConvertAndCopyVariant(temp, type2, _retval);
+}
+
+/* nsIVariant getNamedProperty (in nsISupports aBag, in AString aName); */
+NS_IMETHODIMP nsTestVariant::GetNamedProperty(nsISupports *aObj, const nsAString & aName, nsIVariant **_retval)
+{
+    nsresult rv;
+    nsCOMPtr<nsIPropertyBag> bag = do_QueryInterface(aObj, &rv);
+    if(!bag)
+        return rv;
+    return bag->GetProperty(aName, _retval);
+}
+
+/* nsISimpleEnumerator getEnumerator (in nsISupports aBag); */
+NS_IMETHODIMP nsTestVariant::GetEnumerator(nsISupports *aObj, nsISimpleEnumerator **_retval)
+{
+    nsresult rv;
+    nsCOMPtr<nsIPropertyBag> bag = do_QueryInterface(aObj, &rv);
+    if(!bag)
+        return rv;
+    return bag->GetEnumerator(_retval);
+}
+
+/***************************************************************************/
+
+// static
+NS_IMETHODIMP
+xpctest::ConstructXPCTestVariant(nsISupports *aOuter, REFNSIID aIID, void **aResult)
+{
+    nsresult rv;
+    NS_ASSERTION(aOuter == nsnull, "no aggregation");
+    nsTestVariant* obj = new nsTestVariant();
+
+    if(!obj)
+    {
+        *aResult = nsnull;
+        rv = NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    NS_ADDREF(obj);
+    rv = obj->QueryInterface(aIID, aResult);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "unable to find correct interface");
+    NS_RELEASE(obj);
+    return rv;
+}

data/vendor/tracemonkey/xpconnect/tests/idispatch/COM/StdAfx.cpp

@@ -0,0 +1,12 @@
+// stdafx.cpp : source file that includes just the standard includes
+//  stdafx.pch will be the pre-compiled header
+//  stdafx.obj will contain the pre-compiled type information
+
+#include "stdafx.h"
+
+#ifdef _ATL_STATIC_REGISTRY
+#include <statreg.h>
+#include <statreg.cpp>
+#endif
+
+#include <atlimpl.cpp>

data/vendor/tracemonkey/xpconnect/tests/idispatch/COM/StdAfx.h

@@ -0,0 +1,28 @@
+// stdafx.h : include file for standard system include files,
+//      or project specific include files that are used frequently,
+//      but are changed infrequently
+
+#if !defined(AFX_STDAFX_H__3B3A8A37_A147_4D96_BFA3_51B0F69B5D8D__INCLUDED_)
+#define AFX_STDAFX_H__3B3A8A37_A147_4D96_BFA3_51B0F69B5D8D__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+#define STRICT
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0400
+#endif
+#define _ATL_APARTMENT_THREADED
+
+#include <atlbase.h>
+//You may derive a class from CComModule and use it if you want to override
+//something, but do not change the name of _Module
+extern CComModule _Module;
+#include <atlcom.h>
+#include <comdef.h>
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_STDAFX_H__3B3A8A37_A147_4D96_BFA3_51B0F69B5D8D__INCLUDED)

data/vendor/tracemonkey/xpconnect/tests/idispatch/COM/XPCDispUtilities.h

@@ -0,0 +1,28 @@
+#ifndef XPCDispUtilities_h
+#define XPCDispUtilities_h
+
+template <class T>
+inline
+HRESULT XPCCreateInstance(const CLSID & clsid, const IID & iid, T ** result)
+{
+    return CoCreateInstance(clsid, 0, CLSCTX_ALL, iid, reinterpret_cast<void**>(result));
+}
+
+DISPID GetIDsOfNames(IDispatch * pIDispatch , CComBSTR const & name)
+{
+    DISPID dispid;
+    OLECHAR * pName = name;
+    HRESULT hresult = pIDispatch->GetIDsOfNames(
+        IID_NULL,
+        &pName,
+        1, 
+        LOCALE_SYSTEM_DEFAULT,
+        &dispid);
+    if (!SUCCEEDED(hresult))
+    {
+        dispid = 0;
+    }
+    return dispid;
+}
+
+#endif

data/vendor/tracemonkey/xpconnect/tests/idispatch/COM/XPCIDispatchTest.cpp

@@ -0,0 +1,86 @@
+// XPCIDispatchTest.cpp : Implementation of DLL Exports.
+
+
+// Note: Proxy/Stub Information
+//      To build a separate proxy/stub DLL, 
+//      run nmake -f IDispatchTestps.mk in the project directory.
+
+#include "stdafx.h"
+#include "resource.h"
+#include <initguid.h>
+#include "XPCIDispatchTest.h"
+
+#include "XPCIDispatchTest_i.c"
+#include "nsXPCDispTestMethods.h"
+#include "nsXPCDispSimple.h"
+#include "nsXPCDispTestNoIDispatch.h"
+#include "nsXPCDispTestProperties.h"
+#include "nsXPCDispTestArrays.h"
+#include "nsXPCDispTestScriptOn.h"
+#include "nsXPCDispTestScriptOff.h"
+#include "nsXPCDispTestWrappedJS.h"
+
+CComModule _Module;
+
+BEGIN_OBJECT_MAP(ObjectMap)
+OBJECT_ENTRY(CLSID_nsXPCDispTestMethods, nsXPCDispTestMethods)
+OBJECT_ENTRY(CLSID_nsXPCDispSimple, nsXPCDispSimple)
+OBJECT_ENTRY(CLSID_nsXPCDispTestNoIDispatch, nsXPCDispTestNoIDispatch)
+OBJECT_ENTRY(CLSID_nsXPCDispTestProperties, nsXPCDispTestProperties)
+OBJECT_ENTRY(CLSID_nsXPCDispTestArrays, nsXPCDispTestArrays)
+OBJECT_ENTRY(CLSID_nsXPCDispTestScriptOn, nsXPCDispTestScriptOn)
+OBJECT_ENTRY(CLSID_nsXPCDispTestScriptOff, nsXPCDispTestScriptOff)
+OBJECT_ENTRY(CLSID_nsXPCDispTestWrappedJS, nsXPCDispTestWrappedJS)
+END_OBJECT_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// DLL Entry Point
+
+extern "C"
+BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/)
+{
+    if (dwReason == DLL_PROCESS_ATTACH)
+    {
+        _Module.Init(ObjectMap, hInstance, &LIBID_IDispatchTestLib);
+        DisableThreadLibraryCalls(hInstance);
+    }
+    else if (dwReason == DLL_PROCESS_DETACH)
+        _Module.Term();
+    return TRUE;    // ok
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Used to determine whether the DLL can be unloaded by OLE
+
+STDAPI DllCanUnloadNow(void)
+{
+    return (_Module.GetLockCount()==0) ? S_OK : S_FALSE;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Returns a class factory to create an object of the requested type
+
+STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv)
+{
+    return _Module.GetClassObject(rclsid, riid, ppv);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// DllRegisterServer - Adds entries to the system registry
+
+STDAPI DllRegisterServer(void)
+{
+    // registers object, typelib and all interfaces in typelib
+    return _Module.RegisterServer(TRUE);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// DllUnregisterServer - Removes entries from the system registry
+
+STDAPI DllUnregisterServer(void)
+{
+    return _Module.UnregisterServer(TRUE);
+}
+
+
+#include "nsXPCDispTestWrappedJS.h"