diff options
Diffstat (limited to 'js/xpconnect/src/XPCConvert.cpp')
| -rw-r--r-- | js/xpconnect/src/XPCConvert.cpp | 1799 |
1 files changed, 1799 insertions, 0 deletions
diff --git a/js/xpconnect/src/XPCConvert.cpp b/js/xpconnect/src/XPCConvert.cpp new file mode 100644 index 000000000..37932b452 --- /dev/null +++ b/js/xpconnect/src/XPCConvert.cpp @@ -0,0 +1,1799 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* vim: set ts=8 sts=4 et sw=4 tw=99: */ +/* 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/. */ + +/* Data conversion between native and JavaScript types. */ + +#include "mozilla/ArrayUtils.h" +#include "mozilla/Range.h" + +#include "xpcprivate.h" +#include "nsIAtom.h" +#include "nsWrapperCache.h" +#include "nsJSUtils.h" +#include "nsQueryObject.h" +#include "WrapperFactory.h" + +#include "nsWrapperCacheInlines.h" + +#include "jsapi.h" +#include "jsfriendapi.h" +#include "js/CharacterEncoding.h" +#include "jsprf.h" + +#include "mozilla/dom/BindingUtils.h" +#include "mozilla/dom/DOMException.h" +#include "mozilla/dom/PrimitiveConversions.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/jsipc/CrossProcessObjectWrappers.h" + +using namespace xpc; +using namespace mozilla; +using namespace mozilla::dom; +using namespace JS; + +//#define STRICT_CHECK_OF_UNICODE +#ifdef STRICT_CHECK_OF_UNICODE +#define ILLEGAL_RANGE(c) (0!=((c) & 0xFF80)) +#else // STRICT_CHECK_OF_UNICODE +#define ILLEGAL_RANGE(c) (0!=((c) & 0xFF00)) +#endif // STRICT_CHECK_OF_UNICODE + +#define ILLEGAL_CHAR_RANGE(c) (0!=((c) & 0x80)) + +/***********************************************************/ + +// static +bool +XPCConvert::IsMethodReflectable(const XPTMethodDescriptor& info) +{ + if (XPT_MD_IS_NOTXPCOM(info.flags) || XPT_MD_IS_HIDDEN(info.flags)) + return false; + + for (int i = info.num_args-1; i >= 0; i--) { + const nsXPTParamInfo& param = info.params[i]; + const nsXPTType& type = param.GetType(); + + // Reflected methods can't use native types. All native types end up + // getting tagged as void*, so this check is easy. + if (type.TagPart() == nsXPTType::T_VOID) + return false; + } + return true; +} + +static JSObject* +UnwrapNativeCPOW(nsISupports* wrapper) +{ + nsCOMPtr<nsIXPConnectWrappedJS> underware = do_QueryInterface(wrapper); + if (underware) { + JSObject* mainObj = underware->GetJSObject(); + if (mainObj && mozilla::jsipc::IsWrappedCPOW(mainObj)) + return mainObj; + } + return nullptr; +} + +/***************************************************************************/ + +// static +bool +XPCConvert::GetISupportsFromJSObject(JSObject* obj, nsISupports** iface) +{ + const JSClass* jsclass = js::GetObjectJSClass(obj); + MOZ_ASSERT(jsclass, "obj has no class"); + if (jsclass && + (jsclass->flags & JSCLASS_HAS_PRIVATE) && + (jsclass->flags & JSCLASS_PRIVATE_IS_NSISUPPORTS)) { + *iface = (nsISupports*) xpc_GetJSPrivate(obj); + return true; + } + *iface = UnwrapDOMObjectToISupports(obj); + return !!*iface; +} + +/***************************************************************************/ + +// static +bool +XPCConvert::NativeData2JS(MutableHandleValue d, const void* s, + const nsXPTType& type, const nsID* iid, nsresult* pErr) +{ + NS_PRECONDITION(s, "bad param"); + + AutoJSContext cx; + if (pErr) + *pErr = NS_ERROR_XPC_BAD_CONVERT_NATIVE; + + switch (type.TagPart()) { + case nsXPTType::T_I8 : + d.setInt32(*static_cast<const int8_t*>(s)); + return true; + case nsXPTType::T_I16 : + d.setInt32(*static_cast<const int16_t*>(s)); + return true; + case nsXPTType::T_I32 : + d.setInt32(*static_cast<const int32_t*>(s)); + return true; + case nsXPTType::T_I64 : + d.setNumber(static_cast<double>(*static_cast<const int64_t*>(s))); + return true; + case nsXPTType::T_U8 : + d.setInt32(*static_cast<const uint8_t*>(s)); + return true; + case nsXPTType::T_U16 : + d.setInt32(*static_cast<const uint16_t*>(s)); + return true; + case nsXPTType::T_U32 : + d.setNumber(*static_cast<const uint32_t*>(s)); + return true; + case nsXPTType::T_U64 : + d.setNumber(static_cast<double>(*static_cast<const uint64_t*>(s))); + return true; + case nsXPTType::T_FLOAT : + d.setNumber(*static_cast<const float*>(s)); + return true; + case nsXPTType::T_DOUBLE: + d.setNumber(*static_cast<const double*>(s)); + return true; + case nsXPTType::T_BOOL : + d.setBoolean(*static_cast<const bool*>(s)); + return true; + case nsXPTType::T_CHAR : + { + char p = *static_cast<const char*>(s); + +#ifdef STRICT_CHECK_OF_UNICODE + MOZ_ASSERT(! ILLEGAL_CHAR_RANGE(p) , "passing non ASCII data"); +#endif // STRICT_CHECK_OF_UNICODE + + JSString* str = JS_NewStringCopyN(cx, &p, 1); + if (!str) + return false; + + d.setString(str); + return true; + } + case nsXPTType::T_WCHAR : + { + char16_t p = *static_cast<const char16_t*>(s); + + JSString* str = JS_NewUCStringCopyN(cx, &p, 1); + if (!str) + return false; + + d.setString(str); + return true; + } + + case nsXPTType::T_JSVAL : + { + d.set(*static_cast<const Value*>(s)); + return JS_WrapValue(cx, d); + } + + case nsXPTType::T_VOID: + XPC_LOG_ERROR(("XPCConvert::NativeData2JS : void* params not supported")); + return false; + + case nsXPTType::T_IID: + { + nsID* iid2 = *static_cast<nsID* const*>(s); + if (!iid2) { + d.setNull(); + return true; + } + + RootedObject scope(cx, JS::CurrentGlobalOrNull(cx)); + JSObject* obj = xpc_NewIDObject(cx, scope, *iid2); + if (!obj) + return false; + + d.setObject(*obj); + return true; + } + + case nsXPTType::T_ASTRING: + // Fall through to T_DOMSTRING case + + case nsXPTType::T_DOMSTRING: + { + const nsAString* p = *static_cast<const nsAString* const*>(s); + if (!p || p->IsVoid()) { + d.setNull(); + return true; + } + + nsStringBuffer* buf; + if (!XPCStringConvert::ReadableToJSVal(cx, *p, &buf, d)) + return false; + if (buf) + buf->AddRef(); + return true; + } + + case nsXPTType::T_CHAR_STR: + { + const char* p = *static_cast<const char* const*>(s); + if (!p) { + d.setNull(); + return true; + } + +#ifdef STRICT_CHECK_OF_UNICODE + bool isAscii = true; + for (char* t = p; *t && isAscii; t++) { + if (ILLEGAL_CHAR_RANGE(*t)) + isAscii = false; + } + MOZ_ASSERT(isAscii, "passing non ASCII data"); +#endif // STRICT_CHECK_OF_UNICODE + + JSString* str = JS_NewStringCopyZ(cx, p); + if (!str) + return false; + + d.setString(str); + return true; + } + + case nsXPTType::T_WCHAR_STR: + { + const char16_t* p = *static_cast<const char16_t* const*>(s); + if (!p) { + d.setNull(); + return true; + } + + JSString* str = JS_NewUCStringCopyZ(cx, p); + if (!str) + return false; + + d.setString(str); + return true; + } + case nsXPTType::T_UTF8STRING: + { + const nsACString* utf8String = *static_cast<const nsACString* const*>(s); + + if (!utf8String || utf8String->IsVoid()) { + d.setNull(); + return true; + } + + if (utf8String->IsEmpty()) { + d.set(JS_GetEmptyStringValue(cx)); + return true; + } + + const uint32_t len = CalcUTF8ToUnicodeLength(*utf8String); + // The cString is not empty at this point, but the calculated + // UTF-16 length is zero, meaning no valid conversion exists. + if (!len) + return false; + + const size_t buffer_size = (len + 1) * sizeof(char16_t); + char16_t* buffer = + static_cast<char16_t*>(JS_malloc(cx, buffer_size)); + if (!buffer) + return false; + + uint32_t copied; + if (!UTF8ToUnicodeBuffer(*utf8String, buffer, &copied) || + len != copied) { + // Copy or conversion during copy failed. Did not copy the + // whole string. + JS_free(cx, buffer); + return false; + } + + // JS_NewUCString takes ownership on success, i.e. a + // successful call will make it the responsiblity of the JS VM + // to free the buffer. + JSString* str = JS_NewUCString(cx, buffer, len); + if (!str) { + JS_free(cx, buffer); + return false; + } + + d.setString(str); + return true; + } + case nsXPTType::T_CSTRING: + { + const nsACString* cString = *static_cast<const nsACString* const*>(s); + + if (!cString || cString->IsVoid()) { + d.setNull(); + return true; + } + + // c-strings (binary blobs) are deliberately not converted from + // UTF-8 to UTF-16. T_UTF8Sting is for UTF-8 encoded strings + // with automatic conversion. + JSString* str = JS_NewStringCopyN(cx, cString->Data(), + cString->Length()); + if (!str) + return false; + + d.setString(str); + return true; + } + + case nsXPTType::T_INTERFACE: + case nsXPTType::T_INTERFACE_IS: + { + nsISupports* iface = *static_cast<nsISupports* const*>(s); + if (!iface) { + d.setNull(); + return true; + } + + if (iid->Equals(NS_GET_IID(nsIVariant))) { + nsCOMPtr<nsIVariant> variant = do_QueryInterface(iface); + if (!variant) + return false; + + return XPCVariant::VariantDataToJS(variant, + pErr, d); + } + + xpcObjectHelper helper(iface); + return NativeInterface2JSObject(d, nullptr, helper, iid, true, pErr); + } + + default: + NS_ERROR("bad type"); + return false; + } + return true; +} + +/***************************************************************************/ + +#ifdef DEBUG +static bool +CheckChar16InCharRange(char16_t c) +{ + if (ILLEGAL_RANGE(c)) { + /* U+0080/U+0100 - U+FFFF data lost. */ + static const size_t MSG_BUF_SIZE = 64; + char msg[MSG_BUF_SIZE]; + snprintf(msg, MSG_BUF_SIZE, "char16_t out of char range; high bits of data lost: 0x%x", int(c)); + NS_WARNING(msg); + return false; + } + + return true; +} + +template<typename CharT> +static void +CheckCharsInCharRange(const CharT* chars, size_t len) +{ + for (size_t i = 0; i < len; i++) { + if (!CheckChar16InCharRange(chars[i])) + break; + } +} +#endif + +template<typename T> +bool ConvertToPrimitive(JSContext* cx, HandleValue v, T* retval) +{ + return ValueToPrimitive<T, eDefault>(cx, v, retval); +} + +// static +bool +XPCConvert::JSData2Native(void* d, HandleValue s, + const nsXPTType& type, + const nsID* iid, + nsresult* pErr) +{ + NS_PRECONDITION(d, "bad param"); + + AutoJSContext cx; + if (pErr) + *pErr = NS_ERROR_XPC_BAD_CONVERT_JS; + + switch (type.TagPart()) { + case nsXPTType::T_I8 : + return ConvertToPrimitive(cx, s, static_cast<int8_t*>(d)); + case nsXPTType::T_I16 : + return ConvertToPrimitive(cx, s, static_cast<int16_t*>(d)); + case nsXPTType::T_I32 : + return ConvertToPrimitive(cx, s, static_cast<int32_t*>(d)); + case nsXPTType::T_I64 : + return ConvertToPrimitive(cx, s, static_cast<int64_t*>(d)); + case nsXPTType::T_U8 : + return ConvertToPrimitive(cx, s, static_cast<uint8_t*>(d)); + case nsXPTType::T_U16 : + return ConvertToPrimitive(cx, s, static_cast<uint16_t*>(d)); + case nsXPTType::T_U32 : + return ConvertToPrimitive(cx, s, static_cast<uint32_t*>(d)); + case nsXPTType::T_U64 : + return ConvertToPrimitive(cx, s, static_cast<uint64_t*>(d)); + case nsXPTType::T_FLOAT : + return ConvertToPrimitive(cx, s, static_cast<float*>(d)); + case nsXPTType::T_DOUBLE : + return ConvertToPrimitive(cx, s, static_cast<double*>(d)); + case nsXPTType::T_BOOL : + return ConvertToPrimitive(cx, s, static_cast<bool*>(d)); + case nsXPTType::T_CHAR : + { + JSString* str = ToString(cx, s); + if (!str) { + return false; + } + + char16_t ch; + if (JS_GetStringLength(str) == 0) { + ch = 0; + } else { + if (!JS_GetStringCharAt(cx, str, 0, &ch)) + return false; + } +#ifdef DEBUG + CheckChar16InCharRange(ch); +#endif + *((char*)d) = char(ch); + break; + } + case nsXPTType::T_WCHAR : + { + JSString* str; + if (!(str = ToString(cx, s))) { + return false; + } + size_t length = JS_GetStringLength(str); + if (length == 0) { + *((uint16_t*)d) = 0; + break; + } + + char16_t ch; + if (!JS_GetStringCharAt(cx, str, 0, &ch)) + return false; + + *((uint16_t*)d) = uint16_t(ch); + break; + } + case nsXPTType::T_JSVAL : + *((Value*)d) = s; + break; + case nsXPTType::T_VOID: + XPC_LOG_ERROR(("XPCConvert::JSData2Native : void* params not supported")); + NS_ERROR("void* params not supported"); + return false; + case nsXPTType::T_IID: + { + const nsID* pid = nullptr; + + // There's no good reason to pass a null IID. + if (s.isNullOrUndefined()) { + if (pErr) + *pErr = NS_ERROR_XPC_BAD_CONVERT_JS; + return false; + } + + if (!s.isObject() || + (!(pid = xpc_JSObjectToID(cx, &s.toObject()))) || + (!(pid = (const nsID*) nsMemory::Clone(pid, sizeof(nsID))))) { + return false; + } + *((const nsID**)d) = pid; + return true; + } + + case nsXPTType::T_ASTRING: + { + if (s.isUndefined()) { + (**((nsAString**)d)).SetIsVoid(true); + return true; + } + MOZ_FALLTHROUGH; + } + case nsXPTType::T_DOMSTRING: + { + if (s.isNull()) { + (**((nsAString**)d)).SetIsVoid(true); + return true; + } + size_t length = 0; + JSString* str = nullptr; + if (!s.isUndefined()) { + str = ToString(cx, s); + if (!str) + return false; + + length = JS_GetStringLength(str); + if (!length) { + (**((nsAString**)d)).Truncate(); + return true; + } + } + + nsAString* ws = *((nsAString**)d); + + if (!str) { + ws->AssignLiteral(u"undefined"); + } else if (XPCStringConvert::IsDOMString(str)) { + // The characters represent an existing nsStringBuffer that + // was shared by XPCStringConvert::ReadableToJSVal. + const char16_t* chars = JS_GetTwoByteExternalStringChars(str); + if (chars[length] == '\0') { + // Safe to share the buffer. + nsStringBuffer::FromData((void*)chars)->ToString(length, *ws); + } else { + // We have to copy to ensure null-termination. + ws->Assign(chars, length); + } + } else if (XPCStringConvert::IsLiteral(str)) { + // The characters represent a literal char16_t string constant + // compiled into libxul, such as the string "undefined" above. + const char16_t* chars = JS_GetTwoByteExternalStringChars(str); + ws->AssignLiteral(chars, length); + } else { + if (!AssignJSString(cx, *ws, str)) + return false; + } + return true; + } + + case nsXPTType::T_CHAR_STR: + { + if (s.isUndefined() || s.isNull()) { + *((char**)d) = nullptr; + return true; + } + + JSString* str = ToString(cx, s); + if (!str) { + return false; + } +#ifdef DEBUG + if (JS_StringHasLatin1Chars(str)) { + size_t len; + AutoCheckCannotGC nogc; + const Latin1Char* chars = JS_GetLatin1StringCharsAndLength(cx, nogc, str, &len); + if (chars) + CheckCharsInCharRange(chars, len); + } else { + size_t len; + AutoCheckCannotGC nogc; + const char16_t* chars = JS_GetTwoByteStringCharsAndLength(cx, nogc, str, &len); + if (chars) + CheckCharsInCharRange(chars, len); + } +#endif // DEBUG + size_t length = JS_GetStringEncodingLength(cx, str); + if (length == size_t(-1)) { + return false; + } + char* buffer = static_cast<char*>(moz_xmalloc(length + 1)); + if (!buffer) { + return false; + } + JS_EncodeStringToBuffer(cx, str, buffer, length); + buffer[length] = '\0'; + *((void**)d) = buffer; + return true; + } + + case nsXPTType::T_WCHAR_STR: + { + JSString* str; + + if (s.isUndefined() || s.isNull()) { + *((char16_t**)d) = nullptr; + return true; + } + + if (!(str = ToString(cx, s))) { + return false; + } + int len = JS_GetStringLength(str); + int byte_len = (len+1)*sizeof(char16_t); + if (!(*((void**)d) = moz_xmalloc(byte_len))) { + // XXX should report error + return false; + } + mozilla::Range<char16_t> destChars(*((char16_t**)d), len + 1); + if (!JS_CopyStringChars(cx, destChars, str)) + return false; + destChars[len] = 0; + + return true; + } + + case nsXPTType::T_UTF8STRING: + { + if (s.isNull() || s.isUndefined()) { + nsCString* rs = *((nsCString**)d); + rs->SetIsVoid(true); + return true; + } + + // The JS val is neither null nor void... + JSString* str = ToString(cx, s); + if (!str) + return false; + + size_t length = JS_GetStringLength(str); + if (!length) { + nsCString* rs = *((nsCString**)d); + rs->Truncate(); + return true; + } + + JSFlatString* flat = JS_FlattenString(cx, str); + if (!flat) + return false; + + size_t utf8Length = JS::GetDeflatedUTF8StringLength(flat); + nsACString* rs = *((nsACString**)d); + rs->SetLength(utf8Length); + + JS::DeflateStringToUTF8Buffer(flat, mozilla::RangedPtr<char>(rs->BeginWriting(), utf8Length)); + + return true; + } + + case nsXPTType::T_CSTRING: + { + if (s.isNull() || s.isUndefined()) { + nsACString* rs = *((nsACString**)d); + rs->SetIsVoid(true); + return true; + } + + // The JS val is neither null nor void... + JSString* str = ToString(cx, s); + if (!str) { + return false; + } + + size_t length = JS_GetStringEncodingLength(cx, str); + if (length == size_t(-1)) { + return false; + } + + if (!length) { + nsCString* rs = *((nsCString**)d); + rs->Truncate(); + return true; + } + + nsACString* rs = *((nsACString**)d); + rs->SetLength(uint32_t(length)); + if (rs->Length() != uint32_t(length)) { + return false; + } + JS_EncodeStringToBuffer(cx, str, rs->BeginWriting(), length); + + return true; + } + + case nsXPTType::T_INTERFACE: + case nsXPTType::T_INTERFACE_IS: + { + MOZ_ASSERT(iid,"can't do interface conversions without iid"); + + if (iid->Equals(NS_GET_IID(nsIVariant))) { + nsCOMPtr<nsIVariant> variant = XPCVariant::newVariant(cx, s); + if (!variant) + return false; + + variant.forget(static_cast<nsISupports**>(d)); + return true; + } else if (iid->Equals(NS_GET_IID(nsIAtom)) && s.isString()) { + // We're trying to pass a string as an nsIAtom. Let's atomize! + JSString* str = s.toString(); + nsAutoJSString autoStr; + if (!autoStr.init(cx, str)) { + if (pErr) + *pErr = NS_ERROR_XPC_BAD_CONVERT_JS_NULL_REF; + return false; + } + nsCOMPtr<nsIAtom> atom = NS_Atomize(autoStr); + atom.forget((nsISupports**)d); + return true; + } + //else ... + + if (s.isNullOrUndefined()) { + *((nsISupports**)d) = nullptr; + return true; + } + + // only wrap JSObjects + if (!s.isObject()) { + if (pErr && s.isInt32() && 0 == s.toInt32()) + *pErr = NS_ERROR_XPC_BAD_CONVERT_JS_ZERO_ISNOT_NULL; + return false; + } + + RootedObject src(cx, &s.toObject()); + return JSObject2NativeInterface((void**)d, src, iid, nullptr, pErr); + } + default: + NS_ERROR("bad type"); + return false; + } + return true; +} + +static inline bool +CreateHolderIfNeeded(HandleObject obj, MutableHandleValue d, + nsIXPConnectJSObjectHolder** dest) +{ + if (dest) { + if (!obj) + return false; + RefPtr<XPCJSObjectHolder> objHolder = new XPCJSObjectHolder(obj); + objHolder.forget(dest); + } + + d.setObjectOrNull(obj); + + return true; +} + +/***************************************************************************/ +// static +bool +XPCConvert::NativeInterface2JSObject(MutableHandleValue d, + nsIXPConnectJSObjectHolder** dest, + xpcObjectHelper& aHelper, + const nsID* iid, + bool allowNativeWrapper, + nsresult* pErr) +{ + if (!iid) + iid = &NS_GET_IID(nsISupports); + + d.setNull(); + if (dest) + *dest = nullptr; + if (!aHelper.Object()) + return true; + if (pErr) + *pErr = NS_ERROR_XPC_BAD_CONVERT_NATIVE; + + // We used to have code here that unwrapped and simply exposed the + // underlying JSObject. That caused anomolies when JSComponents were + // accessed from other JS code - they didn't act like other xpconnect + // wrapped components. So, instead, we create "double wrapped" objects + // (that means an XPCWrappedNative around an nsXPCWrappedJS). This isn't + // optimal -- we could detect this and roll the functionality into a + // single wrapper, but the current solution is good enough for now. + AutoJSContext cx; + XPCWrappedNativeScope* xpcscope = ObjectScope(JS::CurrentGlobalOrNull(cx)); + if (!xpcscope) + return false; + + // First, see if this object supports the wrapper cache. + // Note: If |cache->IsDOMBinding()| is true, then it means that the object + // implementing it doesn't want a wrapped native as its JS Object, but + // instead it provides its own proxy object. In that case, the object + // to use is found as cache->GetWrapper(). If that is null, then the + // object will create (and fill the cache) from its WrapObject call. + nsWrapperCache* cache = aHelper.GetWrapperCache(); + + RootedObject flat(cx, cache ? cache->GetWrapper() : nullptr); + if (!flat && cache && cache->IsDOMBinding()) { + RootedObject global(cx, xpcscope->GetGlobalJSObject()); + js::AssertSameCompartment(cx, global); + flat = cache->WrapObject(cx, nullptr); + if (!flat) + return false; + } + if (flat) { + if (allowNativeWrapper && !JS_WrapObject(cx, &flat)) + return false; + return CreateHolderIfNeeded(flat, d, dest); + } + +#ifdef SPIDERMONKEY_PROMISE + if (iid->Equals(NS_GET_IID(nsISupports))) { + // Check for a Promise being returned via nsISupports. In that + // situation, we want to dig out its underlying JS object and return + // that. + RefPtr<Promise> promise = do_QueryObject(aHelper.Object()); + if (promise) { + flat = promise->PromiseObj(); + if (!JS_WrapObject(cx, &flat)) + return false; + return CreateHolderIfNeeded(flat, d, dest); + } + } +#endif // SPIDERMONKEY_PROMISE + + // Don't double wrap CPOWs. This is a temporary measure for compatibility + // with objects that don't provide necessary QIs (such as objects under + // the new DOM bindings). We expect the other side of the CPOW to have + // the appropriate wrappers in place. + RootedObject cpow(cx, UnwrapNativeCPOW(aHelper.Object())); + if (cpow) { + if (!JS_WrapObject(cx, &cpow)) + return false; + d.setObject(*cpow); + return true; + } + + // Go ahead and create an XPCWrappedNative for this object. + RefPtr<XPCNativeInterface> iface = + XPCNativeInterface::GetNewOrUsed(iid); + if (!iface) + return false; + + RefPtr<XPCWrappedNative> wrapper; + nsresult rv = XPCWrappedNative::GetNewOrUsed(aHelper, xpcscope, iface, + getter_AddRefs(wrapper)); + if (NS_FAILED(rv) && pErr) + *pErr = rv; + + // If creating the wrapped native failed, then return early. + if (NS_FAILED(rv) || !wrapper) + return false; + + // If we're not creating security wrappers, we can return the + // XPCWrappedNative as-is here. + flat = wrapper->GetFlatJSObject(); + if (!allowNativeWrapper) { + d.setObjectOrNull(flat); + if (dest) + wrapper.forget(dest); + if (pErr) + *pErr = NS_OK; + return true; + } + + // The call to wrap here handles both cross-compartment and same-compartment + // security wrappers. + RootedObject original(cx, flat); + if (!JS_WrapObject(cx, &flat)) + return false; + + d.setObjectOrNull(flat); + + if (dest) { + // The wrapper still holds the original flat object. + if (flat == original) { + wrapper.forget(dest); + } else { + if (!flat) + return false; + RefPtr<XPCJSObjectHolder> objHolder = new XPCJSObjectHolder(flat); + objHolder.forget(dest); + } + } + + if (pErr) + *pErr = NS_OK; + + return true; +} + +/***************************************************************************/ + +// static +bool +XPCConvert::JSObject2NativeInterface(void** dest, HandleObject src, + const nsID* iid, + nsISupports* aOuter, + nsresult* pErr) +{ + MOZ_ASSERT(dest, "bad param"); + MOZ_ASSERT(src, "bad param"); + MOZ_ASSERT(iid, "bad param"); + + AutoJSContext cx; + JSAutoCompartment ac(cx, src); + + *dest = nullptr; + if (pErr) + *pErr = NS_ERROR_XPC_BAD_CONVERT_JS; + + nsISupports* iface; + + if (!aOuter) { + // Note that if we have a non-null aOuter then it means that we are + // forcing the creation of a wrapper even if the object *is* a + // wrappedNative or other wise has 'nsISupportness'. + // This allows wrapJSAggregatedToNative to work. + + // If we're looking at a security wrapper, see now if we're allowed to + // pass it to C++. If we are, then fall through to the code below. If + // we aren't, throw an exception eagerly. + // + // NB: It's very important that we _don't_ unwrap in the aOuter case, + // because the caller may explicitly want to create the XPCWrappedJS + // around a security wrapper. XBL does this with Xrays from the XBL + // scope - see nsBindingManager::GetBindingImplementation. + // + // It's also very important that "inner" be rooted here. + RootedObject inner(cx, + js::CheckedUnwrap(src, + /* stopAtWindowProxy = */ false)); + if (!inner) { + if (pErr) + *pErr = NS_ERROR_XPC_SECURITY_MANAGER_VETO; + return false; + } + + // Is this really a native xpcom object with a wrapper? + XPCWrappedNative* wrappedNative = nullptr; + if (IS_WN_REFLECTOR(inner)) + wrappedNative = XPCWrappedNative::Get(inner); + if (wrappedNative) { + iface = wrappedNative->GetIdentityObject(); + return NS_SUCCEEDED(iface->QueryInterface(*iid, dest)); + } + // else... + + // Deal with slim wrappers here. + if (GetISupportsFromJSObject(inner ? inner : src, &iface)) { + if (iface && NS_SUCCEEDED(iface->QueryInterface(*iid, dest))) { + return true; + } + + // If that failed, and iid is for mozIDOMWindowProxy, we actually + // want the outer! + if (iid->Equals(NS_GET_IID(mozIDOMWindowProxy))) { + if (nsCOMPtr<mozIDOMWindow> inner = do_QueryInterface(iface)) { + iface = nsPIDOMWindowInner::From(inner)->GetOuterWindow(); + return NS_SUCCEEDED(iface->QueryInterface(*iid, dest)); + } + } + + return false; + } + +#ifdef SPIDERMONKEY_PROMISE + // Deal with Promises being passed as nsISupports. In that situation we + // want to create a dom::Promise and use that. + if (iid->Equals(NS_GET_IID(nsISupports))) { + RootedObject innerObj(cx, inner); + if (IsPromiseObject(innerObj)) { + nsIGlobalObject* glob = NativeGlobal(innerObj); + RefPtr<Promise> p = Promise::CreateFromExisting(glob, innerObj); + return p && NS_SUCCEEDED(p->QueryInterface(*iid, dest)); + } + } +#endif // SPIDERMONKEY_PROMISE + } + + RefPtr<nsXPCWrappedJS> wrapper; + nsresult rv = nsXPCWrappedJS::GetNewOrUsed(src, *iid, getter_AddRefs(wrapper)); + if (pErr) + *pErr = rv; + + if (NS_FAILED(rv) || !wrapper) + return false; + + // If the caller wanted to aggregate this JS object to a native, + // attach it to the wrapper. Note that we allow a maximum of one + // aggregated native for a given XPCWrappedJS. + if (aOuter) + wrapper->SetAggregatedNativeObject(aOuter); + + // We need to go through the QueryInterface logic to make this return + // the right thing for the various 'special' interfaces; e.g. + // nsIPropertyBag. We must use AggregatedQueryInterface in cases where + // there is an outer to avoid nasty recursion. + rv = aOuter ? wrapper->AggregatedQueryInterface(*iid, dest) : + wrapper->QueryInterface(*iid, dest); + if (pErr) + *pErr = rv; + return NS_SUCCEEDED(rv); +} + +/***************************************************************************/ +/***************************************************************************/ + +// static +nsresult +XPCConvert::ConstructException(nsresult rv, const char* message, + const char* ifaceName, const char* methodName, + nsISupports* data, + nsIException** exceptn, + JSContext* cx, + Value* jsExceptionPtr) +{ + MOZ_ASSERT(!cx == !jsExceptionPtr, "Expected cx and jsExceptionPtr to cooccur."); + + static const char format[] = "\'%s\' when calling method: [%s::%s]"; + const char * msg = message; + nsXPIDLString xmsg; + nsAutoCString sxmsg; + + nsCOMPtr<nsIScriptError> errorObject = do_QueryInterface(data); + if (errorObject) { + if (NS_SUCCEEDED(errorObject->GetMessageMoz(getter_Copies(xmsg)))) { + CopyUTF16toUTF8(xmsg, sxmsg); + msg = sxmsg.get(); + } + } + if (!msg) + if (!nsXPCException::NameAndFormatForNSResult(rv, nullptr, &msg) || ! msg) + msg = "<error>"; + + nsCString msgStr(msg); + if (ifaceName && methodName) + msgStr.AppendPrintf(format, msg, ifaceName, methodName); + + RefPtr<Exception> e = new Exception(msgStr, rv, EmptyCString(), nullptr, data); + + if (cx && jsExceptionPtr) { + e->StowJSVal(*jsExceptionPtr); + } + + e.forget(exceptn); + return NS_OK; +} + +/********************************/ + +class MOZ_STACK_CLASS AutoExceptionRestorer +{ +public: + AutoExceptionRestorer(JSContext* cx, const Value& v) + : mContext(cx), tvr(cx, v) + { + JS_ClearPendingException(mContext); + } + + ~AutoExceptionRestorer() + { + JS_SetPendingException(mContext, tvr); + } + +private: + JSContext * const mContext; + RootedValue tvr; +}; + +static nsresult +JSErrorToXPCException(const char* toStringResult, + const char* ifaceName, + const char* methodName, + const JSErrorReport* report, + nsIException** exceptn) +{ + AutoJSContext cx; + nsresult rv = NS_ERROR_FAILURE; + RefPtr<nsScriptError> data; + if (report) { + nsAutoString bestMessage; + if (report && report->message()) { + CopyUTF8toUTF16(report->message().c_str(), bestMessage); + } else if (toStringResult) { + CopyUTF8toUTF16(toStringResult, bestMessage); + } else { + bestMessage.AssignLiteral("JavaScript Error"); + } + + const char16_t* linebuf = report->linebuf(); + + data = new nsScriptError(); + data->InitWithWindowID( + bestMessage, + NS_ConvertASCIItoUTF16(report->filename), + linebuf ? nsDependentString(linebuf, report->linebufLength()) : EmptyString(), + report->lineno, + report->tokenOffset(), report->flags, + NS_LITERAL_CSTRING("XPConnect JavaScript"), + nsJSUtils::GetCurrentlyRunningCodeInnerWindowID(cx)); + } + + if (data) { + nsAutoCString formattedMsg; + data->ToString(formattedMsg); + + rv = XPCConvert::ConstructException(NS_ERROR_XPC_JAVASCRIPT_ERROR_WITH_DETAILS, + formattedMsg.get(), ifaceName, + methodName, + static_cast<nsIScriptError*>(data.get()), + exceptn, nullptr, nullptr); + } else { + rv = XPCConvert::ConstructException(NS_ERROR_XPC_JAVASCRIPT_ERROR, + nullptr, ifaceName, methodName, + nullptr, exceptn, nullptr, nullptr); + } + return rv; +} + +// static +nsresult +XPCConvert::JSValToXPCException(MutableHandleValue s, + const char* ifaceName, + const char* methodName, + nsIException** exceptn) +{ + AutoJSContext cx; + AutoExceptionRestorer aer(cx, s); + + if (!s.isPrimitive()) { + // we have a JSObject + RootedObject obj(cx, s.toObjectOrNull()); + + if (!obj) { + NS_ERROR("when is an object not an object?"); + return NS_ERROR_FAILURE; + } + + // is this really a native xpcom object with a wrapper? + JSObject* unwrapped = js::CheckedUnwrap(obj, /* stopAtWindowProxy = */ false); + if (!unwrapped) + return NS_ERROR_XPC_SECURITY_MANAGER_VETO; + if (nsCOMPtr<nsISupports> supports = UnwrapReflectorToISupports(unwrapped)) { + nsCOMPtr<nsIException> iface = do_QueryInterface(supports); + if (iface) { + // just pass through the exception (with extra ref and all) + nsCOMPtr<nsIException> temp = iface; + temp.forget(exceptn); + return NS_OK; + } else { + // it is a wrapped native, but not an exception! + return ConstructException(NS_ERROR_XPC_JS_THREW_NATIVE_OBJECT, + nullptr, ifaceName, methodName, supports, + exceptn, nullptr, nullptr); + } + } else { + // It is a JSObject, but not a wrapped native... + + // If it is an engine Error with an error report then let's + // extract the report and build an xpcexception from that + const JSErrorReport* report; + if (nullptr != (report = JS_ErrorFromException(cx, obj))) { + JSAutoByteString toStringResult; + RootedString str(cx, ToString(cx, s)); + if (str) + toStringResult.encodeUtf8(cx, str); + return JSErrorToXPCException(toStringResult.ptr(), ifaceName, + methodName, report, exceptn); + } + + // XXX we should do a check against 'js_ErrorClass' here and + // do the right thing - even though it has no JSErrorReport, + // The fact that it is a JSError exceptions means we can extract + // particular info and our 'result' should reflect that. + + // otherwise we'll just try to convert it to a string + + JSString* str = ToString(cx, s); + if (!str) + return NS_ERROR_FAILURE; + + JSAutoByteString strBytes(cx, str); + if (!strBytes) + return NS_ERROR_FAILURE; + + return ConstructException(NS_ERROR_XPC_JS_THREW_JS_OBJECT, + strBytes.ptr(), ifaceName, methodName, + nullptr, exceptn, cx, s.address()); + } + } + + if (s.isUndefined() || s.isNull()) { + return ConstructException(NS_ERROR_XPC_JS_THREW_NULL, + nullptr, ifaceName, methodName, nullptr, + exceptn, cx, s.address()); + } + + if (s.isNumber()) { + // lets see if it looks like an nsresult + nsresult rv; + double number; + bool isResult = false; + + if (s.isInt32()) { + rv = (nsresult) s.toInt32(); + if (NS_FAILED(rv)) + isResult = true; + else + number = (double) s.toInt32(); + } else { + number = s.toDouble(); + if (number > 0.0 && + number < (double)0xffffffff && + 0.0 == fmod(number,1)) { + // Visual Studio 9 doesn't allow casting directly from a + // double to an enumeration type, contrary to 5.2.9(10) of + // C++11, so add an intermediate cast. + rv = (nsresult)(uint32_t) number; + if (NS_FAILED(rv)) + isResult = true; + } + } + + if (isResult) + return ConstructException(rv, nullptr, ifaceName, methodName, + nullptr, exceptn, cx, s.address()); + else { + // XXX all this nsISupportsDouble code seems a little redundant + // now that we're storing the Value in the exception... + nsCOMPtr<nsISupportsDouble> data; + nsCOMPtr<nsIComponentManager> cm; + if (NS_FAILED(NS_GetComponentManager(getter_AddRefs(cm))) || !cm || + NS_FAILED(cm->CreateInstanceByContractID(NS_SUPPORTS_DOUBLE_CONTRACTID, + nullptr, + NS_GET_IID(nsISupportsDouble), + getter_AddRefs(data)))) + return NS_ERROR_FAILURE; + data->SetData(number); + rv = ConstructException(NS_ERROR_XPC_JS_THREW_NUMBER, nullptr, + ifaceName, methodName, data, exceptn, cx, s.address()); + return rv; + } + } + + // otherwise we'll just try to convert it to a string + // Note: e.g., bools get converted to JSStrings by this code. + + JSString* str = ToString(cx, s); + if (str) { + JSAutoByteString strBytes(cx, str); + if (!!strBytes) { + return ConstructException(NS_ERROR_XPC_JS_THREW_STRING, + strBytes.ptr(), ifaceName, methodName, + nullptr, exceptn, cx, s.address()); + } + } + return NS_ERROR_FAILURE; +} + +/***************************************************************************/ + +// array fun... + +#ifdef POPULATE +#undef POPULATE +#endif + +// static +bool +XPCConvert::NativeArray2JS(MutableHandleValue d, const void** s, + const nsXPTType& type, const nsID* iid, + uint32_t count, nsresult* pErr) +{ + NS_PRECONDITION(s, "bad param"); + + AutoJSContext cx; + + // XXX add support for putting chars in a string rather than an array + + // XXX add support to indicate *which* array element was not convertable + + RootedObject array(cx, JS_NewArrayObject(cx, count)); + if (!array) + return false; + + if (pErr) + *pErr = NS_ERROR_XPC_BAD_CONVERT_NATIVE; + + uint32_t i; + RootedValue current(cx, JS::NullValue()); + +#define POPULATE(_t) \ + PR_BEGIN_MACRO \ + for (i = 0; i < count; i++) { \ + if (!NativeData2JS(¤t, ((_t*)*s)+i, type, iid, pErr) || \ + !JS_DefineElement(cx, array, i, current, JSPROP_ENUMERATE)) \ + return false; \ + } \ + PR_END_MACRO + + // XXX check IsPtr - esp. to handle array of nsID (as opposed to nsID*) + + switch (type.TagPart()) { + case nsXPTType::T_I8 : POPULATE(int8_t); break; + case nsXPTType::T_I16 : POPULATE(int16_t); break; + case nsXPTType::T_I32 : POPULATE(int32_t); break; + case nsXPTType::T_I64 : POPULATE(int64_t); break; + case nsXPTType::T_U8 : POPULATE(uint8_t); break; + case nsXPTType::T_U16 : POPULATE(uint16_t); break; + case nsXPTType::T_U32 : POPULATE(uint32_t); break; + case nsXPTType::T_U64 : POPULATE(uint64_t); break; + case nsXPTType::T_FLOAT : POPULATE(float); break; + case nsXPTType::T_DOUBLE : POPULATE(double); break; + case nsXPTType::T_BOOL : POPULATE(bool); break; + case nsXPTType::T_CHAR : POPULATE(char); break; + case nsXPTType::T_WCHAR : POPULATE(char16_t); break; + case nsXPTType::T_VOID : NS_ERROR("bad type"); return false; + case nsXPTType::T_IID : POPULATE(nsID*); break; + case nsXPTType::T_DOMSTRING : NS_ERROR("bad type"); return false; + case nsXPTType::T_CHAR_STR : POPULATE(char*); break; + case nsXPTType::T_WCHAR_STR : POPULATE(char16_t*); break; + case nsXPTType::T_INTERFACE : POPULATE(nsISupports*); break; + case nsXPTType::T_INTERFACE_IS : POPULATE(nsISupports*); break; + case nsXPTType::T_UTF8STRING : NS_ERROR("bad type"); return false; + case nsXPTType::T_CSTRING : NS_ERROR("bad type"); return false; + case nsXPTType::T_ASTRING : NS_ERROR("bad type"); return false; + default : NS_ERROR("bad type"); return false; + } + + if (pErr) + *pErr = NS_OK; + d.setObject(*array); + return true; + +#undef POPULATE +} + + + +// Check that the tag part of the type matches the type +// of the array. If the check succeeds, check that the size +// of the output does not exceed UINT32_MAX bytes. Allocate +// the memory and copy the elements by memcpy. +static bool +CheckTargetAndPopulate(const nsXPTType& type, + uint8_t requiredType, + size_t typeSize, + uint32_t count, + JSObject* tArr, + void** output, + nsresult* pErr) +{ + // Check that the element type expected by the interface matches + // the type of the elements in the typed array exactly, including + // signedness. + if (type.TagPart() != requiredType) { + if (pErr) + *pErr = NS_ERROR_XPC_BAD_CONVERT_JS; + + return false; + } + + // Calulate the maximum number of elements that can fit in + // UINT32_MAX bytes. + size_t max = UINT32_MAX / typeSize; + + // This could overflow on 32-bit systems so check max first. + size_t byteSize = count * typeSize; + if (count > max || !(*output = moz_xmalloc(byteSize))) { + if (pErr) + *pErr = NS_ERROR_OUT_OF_MEMORY; + + return false; + } + + JS::AutoCheckCannotGC nogc; + bool isShared; + void* buf = JS_GetArrayBufferViewData(tArr, &isShared, nogc); + + // Require opting in to shared memory - a future project. + if (isShared) { + if (pErr) + *pErr = NS_ERROR_XPC_BAD_CONVERT_JS; + + return false; + } + + memcpy(*output, buf, byteSize); + return true; +} + +// Fast conversion of typed arrays to native using memcpy. +// No float or double canonicalization is done. Called by +// JSarray2Native whenever a TypedArray is met. ArrayBuffers +// are not accepted; create a properly typed array view on them +// first. The element type of array must match the XPCOM +// type in size, type and signedness exactly. As an exception, +// Uint8ClampedArray is allowed for arrays of uint8_t. DataViews +// are not supported. + +// static +bool +XPCConvert::JSTypedArray2Native(void** d, + JSObject* jsArray, + uint32_t count, + const nsXPTType& type, + nsresult* pErr) +{ + MOZ_ASSERT(jsArray, "bad param"); + MOZ_ASSERT(d, "bad param"); + MOZ_ASSERT(JS_IsTypedArrayObject(jsArray), "not a typed array"); + + // Check the actual length of the input array against the + // given size_is. + uint32_t len = JS_GetTypedArrayLength(jsArray); + if (len < count) { + if (pErr) + *pErr = NS_ERROR_XPC_NOT_ENOUGH_ELEMENTS_IN_ARRAY; + + return false; + } + + void* output = nullptr; + + switch (JS_GetArrayBufferViewType(jsArray)) { + case js::Scalar::Int8: + if (!CheckTargetAndPopulate(nsXPTType::T_I8, type, + sizeof(int8_t), count, + jsArray, &output, pErr)) { + return false; + } + break; + + case js::Scalar::Uint8: + case js::Scalar::Uint8Clamped: + if (!CheckTargetAndPopulate(nsXPTType::T_U8, type, + sizeof(uint8_t), count, + jsArray, &output, pErr)) { + return false; + } + break; + + case js::Scalar::Int16: + if (!CheckTargetAndPopulate(nsXPTType::T_I16, type, + sizeof(int16_t), count, + jsArray, &output, pErr)) { + return false; + } + break; + + case js::Scalar::Uint16: + if (!CheckTargetAndPopulate(nsXPTType::T_U16, type, + sizeof(uint16_t), count, + jsArray, &output, pErr)) { + return false; + } + break; + + case js::Scalar::Int32: + if (!CheckTargetAndPopulate(nsXPTType::T_I32, type, + sizeof(int32_t), count, + jsArray, &output, pErr)) { + return false; + } + break; + + case js::Scalar::Uint32: + if (!CheckTargetAndPopulate(nsXPTType::T_U32, type, + sizeof(uint32_t), count, + jsArray, &output, pErr)) { + return false; + } + break; + + case js::Scalar::Float32: + if (!CheckTargetAndPopulate(nsXPTType::T_FLOAT, type, + sizeof(float), count, + jsArray, &output, pErr)) { + return false; + } + break; + + case js::Scalar::Float64: + if (!CheckTargetAndPopulate(nsXPTType::T_DOUBLE, type, + sizeof(double), count, + jsArray, &output, pErr)) { + return false; + } + break; + + // Yet another array type was defined? It is not supported yet... + default: + if (pErr) + *pErr = NS_ERROR_XPC_BAD_CONVERT_JS; + + return false; + } + + *d = output; + if (pErr) + *pErr = NS_OK; + + return true; +} + +// static +bool +XPCConvert::JSArray2Native(void** d, HandleValue s, + uint32_t count, const nsXPTType& type, + const nsID* iid, nsresult* pErr) +{ + MOZ_ASSERT(d, "bad param"); + + AutoJSContext cx; + + // XXX add support for getting chars from strings + + // XXX add support to indicate *which* array element was not convertable + + if (s.isNullOrUndefined()) { + if (0 != count) { + if (pErr) + *pErr = NS_ERROR_XPC_NOT_ENOUGH_ELEMENTS_IN_ARRAY; + return false; + } + + *d = nullptr; + return true; + } + + if (!s.isObject()) { + if (pErr) + *pErr = NS_ERROR_XPC_CANT_CONVERT_PRIMITIVE_TO_ARRAY; + return false; + } + + RootedObject jsarray(cx, &s.toObject()); + + // If this is a typed array, then try a fast conversion with memcpy. + if (JS_IsTypedArrayObject(jsarray)) { + return JSTypedArray2Native(d, jsarray, count, type, pErr); + } + + bool isArray; + if (!JS_IsArrayObject(cx, jsarray, &isArray) || !isArray) { + if (pErr) + *pErr = NS_ERROR_XPC_CANT_CONVERT_OBJECT_TO_ARRAY; + return false; + } + + uint32_t len; + if (!JS_GetArrayLength(cx, jsarray, &len) || len < count) { + if (pErr) + *pErr = NS_ERROR_XPC_NOT_ENOUGH_ELEMENTS_IN_ARRAY; + return false; + } + + if (pErr) + *pErr = NS_ERROR_XPC_BAD_CONVERT_JS; + +#define POPULATE(_mode, _t) \ + PR_BEGIN_MACRO \ + cleanupMode = _mode; \ + size_t max = UINT32_MAX / sizeof(_t); \ + if (count > max || \ + nullptr == (array = moz_xmalloc(count * sizeof(_t)))) { \ + if (pErr) \ + *pErr = NS_ERROR_OUT_OF_MEMORY; \ + goto failure; \ + } \ + for (initedCount = 0; initedCount < count; initedCount++) { \ + if (!JS_GetElement(cx, jsarray, initedCount, ¤t) || \ + !JSData2Native(((_t*)array)+initedCount, current, type, \ + iid, pErr)) \ + goto failure; \ + } \ + PR_END_MACRO + + // No Action, FRee memory, RElease object + enum CleanupMode {na, fr, re}; + + CleanupMode cleanupMode; + + void* array = nullptr; + uint32_t initedCount; + RootedValue current(cx); + + // XXX check IsPtr - esp. to handle array of nsID (as opposed to nsID*) + // XXX make extra space at end of char* and wchar* and null termintate + + switch (type.TagPart()) { + case nsXPTType::T_I8 : POPULATE(na, int8_t); break; + case nsXPTType::T_I16 : POPULATE(na, int16_t); break; + case nsXPTType::T_I32 : POPULATE(na, int32_t); break; + case nsXPTType::T_I64 : POPULATE(na, int64_t); break; + case nsXPTType::T_U8 : POPULATE(na, uint8_t); break; + case nsXPTType::T_U16 : POPULATE(na, uint16_t); break; + case nsXPTType::T_U32 : POPULATE(na, uint32_t); break; + case nsXPTType::T_U64 : POPULATE(na, uint64_t); break; + case nsXPTType::T_FLOAT : POPULATE(na, float); break; + case nsXPTType::T_DOUBLE : POPULATE(na, double); break; + case nsXPTType::T_BOOL : POPULATE(na, bool); break; + case nsXPTType::T_CHAR : POPULATE(na, char); break; + case nsXPTType::T_WCHAR : POPULATE(na, char16_t); break; + case nsXPTType::T_VOID : NS_ERROR("bad type"); goto failure; + case nsXPTType::T_IID : POPULATE(fr, nsID*); break; + case nsXPTType::T_DOMSTRING : NS_ERROR("bad type"); goto failure; + case nsXPTType::T_CHAR_STR : POPULATE(fr, char*); break; + case nsXPTType::T_WCHAR_STR : POPULATE(fr, char16_t*); break; + case nsXPTType::T_INTERFACE : POPULATE(re, nsISupports*); break; + case nsXPTType::T_INTERFACE_IS : POPULATE(re, nsISupports*); break; + case nsXPTType::T_UTF8STRING : NS_ERROR("bad type"); goto failure; + case nsXPTType::T_CSTRING : NS_ERROR("bad type"); goto failure; + case nsXPTType::T_ASTRING : NS_ERROR("bad type"); goto failure; + default : NS_ERROR("bad type"); goto failure; + } + + *d = array; + if (pErr) + *pErr = NS_OK; + return true; + +failure: + // we may need to cleanup the partially filled array of converted stuff + if (array) { + if (cleanupMode == re) { + nsISupports** a = (nsISupports**) array; + for (uint32_t i = 0; i < initedCount; i++) { + nsISupports* p = a[i]; + NS_IF_RELEASE(p); + } + } else if (cleanupMode == fr) { + void** a = (void**) array; + for (uint32_t i = 0; i < initedCount; i++) { + void* p = a[i]; + if (p) free(p); + } + } + free(array); + } + + return false; + +#undef POPULATE +} + +// static +bool +XPCConvert::NativeStringWithSize2JS(MutableHandleValue d, const void* s, + const nsXPTType& type, + uint32_t count, + nsresult* pErr) +{ + NS_PRECONDITION(s, "bad param"); + + AutoJSContext cx; + if (pErr) + *pErr = NS_ERROR_XPC_BAD_CONVERT_NATIVE; + + switch (type.TagPart()) { + case nsXPTType::T_PSTRING_SIZE_IS: + { + char* p = *((char**)s); + if (!p) + break; + JSString* str; + if (!(str = JS_NewStringCopyN(cx, p, count))) + return false; + d.setString(str); + break; + } + case nsXPTType::T_PWSTRING_SIZE_IS: + { + char16_t* p = *((char16_t**)s); + if (!p) + break; + JSString* str; + if (!(str = JS_NewUCStringCopyN(cx, p, count))) + return false; + d.setString(str); + break; + } + default: + XPC_LOG_ERROR(("XPCConvert::NativeStringWithSize2JS : unsupported type")); + return false; + } + return true; +} + +// static +bool +XPCConvert::JSStringWithSize2Native(void* d, HandleValue s, + uint32_t count, const nsXPTType& type, + nsresult* pErr) +{ + NS_PRECONDITION(!s.isNull(), "bad param"); + NS_PRECONDITION(d, "bad param"); + + AutoJSContext cx; + uint32_t len; + + if (pErr) + *pErr = NS_ERROR_XPC_BAD_CONVERT_NATIVE; + + switch (type.TagPart()) { + case nsXPTType::T_PSTRING_SIZE_IS: + { + if (s.isUndefined() || s.isNull()) { + if (0 != count) { + if (pErr) + *pErr = NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING; + return false; + } + if (0 != count) { + len = (count + 1) * sizeof(char); + if (!(*((void**)d) = moz_xmalloc(len))) + return false; + return true; + } + // else ... + + *((char**)d) = nullptr; + return true; + } + + JSString* str = ToString(cx, s); + if (!str) { + return false; + } + + size_t length = JS_GetStringEncodingLength(cx, str); + if (length == size_t(-1)) { + return false; + } + if (length > count) { + if (pErr) + *pErr = NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING; + return false; + } + len = uint32_t(length); + + if (len < count) + len = count; + + uint32_t alloc_len = (len + 1) * sizeof(char); + char* buffer = static_cast<char*>(moz_xmalloc(alloc_len)); + if (!buffer) { + return false; + } + JS_EncodeStringToBuffer(cx, str, buffer, len); + buffer[len] = '\0'; + *((char**)d) = buffer; + + return true; + } + + case nsXPTType::T_PWSTRING_SIZE_IS: + { + JSString* str; + + if (s.isUndefined() || s.isNull()) { + if (0 != count) { + if (pErr) + *pErr = NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING; + return false; + } + + if (0 != count) { + len = (count + 1) * sizeof(char16_t); + if (!(*((void**)d) = moz_xmalloc(len))) + return false; + return true; + } + + // else ... + *((const char16_t**)d) = nullptr; + return true; + } + + if (!(str = ToString(cx, s))) { + return false; + } + + len = JS_GetStringLength(str); + if (len > count) { + if (pErr) + *pErr = NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING; + return false; + } + + len = count; + + uint32_t alloc_len = (len + 1) * sizeof(char16_t); + if (!(*((void**)d) = moz_xmalloc(alloc_len))) { + // XXX should report error + return false; + } + mozilla::Range<char16_t> destChars(*((char16_t**)d), len + 1); + if (!JS_CopyStringChars(cx, destChars, str)) + return false; + destChars[count] = 0; + + return true; + } + default: + XPC_LOG_ERROR(("XPCConvert::JSStringWithSize2Native : unsupported type")); + return false; + } +} |