summaryrefslogtreecommitdiffstats
path: root/js/xpconnect/src/XPCConvert.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'js/xpconnect/src/XPCConvert.cpp')
-rw-r--r--js/xpconnect/src/XPCConvert.cpp1799
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(&current, ((_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, &current) || \
+ !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;
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-08 18:29:42 +0000