The Tor Browser: js/xpconnect/src/XPCConvert.cpp@6474c204b198 (annotated)

js/xpconnect/src/XPCConvert.cpp@6474c204b198 (annotated)

js/xpconnect/src/XPCConvert.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- 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 "xpcprivate.h"
 #include "nsIAtom.h"
 #include "nsWrapperCache.h"
 #include "nsJSUtils.h"
 #include "WrapperFactory.h"
 #include "nsWrapperCacheInlines.h"
 #include "jsapi.h"
 #include "jsfriendapi.h"
 #include "jsprf.h"
 #include "JavaScriptParent.h"
 #include "mozilla/dom/BindingUtils.h"
 #include "mozilla/dom/DOMException.h"
 #include "mozilla/dom/PrimitiveConversions.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::JavaScriptParent::IsCPOW(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 :
     {
         jschar p = *static_cast<const jschar*>(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 jschar* p = *static_cast<const jschar* 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, nullptr, true, pErr);
     }
     default:
         NS_ERROR("bad type");
         return false;
     }
     return true;
 }
 /***************************************************************************/
 #ifdef DEBUG
 static bool
 CheckJSCharInCharRange(jschar 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];
         JS_snprintf(msg, MSG_BUF_SIZE, "jschar out of char range; high bits of data lost: 0x%x", c);
         NS_WARNING(msg);
         return false;
     }
     return true;
 }
 #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,
                           bool useAllocator, 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;
         }
         size_t length;
         const jschar* chars = JS_GetStringCharsAndLength(cx, str, &length);
         if (!chars) {
             return false;
         }
         jschar ch = length ? chars[0] : 0;
 #ifdef DEBUG
         CheckJSCharInCharRange(ch);
 #endif
         *((char*)d) = char(ch);
         break;
     }
     case nsXPTType::T_WCHAR  :
     {
         JSString* str;
         if (!(str = ToString(cx, s))) {
             return false;
         }
         size_t length;
         const jschar* chars = JS_GetStringCharsAndLength(cx, str, &length);
         if (!chars) {
             return false;
         }
         if (length == 0) {
             *((uint16_t*)d) = 0;
             break;
         }
         *((uint16_t*)d) = uint16_t(chars[0]);
         break;
     }
     case nsXPTType::T_JSVAL :
         *((jsval*)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 (JSVAL_IS_VOID(s)) {
             if (useAllocator)
                 *((const nsAString**)d) = &NullString();
             else
                 (**((nsAString**)d)).SetIsVoid(true);
             return true;
         }
         // Fall through to T_DOMSTRING case.
     }
     case nsXPTType::T_DOMSTRING:
     {
         if (JSVAL_IS_NULL(s)) {
             if (useAllocator)
                 *((const nsAString**)d) = &NullString();
             else
                 (**((nsAString**)d)).SetIsVoid(true);
             return true;
         }
         size_t length = 0;
         const char16_t* chars = nullptr;
         JSString* str = nullptr;
         if (!JSVAL_IS_VOID(s)) {
             str = ToString(cx, s);
             if (!str)
                 return false;
             chars = useAllocator ? JS_GetStringCharsZAndLength(cx, str, &length)
                                  : JS_GetStringCharsAndLength(cx, str, &length);
             if (!chars)
                 return false;
             if (!length) {
                 if (useAllocator)
                     *((const nsAString**)d) = &EmptyString();
                 else
                     (**((nsAString**)d)).Truncate();
                 return true;
             }
         }
         nsString* ws;
         if (useAllocator) {
             ws = nsXPConnect::GetRuntimeInstance()->NewShortLivedString();
             *((const nsString**)d) = ws;
         } else {
             ws = *((nsString**)d);
         }
         if (!str) {
             ws->AssignLiteral(MOZ_UTF16("undefined"));
         } else if (XPCStringConvert::IsDOMString(str)) {
             // The characters represent an existing nsStringBuffer that
             // was shared by XPCStringConvert::ReadableToJSVal.
             nsStringBuffer::FromData((void *)chars)->ToString(length, *ws);
         } else if (XPCStringConvert::IsLiteral(str)) {
             // The characters represent a literal char16_t string constant
             // compiled into libxul, such as the string "undefined" above.
             ws->AssignLiteral(chars, length);
         } else if (useAllocator && STRING_TO_JSVAL(str) == s) {
             // The JS string will exist over the function call.
             // We don't need to copy the characters in this case.
             ws->Rebind(chars, length);
         } else {
             ws->Assign(chars, length);
         }
         return true;
     }
     case nsXPTType::T_CHAR_STR:
     {
         if (JSVAL_IS_VOID(s) || JSVAL_IS_NULL(s)) {
             *((char**)d) = nullptr;
             return true;
         }
         JSString* str = ToString(cx, s);
         if (!str) {
             return false;
         }
 #ifdef DEBUG
         const jschar* chars=nullptr;
         if (nullptr != (chars = JS_GetStringCharsZ(cx, str))) {
             bool legalRange = true;
             int len = JS_GetStringLength(str);
             const jschar* t;
             int32_t i=0;
             for (t=chars; (i< len) && legalRange ; i++,t++) {
                 if (!CheckJSCharInCharRange(*t))
                     break;
             }
         }
 #endif // DEBUG
         size_t length = JS_GetStringEncodingLength(cx, str);
         if (length == size_t(-1)) {
             return false;
         }
         char *buffer = static_cast<char *>(nsMemory::Alloc(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:
     {
         const jschar* chars=nullptr;
         JSString* str;
         if (JSVAL_IS_VOID(s) || JSVAL_IS_NULL(s)) {
             *((jschar**)d) = nullptr;
             return true;
         }
         if (!(str = ToString(cx, s))) {
             return false;
         }
         if (!(chars = JS_GetStringCharsZ(cx, str))) {
             return false;
         }
         int len = JS_GetStringLength(str);
         int byte_len = (len+1)*sizeof(jschar);
         if (!(*((void**)d) = nsMemory::Alloc(byte_len))) {
             // XXX should report error
             return false;
         }
         jschar* destchars = *((jschar**)d);
         memcpy(destchars, chars, byte_len);
         destchars[len] = 0;
         return true;
     }
     case nsXPTType::T_UTF8STRING:
     {
         const jschar* chars;
         size_t length;
         JSString* str;
         if (JSVAL_IS_NULL(s) || JSVAL_IS_VOID(s)) {
             if (useAllocator) {
                 *((const nsACString**)d) = &NullCString();
             } else {
                 nsCString* rs = *((nsCString**)d);
                 rs->SetIsVoid(true);
             }
             return true;
         }
         // The JS val is neither null nor void...
         if (!(str = ToString(cx, s))||
             !(chars = JS_GetStringCharsAndLength(cx, str, &length))) {
             return false;
         }
         if (!length) {
             if (useAllocator) {
                 *((const nsACString**)d) = &EmptyCString();
             } else {
                 nsCString* rs = *((nsCString**)d);
                 rs->Truncate();
             }
             return true;
         }
         nsCString *rs;
         if (useAllocator) {
             // Use nsCString to enable sharing
             rs = new nsCString();
             if (!rs)
                 return false;
             *((const nsCString**)d) = rs;
         } else {
             rs = *((nsCString**)d);
         }
         CopyUTF16toUTF8(Substring(chars, length), *rs);
         return true;
     }
     case nsXPTType::T_CSTRING:
     {
         if (JSVAL_IS_NULL(s) || JSVAL_IS_VOID(s)) {
             if (useAllocator) {
                 nsACString *rs = new nsCString();
                 if (!rs)
                     return false;
                 rs->SetIsVoid(true);
                 *((nsACString**)d) = rs;
             } else {
                 nsACString* rs = *((nsACString**)d);
                 rs->Truncate();
                 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) {
             if (useAllocator) {
                 *((const nsACString**)d) = &EmptyCString();
             } else {
                 nsCString* rs = *((nsCString**)d);
                 rs->Truncate();
             }
             return true;
         }
         nsACString *rs;
         if (useAllocator) {
             rs = new nsCString();
             if (!rs)
                 return false;
             *((const nsACString**)d) = rs;
         } else {
             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)) &&
                    JSVAL_IS_STRING(s)) {
             // We're trying to pass a string as an nsIAtom.  Let's atomize!
             JSString* str = JSVAL_TO_STRING(s);
             const char16_t* chars = JS_GetStringCharsZ(cx, str);
             if (!chars) {
                 if (pErr)
                     *pErr = NS_ERROR_XPC_BAD_CONVERT_JS_NULL_REF;
                 return false;
             }
             uint32_t length = JS_GetStringLength(str);
             nsCOMPtr<nsIAtom> atom =
                 NS_NewAtom(nsDependentSubstring(chars, chars + length));
             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) {
         nsRefPtr<XPCJSObjectHolder> objHolder = XPCJSObjectHolder::newHolder(obj);
         if (!objHolder)
             return false;
         objHolder.forget(dest);
     }
     d.setObjectOrNull(obj);
     return true;
 }
 /***************************************************************************/
 // static
 bool
 XPCConvert::NativeInterface2JSObject(MutableHandleValue d,
                                      nsIXPConnectJSObjectHolder** dest,
                                      xpcObjectHelper& aHelper,
                                      const nsID* iid,
                                      XPCNativeInterface** Interface,
                                      bool allowNativeWrapper,
                                      nsresult* pErr)
 {
     MOZ_ASSERT_IF(Interface, iid);
     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 = GetObjectScope(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);
         if (!flat)
             return false;
     }
     if (flat) {
         if (allowNativeWrapper && !JS_WrapObject(cx, &flat))
             return false;
         return CreateHolderIfNeeded(flat, d, dest);
     }
     // 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;
     }
     // We can't simply construct a slim wrapper. Go ahead and create an
     // XPCWrappedNative for this object. At this point, |flat| could be
     // non-null, meaning that either we already have a wrapped native from
     // the cache (which might need to be QI'd to the new interface) or that
     // we found a slim wrapper that we'll have to morph.
     AutoMarkingNativeInterfacePtr iface(cx);
     if (iid) {
         if (Interface)
             iface = *Interface;
         if (!iface) {
             iface = XPCNativeInterface::GetNewOrUsed(iid);
             if (!iface)
                 return false;
             if (Interface)
                 *Interface = iface;
         }
     }
     MOZ_ASSERT(!flat || IS_WN_REFLECTOR(flat), "What kind of wrapper is this?");
     nsresult rv;
     XPCWrappedNative* wrapper;
     nsRefPtr<XPCWrappedNative> strongWrapper;
     if (!flat) {
         rv = XPCWrappedNative::GetNewOrUsed(aHelper, xpcscope, iface,
                                             getter_AddRefs(strongWrapper));
         wrapper = strongWrapper;
     } else {
         MOZ_ASSERT(IS_WN_REFLECTOR(flat));
         wrapper = XPCWrappedNative::Get(flat);
         // If asked to return the wrapper we'll return a strong reference,
         // otherwise we'll just return its JSObject in d (which should be
         // rooted in that case).
         if (dest)
             strongWrapper = wrapper;
         if (iface)
             wrapper->FindTearOff(iface, false, &rv);
         else
             rv = NS_OK;
     }
     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();
     jsval v = OBJECT_TO_JSVAL(flat);
     if (!allowNativeWrapper) {
         d.set(v);
         if (dest)
             strongWrapper.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 strongWrapper still holds the original flat object.
         if (flat == original) {
             strongWrapper.forget(dest);
         } else {
             nsRefPtr<XPCJSObjectHolder> objHolder =
                 XPCJSObjectHolder::newHolder(flat);
             if (!objHolder)
                 return false;
             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.
         JSObject* inner = js::CheckedUnwrap(src, /* stopAtOuter = */ false);
         // Hack - For historical reasons, wrapped chrome JS objects have been
         // passable as native interfaces. We'd like to fix this, but it
         // involves fixing the contacts API and PeerConnection to stop using
         // COWs. This needs to happen, but for now just preserve the old
         // behavior.
         //
         // Note that there is an identical hack in getWrapper which should be
         // removed if this one is.
         if (!inner && MOZ_UNLIKELY(xpc::WrapperFactory::IsCOW(src)))
             inner = js::UncheckedUnwrap(src);
         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)
                 return NS_SUCCEEDED(iface->QueryInterface(*iid, dest));
             return false;
         }
     }
     // else...
     nsXPCWrappedJS* wrapper;
     nsresult rv = nsXPCWrappedJS::GetNewOrUsed(src, *iid, &wrapper);
     if (pErr)
         *pErr = rv;
     if (NS_SUCCEEDED(rv) && wrapper) {
         // 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;
         NS_RELEASE(wrapper);
         return NS_SUCCEEDED(rv);
     }
     // else...
     return false;
 }
 /***************************************************************************/
 /***************************************************************************/
 // static
 nsresult
 XPCConvert::ConstructException(nsresult rv, const char* message,
                                const char* ifaceName, const char* methodName,
                                nsISupports* data,
                                nsIException** exceptn,
                                JSContext* cx,
                                jsval* 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);
     nsRefPtr<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, Value v)
         : mContext(cx), tvr(cx, v)
     {
         JS_ClearPendingException(mContext);
     }
     ~AutoExceptionRestorer()
     {
         JS_SetPendingException(mContext, tvr);
     }
 private:
     JSContext * const mContext;
     RootedValue tvr;
 };
 // static
 nsresult
 XPCConvert::JSValToXPCException(MutableHandleValue s,
                                 const char* ifaceName,
                                 const char* methodName,
                                 nsIException** exceptn)
 {
     AutoJSContext cx;
     AutoExceptionRestorer aer(cx, s);
     if (!JSVAL_IS_PRIMITIVE(s)) {
         // we have a JSObject
         RootedObject obj(cx, JSVAL_TO_OBJECT(s));
         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, /* stopAtOuter = */ false);
         if (!unwrapped)
             return NS_ERROR_XPC_SECURITY_MANAGER_VETO;
         XPCWrappedNative* wrapper = IS_WN_REFLECTOR(unwrapped) ? XPCWrappedNative::Get(unwrapped)
                                                                : nullptr;
         if (wrapper) {
             nsISupports* supports = wrapper->GetIdentityObject();
             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 message;
                 JSString* str;
                 if (nullptr != (str = ToString(cx, s)))
                     message.encodeLatin1(cx, str);
                 return JSErrorToXPCException(message.ptr(), ifaceName,
                                              methodName, report, exceptn);
             }
             bool found;
             // heuristic to see if it might be usable as an xpcexception
             if (!JS_HasProperty(cx, obj, "message", &found))
                 return NS_ERROR_FAILURE;
             if (found && !JS_HasProperty(cx, obj, "result", &found))
                 return NS_ERROR_FAILURE;
             if (found) {
                 // lets try to build a wrapper around the JSObject
                 nsXPCWrappedJS* jswrapper;
                 nsresult rv =
                     nsXPCWrappedJS::GetNewOrUsed(obj, NS_GET_IID(nsIException), &jswrapper);
                 if (NS_FAILED(rv))
                     return rv;
                 *exceptn = static_cast<nsIException *>(jswrapper->GetXPTCStub());
                 return NS_OK;
             }
             // 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 (JSVAL_IS_VOID(s) || JSVAL_IS_NULL(s)) {
         return ConstructException(NS_ERROR_XPC_JS_THREW_NULL,
                                   nullptr, ifaceName, methodName, nullptr,
                                   exceptn, cx, s.address());
     }
     if (JSVAL_IS_NUMBER(s)) {
         // lets see if it looks like an nsresult
         nsresult rv;
         double number;
         bool isResult = false;
         if (JSVAL_IS_INT(s)) {
             rv = (nsresult) JSVAL_TO_INT(s);
             if (NS_FAILED(rv))
                 isResult = true;
             else
                 number = (double) JSVAL_TO_INT(s);
         } else {
             number = JSVAL_TO_DOUBLE(s);
             if (number > 0.0 &&
                 number < (double)0xffffffff &&
 .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 jsval in the exception...
             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),
                                                          (void**)&data)))
                 return NS_ERROR_FAILURE;
             data->SetData(number);
             rv = ConstructException(NS_ERROR_XPC_JS_THREW_NUMBER, nullptr,
                                     ifaceName, methodName, data, exceptn, cx, s.address());
             NS_RELEASE(data);
             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;
 }
 /********************************/
 // static
 nsresult
 XPCConvert::JSErrorToXPCException(const char* message,
                                   const char* ifaceName,
                                   const char* methodName,
                                   const JSErrorReport* report,
                                   nsIException** exceptn)
 {
     AutoJSContext cx;
     nsresult rv = NS_ERROR_FAILURE;
     nsRefPtr<nsScriptError> data;
     if (report) {
         nsAutoString bestMessage;
         if (report && report->ucmessage) {
             bestMessage = static_cast<const char16_t*>(report->ucmessage);
         } else if (message) {
             CopyASCIItoUTF16(message, bestMessage);
         } else {
             bestMessage.AssignLiteral("JavaScript Error");
         }
         const char16_t* uclinebuf =
             static_cast<const char16_t*>(report->uclinebuf);
         data = new nsScriptError();
         data->InitWithWindowID(
             bestMessage,
             NS_ConvertASCIItoUTF16(report->filename),
             uclinebuf ? nsDependentString(uclinebuf) : EmptyString(),
             report->lineno,
             report->uctokenptr - report->uclinebuf, report->flags,
             NS_LITERAL_CSTRING("XPConnect JavaScript"),
             nsJSUtils::GetCurrentlyRunningCodeInnerWindowID(cx));
     }
     if (data) {
         nsAutoCString formattedMsg;
         data->ToString(formattedMsg);
         rv = ConstructException(NS_ERROR_XPC_JAVASCRIPT_ERROR_WITH_DETAILS,
                                 formattedMsg.get(), ifaceName, methodName,
                                 static_cast<nsIScriptError*>(data.get()),
                                 exceptn, nullptr, nullptr);
     } else {
         rv = ConstructException(NS_ERROR_XPC_JAVASCRIPT_ERROR,
                                 nullptr, ifaceName, methodName, nullptr,
                                 exceptn, nullptr, nullptr);
     }
     return rv;
 }
 /***************************************************************************/
 // 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, JSVAL_NULL);
 #define POPULATE(_t)                                                                    \
     PR_BEGIN_MACRO                                                                      \
         for (i = 0; i < count; i++) {                                                   \
             if (!NativeData2JS(&current, ((_t*)*s)+i, type, iid, pErr) ||               \
                 !JS_SetElement(cx, array, i, current))                                  \
                 goto failure;                                                           \
         }                                                                               \
     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(jschar);         break;
     case nsXPTType::T_VOID          : NS_ERROR("bad type"); goto failure;
     case nsXPTType::T_IID           : POPULATE(nsID*);          break;
     case nsXPTType::T_DOMSTRING     : NS_ERROR("bad type"); goto failure;
     case nsXPTType::T_CHAR_STR      : POPULATE(char*);          break;
     case nsXPTType::T_WCHAR_STR     : POPULATE(jschar*);        break;
     case nsXPTType::T_INTERFACE     : POPULATE(nsISupports*);   break;
     case nsXPTType::T_INTERFACE_IS  : POPULATE(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;
     }
     if (pErr)
         *pErr = NS_OK;
     d.setObject(*array);
     return true;
 failure:
     return false;
 #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 = nsMemory::Alloc(byteSize))) {
         if (pErr)
             *pErr = NS_ERROR_OUT_OF_MEMORY;
         return false;
     }
     memcpy(*output, JS_GetArrayBufferViewData(tArr), 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::ArrayBufferView::TYPE_INT8:
         if (!CheckTargetAndPopulate(nsXPTType::T_I8, type,
                                     sizeof(int8_t), count,
                                     jsArray, &output, pErr)) {
             return false;
         }
         break;
     case js::ArrayBufferView::TYPE_UINT8:
     case js::ArrayBufferView::TYPE_UINT8_CLAMPED:
         if (!CheckTargetAndPopulate(nsXPTType::T_U8, type,
                                     sizeof(uint8_t), count,
                                     jsArray, &output, pErr)) {
             return false;
         }
         break;
     case js::ArrayBufferView::TYPE_INT16:
         if (!CheckTargetAndPopulate(nsXPTType::T_I16, type,
                                     sizeof(int16_t), count,
                                     jsArray, &output, pErr)) {
             return false;
         }
         break;
     case js::ArrayBufferView::TYPE_UINT16:
         if (!CheckTargetAndPopulate(nsXPTType::T_U16, type,
                                     sizeof(uint16_t), count,
                                     jsArray, &output, pErr)) {
             return false;
         }
         break;
     case js::ArrayBufferView::TYPE_INT32:
         if (!CheckTargetAndPopulate(nsXPTType::T_I32, type,
                                     sizeof(int32_t), count,
                                     jsArray, &output, pErr)) {
             return false;
         }
         break;
     case js::ArrayBufferView::TYPE_UINT32:
         if (!CheckTargetAndPopulate(nsXPTType::T_U32, type,
                                     sizeof(uint32_t), count,
                                     jsArray, &output, pErr)) {
             return false;
         }
         break;
     case js::ArrayBufferView::TYPE_FLOAT32:
         if (!CheckTargetAndPopulate(nsXPTType::T_FLOAT, type,
                                     sizeof(float), count,
                                     jsArray, &output, pErr)) {
             return false;
         }
         break;
     case js::ArrayBufferView::TYPE_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);
     }
     if (!JS_IsArrayObject(cx, jsarray)) {
         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 = nsMemory::Alloc(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,        \
                                true, 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, jschar);         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, jschar*);        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) nsMemory::Free(p);
             }
         }
         nsMemory::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:
         {
             jschar* p = *((jschar**)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(!JSVAL_IS_NULL(s), "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 (JSVAL_IS_VOID(s) || JSVAL_IS_NULL(s)) {
                 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) = nsMemory::Alloc(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 *>(nsMemory::Alloc(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:
         {
             const jschar* chars=nullptr;
             JSString* str;
             if (JSVAL_IS_VOID(s) || JSVAL_IS_NULL(s)) {
                 if (0 != count) {
                     if (pErr)
                         *pErr = NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING;
                     return false;
                 }
                 if (0 != count) {
                     len = (count + 1) * sizeof(jschar);
                     if (!(*((void**)d) = nsMemory::Alloc(len)))
                         return false;
                     return true;
                 }
                 // else ...
                 *((const jschar**)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;
             }
             if (len < count)
                 len = count;
             if (!(chars = JS_GetStringCharsZ(cx, str))) {
                 return false;
             }
             uint32_t alloc_len = (len + 1) * sizeof(jschar);
             if (!(*((void**)d) = nsMemory::Alloc(alloc_len))) {
                 // XXX should report error
                 return false;
             }
             memcpy(*((jschar**)d), chars, alloc_len);
             (*((jschar**)d))[count] = 0;
             return true;
         }
         default:
             XPC_LOG_ERROR(("XPCConvert::JSStringWithSize2Native : unsupported type"));
             return false;
     }
 }

The Tor Browser / annotate

js/xpconnect/src/XPCConvert.cpp@6474c204b198 (annotated)

js/xpconnect/src/XPCConvert.cpp