diff options
Diffstat (limited to 'js/xpconnect/tests/components/native')
7 files changed, 633 insertions, 0 deletions
diff --git a/js/xpconnect/tests/components/native/moz.build b/js/xpconnect/tests/components/native/moz.build new file mode 100644 index 0000000000..25d1cb9429 --- /dev/null +++ b/js/xpconnect/tests/components/native/moz.build @@ -0,0 +1,19 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +FINAL_TARGET = '_tests/xpcshell/js/xpconnect/tests/components/native/' +EXTRA_COMPONENTS += [ + 'xpctest.manifest', +] + +UNIFIED_SOURCES += [ + 'xpctest_attributes.cpp', + 'xpctest_module.cpp', + 'xpctest_params.cpp', + 'xpctest_returncode.cpp', +] + +XPCOMBinaryComponent('xpctest') diff --git a/js/xpconnect/tests/components/native/xpctest.manifest b/js/xpconnect/tests/components/native/xpctest.manifest new file mode 100644 index 0000000000..5b01aca44f --- /dev/null +++ b/js/xpconnect/tests/components/native/xpctest.manifest @@ -0,0 +1 @@ +interfaces xpctest.xpt diff --git a/js/xpconnect/tests/components/native/xpctest_attributes.cpp b/js/xpconnect/tests/components/native/xpctest_attributes.cpp new file mode 100644 index 0000000000..6a844fee22 --- /dev/null +++ b/js/xpconnect/tests/components/native/xpctest_attributes.cpp @@ -0,0 +1,139 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "xpctest_private.h" + +NS_IMPL_ISUPPORTS(xpcTestObjectReadOnly, nsIXPCTestObjectReadOnly) + +xpcTestObjectReadOnly :: xpcTestObjectReadOnly() { + boolProperty = true; + shortProperty = 32767; + longProperty = 2147483647; + floatProperty = 5.5f; + charProperty = 'X'; + // timeProperty is PRTime and signed type. + // So it has to allow negative value. + timeProperty = -1; +} + +NS_IMETHODIMP xpcTestObjectReadOnly :: GetStrReadOnly(char * *aStrReadOnly){ + char aString[] = "XPConnect Read-Only String"; + + if (!aStrReadOnly) + return NS_ERROR_NULL_POINTER; + *aStrReadOnly = (char*) nsMemory::Clone(aString, + sizeof(char)*(strlen(aString)+1)); + return *aStrReadOnly ? NS_OK : NS_ERROR_OUT_OF_MEMORY; +} + +NS_IMETHODIMP xpcTestObjectReadOnly :: GetBoolReadOnly(bool* aBoolReadOnly) { + *aBoolReadOnly = boolProperty; + return NS_OK; +} +NS_IMETHODIMP xpcTestObjectReadOnly :: GetShortReadOnly(int16_t* aShortReadOnly){ + *aShortReadOnly = shortProperty; + return NS_OK; +} +NS_IMETHODIMP xpcTestObjectReadOnly :: GetLongReadOnly(int32_t* aLongReadOnly){ + *aLongReadOnly = longProperty; + return NS_OK; +} +NS_IMETHODIMP xpcTestObjectReadOnly :: GetFloatReadOnly(float* aFloatReadOnly){ + *aFloatReadOnly = floatProperty; + return NS_OK; +} +NS_IMETHODIMP xpcTestObjectReadOnly :: GetCharReadOnly(char* aCharReadOnly){ + *aCharReadOnly = charProperty; + return NS_OK; +} +NS_IMETHODIMP xpcTestObjectReadOnly :: GetTimeReadOnly(PRTime* aTimeReadOnly){ + *aTimeReadOnly = timeProperty; + return NS_OK; +} + +NS_IMPL_ISUPPORTS(xpcTestObjectReadWrite, nsIXPCTestObjectReadWrite) + +xpcTestObjectReadWrite :: xpcTestObjectReadWrite() { + const char s[] = "XPConnect Read-Writable String"; + stringProperty = (char*) nsMemory::Clone(s, sizeof(char)*(strlen(s)+1)); + boolProperty = true; + shortProperty = 32767; + longProperty = 2147483647; + floatProperty = 5.5f; + charProperty = 'X'; + // timeProperty is PRTime and signed type. + // So it has to allow negative value. + timeProperty = -1; +} + +xpcTestObjectReadWrite :: ~xpcTestObjectReadWrite() +{ + free(stringProperty); +} + +NS_IMETHODIMP xpcTestObjectReadWrite :: GetStringProperty(char * *aStringProperty) { + if (!aStringProperty) + return NS_ERROR_NULL_POINTER; + *aStringProperty = (char*) nsMemory::Clone(stringProperty, + sizeof(char)*(strlen(stringProperty)+1)); + return *aStringProperty ? NS_OK : NS_ERROR_OUT_OF_MEMORY; + +} +NS_IMETHODIMP xpcTestObjectReadWrite :: SetStringProperty(const char * aStringProperty) { + free(stringProperty); + stringProperty = (char*) nsMemory::Clone(aStringProperty, + sizeof(char)*(strlen(aStringProperty)+1)); + return NS_OK; +} + +NS_IMETHODIMP xpcTestObjectReadWrite :: GetBooleanProperty(bool* aBooleanProperty) { + *aBooleanProperty = boolProperty; + return NS_OK; +} +NS_IMETHODIMP xpcTestObjectReadWrite :: SetBooleanProperty(bool aBooleanProperty) { + boolProperty = aBooleanProperty; + return NS_OK; +} +NS_IMETHODIMP xpcTestObjectReadWrite :: GetShortProperty(int16_t* aShortProperty) { + *aShortProperty = shortProperty; + return NS_OK; +} +NS_IMETHODIMP xpcTestObjectReadWrite :: SetShortProperty(int16_t aShortProperty) { + shortProperty = aShortProperty; + return NS_OK; +} +NS_IMETHODIMP xpcTestObjectReadWrite :: GetLongProperty(int32_t* aLongProperty) { + *aLongProperty = longProperty; + return NS_OK; +} +NS_IMETHODIMP xpcTestObjectReadWrite :: SetLongProperty(int32_t aLongProperty) { + longProperty = aLongProperty; + return NS_OK; +} +NS_IMETHODIMP xpcTestObjectReadWrite :: GetFloatProperty(float* aFloatProperty) { + *aFloatProperty = floatProperty; + return NS_OK; +} +NS_IMETHODIMP xpcTestObjectReadWrite :: SetFloatProperty(float aFloatProperty) { + floatProperty = aFloatProperty; + return NS_OK; +} +NS_IMETHODIMP xpcTestObjectReadWrite :: GetCharProperty(char* aCharProperty) { + *aCharProperty = charProperty; + return NS_OK; +} +NS_IMETHODIMP xpcTestObjectReadWrite :: SetCharProperty(char aCharProperty) { + charProperty = aCharProperty; + return NS_OK; +} +NS_IMETHODIMP xpcTestObjectReadWrite :: GetTimeProperty(PRTime* aTimeProperty) { + *aTimeProperty = timeProperty; + return NS_OK; +} +NS_IMETHODIMP xpcTestObjectReadWrite :: SetTimeProperty(PRTime aTimeProperty) { + timeProperty = aTimeProperty; + return NS_OK; +} diff --git a/js/xpconnect/tests/components/native/xpctest_module.cpp b/js/xpconnect/tests/components/native/xpctest_module.cpp new file mode 100644 index 0000000000..f6c29968b9 --- /dev/null +++ b/js/xpconnect/tests/components/native/xpctest_module.cpp @@ -0,0 +1,59 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/* module registration and factory code. */ + +#include "mozilla/ModuleUtils.h" +#include "xpctest_private.h" + +#define NS_XPCTESTOBJECTREADONLY_CID \ +{ 0x492609a7, 0x2582, 0x436b, \ + { 0xb0, 0xef, 0x92, 0xe2, 0x9b, 0xb9, 0xe1, 0x43 } } + +#define NS_XPCTESTOBJECTREADWRITE_CID \ +{ 0x8f37f760, 0x3686, 0x4dbb, \ + { 0xb1, 0x21, 0x96, 0x93, 0xba, 0x81, 0x3f, 0x8f } } + +#define NS_XPCTESTPARAMS_CID \ +{ 0x1f11076a, 0x0fa2, 0x4f07, \ + { 0xb4, 0x7a, 0xa1, 0x54, 0x31, 0xf2, 0xce, 0xf7 } } + +#define NS_XPCTESTRETURNCODEPARENT_CID \ +{ 0x3818f744, 0x5445, 0x4e9c, \ + { 0x9b, 0xb8, 0x64, 0x62, 0xfe, 0x81, 0xb6, 0x19 } } + +NS_GENERIC_FACTORY_CONSTRUCTOR(xpcTestObjectReadOnly) +NS_GENERIC_FACTORY_CONSTRUCTOR(xpcTestObjectReadWrite) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsXPCTestParams) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsXPCTestReturnCodeParent) +NS_DEFINE_NAMED_CID(NS_XPCTESTOBJECTREADONLY_CID); +NS_DEFINE_NAMED_CID(NS_XPCTESTOBJECTREADWRITE_CID); +NS_DEFINE_NAMED_CID(NS_XPCTESTPARAMS_CID); +NS_DEFINE_NAMED_CID(NS_XPCTESTRETURNCODEPARENT_CID); + +static const mozilla::Module::CIDEntry kXPCTestCIDs[] = { + { &kNS_XPCTESTOBJECTREADONLY_CID, false, nullptr, xpcTestObjectReadOnlyConstructor }, + { &kNS_XPCTESTOBJECTREADWRITE_CID, false, nullptr, xpcTestObjectReadWriteConstructor }, + { &kNS_XPCTESTPARAMS_CID, false, nullptr, nsXPCTestParamsConstructor }, + { &kNS_XPCTESTRETURNCODEPARENT_CID, false, nullptr, nsXPCTestReturnCodeParentConstructor }, + { nullptr } +}; + +static const mozilla::Module::ContractIDEntry kXPCTestContracts[] = { + { "@mozilla.org/js/xpc/test/native/ObjectReadOnly;1", &kNS_XPCTESTOBJECTREADONLY_CID }, + { "@mozilla.org/js/xpc/test/native/ObjectReadWrite;1", &kNS_XPCTESTOBJECTREADWRITE_CID }, + { "@mozilla.org/js/xpc/test/native/Params;1", &kNS_XPCTESTPARAMS_CID }, + { "@mozilla.org/js/xpc/test/native/ReturnCodeParent;1", &kNS_XPCTESTRETURNCODEPARENT_CID }, + { nullptr } +}; + +static const mozilla::Module kXPCTestModule = { + mozilla::Module::kVersion, + kXPCTestCIDs, + kXPCTestContracts +}; + +NSMODULE_DEFN(xpconnect_test) = &kXPCTestModule; diff --git a/js/xpconnect/tests/components/native/xpctest_params.cpp b/js/xpconnect/tests/components/native/xpctest_params.cpp new file mode 100644 index 0000000000..e88746d893 --- /dev/null +++ b/js/xpconnect/tests/components/native/xpctest_params.cpp @@ -0,0 +1,308 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "xpctest_private.h" +#include "xpctest_interfaces.h" +#include "js/Value.h" + +NS_IMPL_ISUPPORTS(nsXPCTestParams, nsIXPCTestParams) + +nsXPCTestParams::nsXPCTestParams() +{ +} + +nsXPCTestParams::~nsXPCTestParams() +{ +} + +#define GENERIC_METHOD_IMPL { \ + *_retval = *b; \ + *b = a; \ + return NS_OK; \ +} + +#define STRING_METHOD_IMPL { \ + _retval.Assign(b); \ + b.Assign(a); \ + return NS_OK; \ +} + +#define TAKE_OWNERSHIP_NOOP(val) {} +#define TAKE_OWNERSHIP_INTERFACE(val) {static_cast<nsISupports*>(val)->AddRef();} +#define TAKE_OWNERSHIP_STRING(val) { \ + nsDependentCString vprime(val); \ + val = ToNewCString(vprime); \ +} +#define TAKE_OWNERSHIP_WSTRING(val) { \ + nsDependentString vprime(val); \ + val = ToNewUnicode(vprime); \ +} + +// Macro for our buffer-oriented types: +// 'type' is the type of element that the buffer contains. +// 'padding' is an offset added to length, allowing us to handle +// null-terminated strings. +// 'TAKE_OWNERSHIP' is one of the macros above. +#define BUFFER_METHOD_IMPL(type, padding, TAKE_OWNERSHIP) { \ + uint32_t elemSize = sizeof(type); \ + \ + /* Copy b into rv. */ \ + *rvLength = *bLength; \ + *rv = static_cast<type*>(moz_xmalloc(elemSize * (*bLength + padding))); \ + if (!*rv) \ + return NS_ERROR_OUT_OF_MEMORY; \ + memcpy(*rv, *b, elemSize * (*bLength + padding)); \ + \ + /* Copy a into b. */ \ + *bLength = aLength; \ + free(*b); \ + *b = static_cast<type*>(moz_xmalloc(elemSize * (aLength + padding))); \ + if (!*b) \ + return NS_ERROR_OUT_OF_MEMORY; \ + memcpy(*b, a, elemSize * (aLength + padding)); \ + \ + /* We need to take ownership of the data we got from a, \ + since the caller owns it. */ \ + for (unsigned i = 0; i < *bLength + padding; ++i) \ + TAKE_OWNERSHIP((*b)[i]); \ + \ + return NS_OK; \ +} + +NS_IMETHODIMP nsXPCTestParams::TestBoolean(bool a, bool* b, bool* _retval) +{ + GENERIC_METHOD_IMPL; +} + +NS_IMETHODIMP nsXPCTestParams::TestOctet(uint8_t a, uint8_t* b, uint8_t* _retval) +{ + GENERIC_METHOD_IMPL; +} + +NS_IMETHODIMP nsXPCTestParams::TestShort(int16_t a, int16_t* b, int16_t* _retval) +{ + GENERIC_METHOD_IMPL; +} + +NS_IMETHODIMP nsXPCTestParams::TestLong(int32_t a, int32_t* b, int32_t* _retval) +{ + GENERIC_METHOD_IMPL; +} + +NS_IMETHODIMP nsXPCTestParams::TestLongLong(int64_t a, int64_t* b, int64_t* _retval) +{ + GENERIC_METHOD_IMPL; +} + +NS_IMETHODIMP nsXPCTestParams::TestUnsignedShort(uint16_t a, uint16_t* b, uint16_t* _retval) +{ + GENERIC_METHOD_IMPL; +} + +NS_IMETHODIMP nsXPCTestParams::TestUnsignedLong(uint32_t a, uint32_t* b, uint32_t* _retval) +{ + GENERIC_METHOD_IMPL; +} + +NS_IMETHODIMP nsXPCTestParams::TestUnsignedLongLong(uint64_t a, uint64_t* b, uint64_t* _retval) +{ + GENERIC_METHOD_IMPL; +} + +NS_IMETHODIMP nsXPCTestParams::TestFloat(float a, float* b, float* _retval) +{ + GENERIC_METHOD_IMPL; +} + +NS_IMETHODIMP nsXPCTestParams::TestDouble(double a, float* b, double* _retval) +{ + GENERIC_METHOD_IMPL; +} + +NS_IMETHODIMP nsXPCTestParams::TestChar(char a, char* b, char* _retval) +{ + GENERIC_METHOD_IMPL; +} + +NS_IMETHODIMP nsXPCTestParams::TestString(const char * a, char * *b, char * *_retval) +{ + nsDependentCString aprime(a); + nsDependentCString bprime(*b); + *_retval = ToNewCString(bprime); + *b = ToNewCString(aprime); + + // XPCOM ownership rules dictate that overwritten inout params must be callee-freed. + // See https://developer.mozilla.org/en/XPIDL + free(const_cast<char*>(bprime.get())); + + return NS_OK; +} + +NS_IMETHODIMP nsXPCTestParams::TestWchar(char16_t a, char16_t* b, char16_t* _retval) +{ + GENERIC_METHOD_IMPL; +} + +NS_IMETHODIMP nsXPCTestParams::TestWstring(const char16_t * a, char16_t * *b, char16_t * *_retval) +{ + nsDependentString aprime(a); + nsDependentString bprime(*b); + *_retval = ToNewUnicode(bprime); + *b = ToNewUnicode(aprime); + + // XPCOM ownership rules dictate that overwritten inout params must be callee-freed. + // See https://developer.mozilla.org/en/XPIDL + free((void*)bprime.get()); + + return NS_OK; +} + +NS_IMETHODIMP nsXPCTestParams::TestDOMString(const nsAString & a, nsAString & b, nsAString & _retval) +{ + STRING_METHOD_IMPL; +} + + +NS_IMETHODIMP nsXPCTestParams::TestAString(const nsAString & a, nsAString & b, nsAString & _retval) +{ + STRING_METHOD_IMPL; +} + +NS_IMETHODIMP nsXPCTestParams::TestAUTF8String(const nsACString & a, nsACString & b, nsACString & _retval) +{ + STRING_METHOD_IMPL; +} + +NS_IMETHODIMP nsXPCTestParams::TestACString(const nsACString & a, nsACString & b, nsACString & _retval) +{ + STRING_METHOD_IMPL; +} + +NS_IMETHODIMP nsXPCTestParams::TestJsval(JS::Handle<JS::Value> a, + JS::MutableHandle<JS::Value> b, + JS::MutableHandle<JS::Value> _retval) +{ + _retval.set(b); + b.set(a); + return NS_OK; +} + +NS_IMETHODIMP nsXPCTestParams::TestShortArray(uint32_t aLength, int16_t* a, + uint32_t* bLength, int16_t** b, + uint32_t* rvLength, int16_t** rv) +{ + BUFFER_METHOD_IMPL(int16_t, 0, TAKE_OWNERSHIP_NOOP); +} + +NS_IMETHODIMP nsXPCTestParams::TestDoubleArray(uint32_t aLength, double* a, + uint32_t* bLength, double** b, + uint32_t* rvLength, double** rv) +{ + BUFFER_METHOD_IMPL(double, 0, TAKE_OWNERSHIP_NOOP); +} + +NS_IMETHODIMP nsXPCTestParams::TestStringArray(uint32_t aLength, const char * *a, + uint32_t* bLength, char * **b, + uint32_t* rvLength, char * **rv) +{ + BUFFER_METHOD_IMPL(char*, 0, TAKE_OWNERSHIP_STRING); +} + +NS_IMETHODIMP nsXPCTestParams::TestWstringArray(uint32_t aLength, const char16_t * *a, + uint32_t* bLength, char16_t * **b, + uint32_t* rvLength, char16_t * **rv) +{ + BUFFER_METHOD_IMPL(char16_t*, 0, TAKE_OWNERSHIP_WSTRING); +} + +NS_IMETHODIMP nsXPCTestParams::TestInterfaceArray(uint32_t aLength, nsIXPCTestInterfaceA** a, + uint32_t* bLength, nsIXPCTestInterfaceA * **b, + uint32_t* rvLength, nsIXPCTestInterfaceA * **rv) +{ + BUFFER_METHOD_IMPL(nsIXPCTestInterfaceA*, 0, TAKE_OWNERSHIP_INTERFACE); +} + +NS_IMETHODIMP nsXPCTestParams::TestSizedString(uint32_t aLength, const char * a, + uint32_t* bLength, char * *b, + uint32_t* rvLength, char * *rv) +{ + BUFFER_METHOD_IMPL(char, 1, TAKE_OWNERSHIP_NOOP); +} + +NS_IMETHODIMP nsXPCTestParams::TestSizedWstring(uint32_t aLength, const char16_t * a, + uint32_t* bLength, char16_t * *b, + uint32_t* rvLength, char16_t * *rv) +{ + BUFFER_METHOD_IMPL(char16_t, 1, TAKE_OWNERSHIP_NOOP); +} + +NS_IMETHODIMP nsXPCTestParams::TestInterfaceIs(const nsIID* aIID, void* a, + nsIID** bIID, void** b, + nsIID** rvIID, void** rv) +{ + // + // Getting the buffers and ownership right here can be a little tricky. + // + + // The interface pointers are heap-allocated, and b has been AddRef'd + // by XPConnect for the duration of the call. If we snatch it away from b + // and leave no trace, XPConnect won't Release it. Since we also need to + // return an already-AddRef'd pointer in rv, we don't need to do anything + // special here. + *rv = *b; + + // rvIID is out-only, so nobody allocated an IID buffer for us. Do that now, + // and store b's IID in the new buffer. + *rvIID = static_cast<nsIID*>(moz_xmalloc(sizeof(nsID))); + if (!*rvIID) + return NS_ERROR_OUT_OF_MEMORY; + **rvIID = **bIID; + + // Copy the interface pointer from a to b. Since a is in-only, XPConnect will + // release it upon completion of the call. AddRef it for b. + *b = a; + static_cast<nsISupports*>(*b)->AddRef(); + + // We already had a buffer allocated for b's IID, so we can re-use it. + **bIID = *aIID; + + return NS_OK; +} + +NS_IMETHODIMP nsXPCTestParams::TestInterfaceIsArray(uint32_t aLength, const nsIID* aIID, + void** a, + uint32_t* bLength, nsIID** bIID, + void*** b, + uint32_t* rvLength, nsIID** rvIID, + void*** rv) +{ + // Transfer the IIDs. See the comments in TestInterfaceIs (above) for an + // explanation of what we're doing. + *rvIID = static_cast<nsIID*>(moz_xmalloc(sizeof(nsID))); + if (!*rvIID) + return NS_ERROR_OUT_OF_MEMORY; + **rvIID = **bIID; + **bIID = *aIID; + + // The macro is agnostic to the actual interface types, so we can re-use code here. + // + // Do this second, since the macro returns. + BUFFER_METHOD_IMPL(void*, 0, TAKE_OWNERSHIP_INTERFACE); +} + +NS_IMETHODIMP nsXPCTestParams::TestOutAString(nsAString & o) +{ + o.AssignLiteral("out"); + return NS_OK; +} + +NS_IMETHODIMP nsXPCTestParams::TestStringArrayOptionalSize(const char * *a, uint32_t length, nsACString& out) +{ + out.Truncate(); + for (uint32_t i = 0; i < length; ++i) { + out.Append(a[i]); + } + + return NS_OK; +} diff --git a/js/xpconnect/tests/components/native/xpctest_private.h b/js/xpconnect/tests/components/native/xpctest_private.h new file mode 100644 index 0000000000..45e3f12e48 --- /dev/null +++ b/js/xpconnect/tests/components/native/xpctest_private.h @@ -0,0 +1,80 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/* local header for xpconnect tests components */ + +#ifndef xpctest_private_h___ +#define xpctest_private_h___ + +#include "nsISupports.h" +#include "nsMemory.h" +#include "nsStringGlue.h" +#include "xpctest_attributes.h" +#include "xpctest_params.h" +#include "xpctest_returncode.h" +#include "mozilla/Attributes.h" + +class xpcTestObjectReadOnly final : public nsIXPCTestObjectReadOnly { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIXPCTESTOBJECTREADONLY + xpcTestObjectReadOnly(); + + private: + ~xpcTestObjectReadOnly() {} + + bool boolProperty; + int16_t shortProperty; + int32_t longProperty; + float floatProperty; + char charProperty; + PRTime timeProperty; +}; + +class xpcTestObjectReadWrite final : public nsIXPCTestObjectReadWrite { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIXPCTESTOBJECTREADWRITE + + xpcTestObjectReadWrite(); + + private: + ~xpcTestObjectReadWrite(); + + bool boolProperty; + int16_t shortProperty; + int32_t longProperty; + float floatProperty; + char charProperty; + char* stringProperty; + PRTime timeProperty; +}; + +class nsXPCTestParams final : public nsIXPCTestParams +{ +public: + NS_DECL_ISUPPORTS + NS_DECL_NSIXPCTESTPARAMS + + nsXPCTestParams(); + +private: + ~nsXPCTestParams(); +}; + +class nsXPCTestReturnCodeParent final : public nsIXPCTestReturnCodeParent +{ +public: + NS_DECL_ISUPPORTS + NS_DECL_NSIXPCTESTRETURNCODEPARENT + + nsXPCTestReturnCodeParent(); + +private: + ~nsXPCTestReturnCodeParent(); +}; + +#endif /* xpctest_private_h___ */ diff --git a/js/xpconnect/tests/components/native/xpctest_returncode.cpp b/js/xpconnect/tests/components/native/xpctest_returncode.cpp new file mode 100644 index 0000000000..3ae7d42796 --- /dev/null +++ b/js/xpconnect/tests/components/native/xpctest_returncode.cpp @@ -0,0 +1,27 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "xpctest_private.h" +#include "xpctest_interfaces.h" +#include "nsComponentManagerUtils.h" + +NS_IMPL_ISUPPORTS(nsXPCTestReturnCodeParent, nsIXPCTestReturnCodeParent) + +nsXPCTestReturnCodeParent::nsXPCTestReturnCodeParent() +{ +} + +nsXPCTestReturnCodeParent::~nsXPCTestReturnCodeParent() +{ +} + +NS_IMETHODIMP nsXPCTestReturnCodeParent::CallChild(int32_t childBehavior, nsresult* _retval) +{ + nsresult rv; + nsCOMPtr<nsIXPCTestReturnCodeChild> child(do_CreateInstance("@mozilla.org/js/xpc/test/js/ReturnCodeChild;1", &rv)); + NS_ENSURE_SUCCESS(rv, rv); + rv = child->DoIt(childBehavior); + *_retval = rv; + return NS_OK; +} |