The Tor Browser: dom/bindings/BindingUtils.h@97036ab72558 (annotated)

dom/bindings/BindingUtils.h@97036ab72558 (annotated)

dom/bindings/BindingUtils.h

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-*/
 /* vim: set ts=2 sw=2 et tw=79: */
 /* 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/. */
 #ifndef mozilla_dom_BindingUtils_h__
 #define mozilla_dom_BindingUtils_h__
 #include "jsfriendapi.h"
 #include "jswrapper.h"
 #include "mozilla/ArrayUtils.h"
 #include "mozilla/Alignment.h"
 #include "mozilla/Array.h"
 #include "mozilla/dom/BindingDeclarations.h"
 #include "mozilla/dom/CallbackObject.h"
 #include "mozilla/dom/DOMJSClass.h"
 #include "mozilla/dom/DOMJSProxyHandler.h"
 #include "mozilla/dom/Exceptions.h"
 #include "mozilla/dom/NonRefcountedDOMObject.h"
 #include "mozilla/dom/Nullable.h"
 #include "mozilla/dom/RootedDictionary.h"
 #include "mozilla/dom/workers/Workers.h"
 #include "mozilla/ErrorResult.h"
 #include "mozilla/Likely.h"
 #include "mozilla/MemoryReporting.h"
 #include "nsCycleCollector.h"
 #include "nsIXPConnect.h"
 #include "MainThreadUtils.h"
 #include "nsISupportsImpl.h"
 #include "qsObjectHelper.h"
 #include "xpcpublic.h"
 #include "nsIVariant.h"
 #include "pldhash.h" // For PLDHashOperator
 #include "nsWrapperCacheInlines.h"
 class nsIJSID;
 class nsPIDOMWindow;
 extern nsresult
 xpc_qsUnwrapArgImpl(JSContext* cx, JS::Handle<JS::Value> v, const nsIID& iid, void** ppArg,
                     nsISupports** ppArgRef, JS::MutableHandle<JS::Value> vp);
 namespace mozilla {
 namespace dom {
 template<typename DataType> class MozMap;
 struct SelfRef
 {
   SelfRef() : ptr(nullptr) {}
   explicit SelfRef(nsISupports *p) : ptr(p) {}
   ~SelfRef() { NS_IF_RELEASE(ptr); }
   nsISupports* ptr;
 };
 /** Convert a jsval to an XPCOM pointer. */
 template <class Interface, class StrongRefType>
 inline nsresult
 UnwrapArg(JSContext* cx, JS::Handle<JS::Value> v, Interface** ppArg,
           StrongRefType** ppArgRef, JS::MutableHandle<JS::Value> vp)
 {
   nsISupports* argRef = *ppArgRef;
   nsresult rv = xpc_qsUnwrapArgImpl(cx, v, NS_GET_TEMPLATE_IID(Interface),
                                     reinterpret_cast<void**>(ppArg), &argRef,
                                     vp);
   *ppArgRef = static_cast<StrongRefType*>(argRef);
   return rv;
 }
 inline const ErrNum
 GetInvalidThisErrorForMethod(bool aSecurityError)
 {
   return aSecurityError ? MSG_METHOD_THIS_UNWRAPPING_DENIED :
                           MSG_METHOD_THIS_DOES_NOT_IMPLEMENT_INTERFACE;
 }
 inline const ErrNum
 GetInvalidThisErrorForGetter(bool aSecurityError)
 {
   return aSecurityError ? MSG_GETTER_THIS_UNWRAPPING_DENIED :
                           MSG_GETTER_THIS_DOES_NOT_IMPLEMENT_INTERFACE;
 }
 inline const ErrNum
 GetInvalidThisErrorForSetter(bool aSecurityError)
 {
   return aSecurityError ? MSG_SETTER_THIS_UNWRAPPING_DENIED :
                           MSG_SETTER_THIS_DOES_NOT_IMPLEMENT_INTERFACE;
 }
 bool
 ThrowInvalidThis(JSContext* aCx, const JS::CallArgs& aArgs,
                  const ErrNum aErrorNumber,
                  const char* aInterfaceName);
 bool
 ThrowInvalidThis(JSContext* aCx, const JS::CallArgs& aArgs,
                  const ErrNum aErrorNumber,
                  prototypes::ID aProtoId);
 inline bool
 ThrowMethodFailedWithDetails(JSContext* cx, ErrorResult& rv,
                              const char* ifaceName,
                              const char* memberName,
                              bool reportJSContentExceptions = false)
 {
   if (rv.IsTypeError()) {
     rv.ReportTypeError(cx);
     return false;
   }
   if (rv.IsJSException()) {
     if (reportJSContentExceptions) {
       rv.ReportJSExceptionFromJSImplementation(cx);
     } else {
       rv.ReportJSException(cx);
     }
     return false;
   }
   if (rv.IsNotEnoughArgsError()) {
     rv.ReportNotEnoughArgsError(cx, ifaceName, memberName);
     return false;
   }
   return Throw(cx, rv.ErrorCode());
 }
 // Returns true if the JSClass is used for DOM objects.
 inline bool
 IsDOMClass(const JSClass* clasp)
 {
   return clasp->flags & JSCLASS_IS_DOMJSCLASS;
 }
 inline bool
 IsDOMClass(const js::Class* clasp)
 {
   return IsDOMClass(Jsvalify(clasp));
 }
 // Return true if the JSClass is used for non-proxy DOM objects.
 inline bool
 IsNonProxyDOMClass(const js::Class* clasp)
 {
   return IsDOMClass(clasp) && !clasp->isProxy();
 }
 inline bool
 IsNonProxyDOMClass(const JSClass* clasp)
 {
   return IsNonProxyDOMClass(js::Valueify(clasp));
 }
 // Returns true if the JSClass is used for DOM interface and interface
 // prototype objects.
 inline bool
 IsDOMIfaceAndProtoClass(const JSClass* clasp)
 {
   return clasp->flags & JSCLASS_IS_DOMIFACEANDPROTOJSCLASS;
 }
 inline bool
 IsDOMIfaceAndProtoClass(const js::Class* clasp)
 {
   return IsDOMIfaceAndProtoClass(Jsvalify(clasp));
 }
 static_assert(DOM_OBJECT_SLOT == js::PROXY_PRIVATE_SLOT,
               "js::PROXY_PRIVATE_SLOT doesn't match DOM_OBJECT_SLOT.  "
               "Expect bad things");
 template <class T>
 inline T*
 UnwrapDOMObject(JSObject* obj)
 {
   MOZ_ASSERT(IsDOMClass(js::GetObjectClass(obj)),
              "Don't pass non-DOM objects to this function");
   JS::Value val = js::GetReservedSlot(obj, DOM_OBJECT_SLOT);
   return static_cast<T*>(val.toPrivate());
 }
 inline const DOMClass*
 GetDOMClass(JSObject* obj)
 {
   const js::Class* clasp = js::GetObjectClass(obj);
   if (IsDOMClass(clasp)) {
     return &DOMJSClass::FromJSClass(clasp)->mClass;
   }
   return nullptr;
 }
 inline nsISupports*
 UnwrapDOMObjectToISupports(JSObject* aObject)
 {
   const DOMClass* clasp = GetDOMClass(aObject);
   if (!clasp || !clasp->mDOMObjectIsISupports) {
     return nullptr;
   }
   return UnwrapDOMObject<nsISupports>(aObject);
 }
 inline bool
 IsDOMObject(JSObject* obj)
 {
   return IsDOMClass(js::GetObjectClass(obj));
 }
 #define UNWRAP_OBJECT(Interface, obj, value)                                 \
   mozilla::dom::UnwrapObject<mozilla::dom::prototypes::id::Interface,        \
     mozilla::dom::Interface##Binding::NativeType>(obj, value)
 // Some callers don't want to set an exception when unwrapping fails
 // (for example, overload resolution uses unwrapping to tell what sort
 // of thing it's looking at).
 // U must be something that a T* can be assigned to (e.g. T* or an nsRefPtr<T>).
 template <class T, typename U>
 MOZ_ALWAYS_INLINE nsresult
 UnwrapObject(JSObject* obj, U& value, prototypes::ID protoID,
              uint32_t protoDepth)
 {
   /* First check to see whether we have a DOM object */
   const DOMClass* domClass = GetDOMClass(obj);
   if (!domClass) {
     /* Maybe we have a security wrapper or outer window? */
     if (!js::IsWrapper(obj)) {
       /* Not a DOM object, not a wrapper, just bail */
       return NS_ERROR_XPC_BAD_CONVERT_JS;
     }
     obj = js::CheckedUnwrap(obj, /* stopAtOuter = */ false);
     if (!obj) {
       return NS_ERROR_XPC_SECURITY_MANAGER_VETO;
     }
     MOZ_ASSERT(!js::IsWrapper(obj));
     domClass = GetDOMClass(obj);
     if (!domClass) {
       /* We don't have a DOM object */
       return NS_ERROR_XPC_BAD_CONVERT_JS;
     }
   }
   /* This object is a DOM object.  Double-check that it is safely
      castable to T by checking whether it claims to inherit from the
      class identified by protoID. */
   if (domClass->mInterfaceChain[protoDepth] == protoID) {
     value = UnwrapDOMObject<T>(obj);
     return NS_OK;
   }
   /* It's the wrong sort of DOM object */
   return NS_ERROR_XPC_BAD_CONVERT_JS;
 }
 template <prototypes::ID PrototypeID, class T, typename U>
 MOZ_ALWAYS_INLINE nsresult
 UnwrapObject(JSObject* obj, U& value)
 {
   return UnwrapObject<T>(obj, value, PrototypeID,
                          PrototypeTraits<PrototypeID>::Depth);
 }
 inline bool
 IsNotDateOrRegExp(JSContext* cx, JS::Handle<JSObject*> obj)
 {
   MOZ_ASSERT(obj);
   return !JS_ObjectIsDate(cx, obj) && !JS_ObjectIsRegExp(cx, obj);
 }
 MOZ_ALWAYS_INLINE bool
 IsObjectValueConvertibleToDictionary(JSContext* cx,
                                      JS::Handle<JS::Value> objVal)
 {
   JS::Rooted<JSObject*> obj(cx, &objVal.toObject());
   return IsNotDateOrRegExp(cx, obj);
 }
 MOZ_ALWAYS_INLINE bool
 IsConvertibleToDictionary(JSContext* cx, JS::Handle<JS::Value> val)
 {
   return val.isNullOrUndefined() ||
     (val.isObject() && IsObjectValueConvertibleToDictionary(cx, val));
 }
 MOZ_ALWAYS_INLINE bool
 IsConvertibleToCallbackInterface(JSContext* cx, JS::Handle<JSObject*> obj)
 {
   return IsNotDateOrRegExp(cx, obj);
 }
 // The items in the protoAndIfaceCache are indexed by the prototypes::id::ID and
 // constructors::id::ID enums, in that order. The end of the prototype objects
 // should be the start of the interface objects.
 static_assert((size_t)constructors::id::_ID_Start ==
               (size_t)prototypes::id::_ID_Count,
               "Overlapping or discontiguous indexes.");
 const size_t kProtoAndIfaceCacheCount = constructors::id::_ID_Count;
 class ProtoAndIfaceCache
 {
   // The caching strategy we use depends on what sort of global we're dealing
   // with.  For a window-like global, we want everything to be as fast as
   // possible, so we use a flat array, indexed by prototype/constructor ID.
   // For everything else (e.g. globals for JSMs), space is more important than
   // speed, so we use a two-level lookup table.
   class ArrayCache : public Array<JS::Heap<JSObject*>, kProtoAndIfaceCacheCount>
   {
   public:
     JSObject* EntrySlotIfExists(size_t i) {
       return (*this)[i];
     }
     JS::Heap<JSObject*>& EntrySlotOrCreate(size_t i) {
       return (*this)[i];
     }
     JS::Heap<JSObject*>& EntrySlotMustExist(size_t i) {
       MOZ_ASSERT((*this)[i]);
       return (*this)[i];
     }
     void Trace(JSTracer* aTracer) {
       for (size_t i = 0; i < ArrayLength(*this); ++i) {
         if ((*this)[i]) {
           JS_CallHeapObjectTracer(aTracer, &(*this)[i], "protoAndIfaceCache[i]");
         }
       }
     }
     size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) {
       return aMallocSizeOf(this);
     }
   };
   class PageTableCache
   {
   public:
     PageTableCache() {
       memset(&mPages, 0, sizeof(mPages));
     }
     ~PageTableCache() {
       for (size_t i = 0; i < ArrayLength(mPages); ++i) {
         delete mPages[i];
       }
     }
     JSObject* EntrySlotIfExists(size_t i) {
       MOZ_ASSERT(i < kProtoAndIfaceCacheCount);
       size_t pageIndex = i / kPageSize;
       size_t leafIndex = i % kPageSize;
       Page* p = mPages[pageIndex];
       if (!p) {
         return nullptr;
       }
       return (*p)[leafIndex];
     }
     JS::Heap<JSObject*>& EntrySlotOrCreate(size_t i) {
       MOZ_ASSERT(i < kProtoAndIfaceCacheCount);
       size_t pageIndex = i / kPageSize;
       size_t leafIndex = i % kPageSize;
       Page* p = mPages[pageIndex];
       if (!p) {
         p = new Page;
         mPages[pageIndex] = p;
       }
       return (*p)[leafIndex];
     }
     JS::Heap<JSObject*>& EntrySlotMustExist(size_t i) {
       MOZ_ASSERT(i < kProtoAndIfaceCacheCount);
       size_t pageIndex = i / kPageSize;
       size_t leafIndex = i % kPageSize;
       Page* p = mPages[pageIndex];
       MOZ_ASSERT(p);
       return (*p)[leafIndex];
     }
     void Trace(JSTracer* trc) {
       for (size_t i = 0; i < ArrayLength(mPages); ++i) {
         Page* p = mPages[i];
         if (p) {
           for (size_t j = 0; j < ArrayLength(*p); ++j) {
             if ((*p)[j]) {
               JS_CallHeapObjectTracer(trc, &(*p)[j], "protoAndIfaceCache[i]");
             }
           }
         }
       }
     }
     size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) {
       size_t n = aMallocSizeOf(this);
       for (size_t i = 0; i < ArrayLength(mPages); ++i) {
         n += aMallocSizeOf(mPages[i]);
       }
       return n;
     }
   private:
     static const size_t kPageSize = 16;
     typedef Array<JS::Heap<JSObject*>, kPageSize> Page;
     static const size_t kNPages = kProtoAndIfaceCacheCount / kPageSize +
       size_t(bool(kProtoAndIfaceCacheCount % kPageSize));
     Array<Page*, kNPages> mPages;
   };
 public:
   enum Kind {
     WindowLike,
     NonWindowLike
   };
   ProtoAndIfaceCache(Kind aKind) : mKind(aKind) {
     MOZ_COUNT_CTOR(ProtoAndIfaceCache);
     if (aKind == WindowLike) {
       mArrayCache = new ArrayCache();
     } else {
       mPageTableCache = new PageTableCache();
     }
   }
   ~ProtoAndIfaceCache() {
     if (mKind == WindowLike) {
       delete mArrayCache;
     } else {
       delete mPageTableCache;
     }
     MOZ_COUNT_DTOR(ProtoAndIfaceCache);
   }
 #define FORWARD_OPERATION(opName, args)              \
   do {                                               \
     if (mKind == WindowLike) {                       \
       return mArrayCache->opName args;               \
     } else {                                         \
       return mPageTableCache->opName args;           \
     }                                                \
   } while(0)
   JSObject* EntrySlotIfExists(size_t i) {
     FORWARD_OPERATION(EntrySlotIfExists, (i));
   }
   JS::Heap<JSObject*>& EntrySlotOrCreate(size_t i) {
     FORWARD_OPERATION(EntrySlotOrCreate, (i));
   }
   JS::Heap<JSObject*>& EntrySlotMustExist(size_t i) {
     FORWARD_OPERATION(EntrySlotMustExist, (i));
   }
   void Trace(JSTracer *aTracer) {
     FORWARD_OPERATION(Trace, (aTracer));
   }
   size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) {
     size_t n = aMallocSizeOf(this);
     n += (mKind == WindowLike
           ? mArrayCache->SizeOfIncludingThis(aMallocSizeOf)
           : mPageTableCache->SizeOfIncludingThis(aMallocSizeOf));
     return n;
   }
 #undef FORWARD_OPERATION
 private:
   union {
     ArrayCache *mArrayCache;
     PageTableCache *mPageTableCache;
   };
   Kind mKind;
 };
 inline void
 AllocateProtoAndIfaceCache(JSObject* obj, ProtoAndIfaceCache::Kind aKind)
 {
   MOZ_ASSERT(js::GetObjectClass(obj)->flags & JSCLASS_DOM_GLOBAL);
   MOZ_ASSERT(js::GetReservedSlot(obj, DOM_PROTOTYPE_SLOT).isUndefined());
   ProtoAndIfaceCache* protoAndIfaceCache = new ProtoAndIfaceCache(aKind);
   js::SetReservedSlot(obj, DOM_PROTOTYPE_SLOT,
                       JS::PrivateValue(protoAndIfaceCache));
 }
 inline void
 TraceProtoAndIfaceCache(JSTracer* trc, JSObject* obj)
 {
   MOZ_ASSERT(js::GetObjectClass(obj)->flags & JSCLASS_DOM_GLOBAL);
   if (!HasProtoAndIfaceCache(obj))
     return;
   ProtoAndIfaceCache* protoAndIfaceCache = GetProtoAndIfaceCache(obj);
   protoAndIfaceCache->Trace(trc);
 }
 inline void
 DestroyProtoAndIfaceCache(JSObject* obj)
 {
   MOZ_ASSERT(js::GetObjectClass(obj)->flags & JSCLASS_DOM_GLOBAL);
   ProtoAndIfaceCache* protoAndIfaceCache = GetProtoAndIfaceCache(obj);
   delete protoAndIfaceCache;
 }
 /**
  * Add constants to an object.
  */
 bool
 DefineConstants(JSContext* cx, JS::Handle<JSObject*> obj,
                 const ConstantSpec* cs);
 struct JSNativeHolder
 {
   JSNative mNative;
   const NativePropertyHooks* mPropertyHooks;
 };
 struct NamedConstructor
 {
   const char* mName;
   const JSNativeHolder mHolder;
   unsigned mNargs;
 };
 /*
  * Create a DOM interface object (if constructorClass is non-null) and/or a
  * DOM interface prototype object (if protoClass is non-null).
  *
  * global is used as the parent of the interface object and the interface
  *        prototype object
  * protoProto is the prototype to use for the interface prototype object.
  * interfaceProto is the prototype to use for the interface object.
  * protoClass is the JSClass to use for the interface prototype object.
  *            This is null if we should not create an interface prototype
  *            object.
  * protoCache a pointer to a JSObject pointer where we should cache the
  *            interface prototype object. This must be null if protoClass is and
  *            vice versa.
  * constructorClass is the JSClass to use for the interface object.
  *                  This is null if we should not create an interface object or
  *                  if it should be a function object.
  * constructor holds the JSNative to back the interface object which should be a
  *             Function, unless constructorClass is non-null in which case it is
  *             ignored. If this is null and constructorClass is also null then
  *             we should not create an interface object at all.
  * ctorNargs is the length of the constructor function; 0 if no constructor
  * constructorCache a pointer to a JSObject pointer where we should cache the
  *                  interface object. This must be null if both constructorClass
  *                  and constructor are null, and non-null otherwise.
  * domClass is the DOMClass of instance objects for this class.  This can be
  *          null if this is not a concrete proto.
  * properties contains the methods, attributes and constants to be defined on
  *            objects in any compartment.
  * chromeProperties contains the methods, attributes and constants to be defined
  *                  on objects in chrome compartments. This must be null if the
  *                  interface doesn't have any ChromeOnly properties or if the
  *                  object is being created in non-chrome compartment.
  * defineOnGlobal controls whether properties should be defined on the given
  *                global for the interface object (if any) and named
  *                constructors (if any) for this interface.  This can be
  *                false in situations where we want the properties to only
  *                appear on privileged Xrays but not on the unprivileged
  *                underlying global.
  *
  * At least one of protoClass, constructorClass or constructor should be
  * non-null. If constructorClass or constructor are non-null, the resulting
  * interface object will be defined on the given global with property name
  * |name|, which must also be non-null.
  */
 void
 CreateInterfaceObjects(JSContext* cx, JS::Handle<JSObject*> global,
                        JS::Handle<JSObject*> protoProto,
                        const JSClass* protoClass, JS::Heap<JSObject*>* protoCache,
                        JS::Handle<JSObject*> interfaceProto,
                        const JSClass* constructorClass, const JSNativeHolder* constructor,
                        unsigned ctorNargs, const NamedConstructor* namedConstructors,
                        JS::Heap<JSObject*>* constructorCache, const DOMClass* domClass,
                        const NativeProperties* regularProperties,
                        const NativeProperties* chromeOnlyProperties,
                        const char* name, bool defineOnGlobal);
 /*
  * Define the unforgeable attributes on an object.
  */
 bool
 DefineUnforgeableAttributes(JSContext* cx, JS::Handle<JSObject*> obj,
                             const Prefable<const JSPropertySpec>* props);
 bool
 DefineWebIDLBindingPropertiesOnXPCObject(JSContext* cx,
                                          JS::Handle<JSObject*> obj,
                                          const NativeProperties* properties,
                                          bool defineUnforgeableAttributes);
 #ifdef _MSC_VER
 #define HAS_MEMBER_CHECK(_name)                                           \
   template<typename V> static yes& Check(char (*)[(&V::_name == 0) + 1])
 #else
 #define HAS_MEMBER_CHECK(_name)                                           \
   template<typename V> static yes& Check(char (*)[sizeof(&V::_name) + 1])
 #endif
 #define HAS_MEMBER(_name)                                                 \
 template<typename T>                                                      \
 class Has##_name##Member {                                                \
   typedef char yes[1];                                                    \
   typedef char no[2];                                                     \
   HAS_MEMBER_CHECK(_name);                                                \
   template<typename V> static no& Check(...);                             \
                                                                           \
 public:                                                                   \
   static bool const Value = sizeof(Check<T>(nullptr)) == sizeof(yes);     \
 };
 HAS_MEMBER(WrapObject)
 // HasWrapObject<T>::Value will be true if T has a WrapObject member but it's
 // not nsWrapperCache::WrapObject.
 template<typename T>
 struct HasWrapObject
 {
 private:
   typedef char yes[1];
   typedef char no[2];
   typedef JSObject* (nsWrapperCache::*WrapObject)(JSContext*,
                                                   JS::Handle<JSObject*>);
   template<typename U, U> struct SFINAE;
   template <typename V> static no& Check(SFINAE<WrapObject, &V::WrapObject>*);
   template <typename V> static yes& Check(...);
 public:
   static bool const Value = HasWrapObjectMember<T>::Value &&
                             sizeof(Check<T>(nullptr)) == sizeof(yes);
 };
 #ifdef DEBUG
 template <class T, bool isISupports=IsBaseOf<nsISupports, T>::value>
 struct
 CheckWrapperCacheCast
 {
   static bool Check()
   {
     return reinterpret_cast<uintptr_t>(
       static_cast<nsWrapperCache*>(
         reinterpret_cast<T*>(1))) == 1;
   }
 };
 template <class T>
 struct
 CheckWrapperCacheCast<T, true>
 {
   static bool Check()
   {
     return true;
   }
 };
 #endif
 MOZ_ALWAYS_INLINE bool
 CouldBeDOMBinding(void*)
 {
   return true;
 }
 MOZ_ALWAYS_INLINE bool
 CouldBeDOMBinding(nsWrapperCache* aCache)
 {
   return aCache->IsDOMBinding();
 }
 inline bool
 TryToOuterize(JSContext* cx, JS::MutableHandle<JS::Value> rval)
 {
   if (js::IsInnerObject(&rval.toObject())) {
     JS::Rooted<JSObject*> obj(cx, &rval.toObject());
     obj = JS_ObjectToOuterObject(cx, obj);
     if (!obj) {
       return false;
     }
     rval.set(JS::ObjectValue(*obj));
   }
   return true;
 }
 // Make sure to wrap the given string value into the right compartment, as
 // needed.
 MOZ_ALWAYS_INLINE
 bool
 MaybeWrapStringValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
 {
   MOZ_ASSERT(rval.isString());
   JSString* str = rval.toString();
   if (JS::GetGCThingZone(str) != js::GetContextZone(cx)) {
     return JS_WrapValue(cx, rval);
   }
   return true;
 }
 // Make sure to wrap the given object value into the right compartment as
 // needed.  This will work correctly, but possibly slowly, on all objects.
 MOZ_ALWAYS_INLINE
 bool
 MaybeWrapObjectValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
 {
   MOZ_ASSERT(rval.isObject());
   // Cross-compartment always requires wrapping.
   JSObject* obj = &rval.toObject();
   if (js::GetObjectCompartment(obj) != js::GetContextCompartment(cx)) {
     return JS_WrapValue(cx, rval);
   }
   // We're same-compartment, but even then we might need to wrap
   // objects specially.  Check for that.
   if (IsDOMObject(obj)) {
     return TryToOuterize(cx, rval);
   }
   // It's not a WebIDL object.  But it might be an XPConnect one, in which case
   // we may need to outerize here, so make sure to call JS_WrapValue.
   return JS_WrapValue(cx, rval);
 }
 // Like MaybeWrapObjectValue, but also allows null
 MOZ_ALWAYS_INLINE
 bool
 MaybeWrapObjectOrNullValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
 {
   MOZ_ASSERT(rval.isObjectOrNull());
   if (rval.isNull()) {
     return true;
   }
   return MaybeWrapObjectValue(cx, rval);
 }
 // Wrapping for objects that are known to not be DOM or XPConnect objects
 MOZ_ALWAYS_INLINE
 bool
 MaybeWrapNonDOMObjectValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
 {
   MOZ_ASSERT(rval.isObject());
   MOZ_ASSERT(!GetDOMClass(&rval.toObject()));
   MOZ_ASSERT(!(js::GetObjectClass(&rval.toObject())->flags &
                JSCLASS_PRIVATE_IS_NSISUPPORTS));
   JSObject* obj = &rval.toObject();
   if (js::GetObjectCompartment(obj) == js::GetContextCompartment(cx)) {
     return true;
   }
   return JS_WrapValue(cx, rval);
 }
 // Like MaybeWrapNonDOMObjectValue but allows null
 MOZ_ALWAYS_INLINE
 bool
 MaybeWrapNonDOMObjectOrNullValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
 {
   MOZ_ASSERT(rval.isObjectOrNull());
   if (rval.isNull()) {
     return true;
   }
   return MaybeWrapNonDOMObjectValue(cx, rval);
 }
 // If rval is a gcthing and is not in the compartment of cx, wrap rval
 // into the compartment of cx (typically by replacing it with an Xray or
 // cross-compartment wrapper around the original object).
 MOZ_ALWAYS_INLINE bool
 MaybeWrapValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
 {
   if (rval.isString()) {
     return MaybeWrapStringValue(cx, rval);
   }
   if (!rval.isObject()) {
     return true;
   }
   return MaybeWrapObjectValue(cx, rval);
 }
 // Create a JSObject wrapping "value", if there isn't one already, and store it
 // in rval.  "value" must be a concrete class that implements a
 // GetWrapperPreserveColor() which can return its existing wrapper, if any, and
 // a WrapObject() which will try to create a wrapper. Typically, this is done by
 // having "value" inherit from nsWrapperCache.
 template <class T>
 MOZ_ALWAYS_INLINE bool
 WrapNewBindingObject(JSContext* cx, T* value, JS::MutableHandle<JS::Value> rval)
 {
   MOZ_ASSERT(value);
   JSObject* obj = value->GetWrapperPreserveColor();
   // We can get rid of this when we remove support for hasXPConnectImpls.
   bool couldBeDOMBinding = CouldBeDOMBinding(value);
   if (obj) {
     JS::ExposeObjectToActiveJS(obj);
   } else {
     // Inline this here while we have non-dom objects in wrapper caches.
     if (!couldBeDOMBinding) {
       return false;
     }
     obj = value->WrapObject(cx);
     if (!obj) {
       // At this point, obj is null, so just return false.
       // Callers seem to be testing JS_IsExceptionPending(cx) to
       // figure out whether WrapObject() threw.
       return false;
     }
   }
 #ifdef DEBUG
   const DOMClass* clasp = GetDOMClass(obj);
   // clasp can be null if the cache contained a non-DOM object.
   if (clasp) {
     // Some sanity asserts about our object.  Specifically:
     // 1)  If our class claims we're nsISupports, we better be nsISupports
     //     XXXbz ideally, we could assert that reinterpret_cast to nsISupports
     //     does the right thing, but I don't see a way to do it.  :(
     // 2)  If our class doesn't claim we're nsISupports we better be
     //     reinterpret_castable to nsWrapperCache.
     MOZ_ASSERT(clasp, "What happened here?");
     MOZ_ASSERT_IF(clasp->mDOMObjectIsISupports, (IsBaseOf<nsISupports, T>::value));
     MOZ_ASSERT(CheckWrapperCacheCast<T>::Check());
   }
 #endif
   rval.set(JS::ObjectValue(*obj));
   bool sameCompartment =
     js::GetObjectCompartment(obj) == js::GetContextCompartment(cx);
   if (sameCompartment && couldBeDOMBinding) {
     // We only need to outerize Window objects, so anything inheriting from
     // nsGlobalWindow (which inherits from EventTarget itself).
     return IsBaseOf<nsGlobalWindow, T>::value || IsSame<EventTarget, T>::value ?
            TryToOuterize(cx, rval) : true;
   }
   return JS_WrapValue(cx, rval);
 }
 // Create a JSObject wrapping "value", for cases when "value" is a
 // non-wrapper-cached object using WebIDL bindings.  "value" must implement a
 // WrapObject() method taking a JSContext and a scope.
 template <class T>
 inline bool
 WrapNewBindingNonWrapperCachedObject(JSContext* cx,
                                      JS::Handle<JSObject*> scopeArg,
                                      T* value,
                                      JS::MutableHandle<JS::Value> rval)
 {
   MOZ_ASSERT(value);
   // We try to wrap in the compartment of the underlying object of "scope"
   JS::Rooted<JSObject*> obj(cx);
   {
     // scope for the JSAutoCompartment so that we restore the compartment
     // before we call JS_WrapValue.
     Maybe<JSAutoCompartment> ac;
     // Maybe<Handle> doesn't so much work, and in any case, adding
     // more Maybe (one for a Rooted and one for a Handle) adds more
     // code (and branches!) than just adding a single rooted.
     JS::Rooted<JSObject*> scope(cx, scopeArg);
     if (js::IsWrapper(scope)) {
       scope = js::CheckedUnwrap(scope, /* stopAtOuter = */ false);
       if (!scope)
         return false;
       ac.construct(cx, scope);
     }
     MOZ_ASSERT(js::IsObjectInContextCompartment(scope, cx));
     obj = value->WrapObject(cx);
   }
   if (!obj) {
     return false;
   }
   // We can end up here in all sorts of compartments, per above.  Make
   // sure to JS_WrapValue!
   rval.set(JS::ObjectValue(*obj));
   return JS_WrapValue(cx, rval);
 }
 // Create a JSObject wrapping "value", for cases when "value" is a
 // non-wrapper-cached owned object using WebIDL bindings.  "value" must implement a
 // WrapObject() method taking a JSContext, a scope, and a boolean outparam that
 // is true if the JSObject took ownership
 template <class T>
 inline bool
 WrapNewBindingNonWrapperCachedOwnedObject(JSContext* cx,
                                           JS::Handle<JSObject*> scopeArg,
                                           nsAutoPtr<T>& value,
                                           JS::MutableHandle<JS::Value> rval)
 {
   // We do a runtime check on value, because otherwise we might in
   // fact end up wrapping a null and invoking methods on it later.
   if (!value) {
     NS_RUNTIMEABORT("Don't try to wrap null objects");
   }
   // We try to wrap in the compartment of the underlying object of "scope"
   JS::Rooted<JSObject*> obj(cx);
   {
     // scope for the JSAutoCompartment so that we restore the compartment
     // before we call JS_WrapValue.
     Maybe<JSAutoCompartment> ac;
     // Maybe<Handle> doesn't so much work, and in any case, adding
     // more Maybe (one for a Rooted and one for a Handle) adds more
     // code (and branches!) than just adding a single rooted.
     JS::Rooted<JSObject*> scope(cx, scopeArg);
     if (js::IsWrapper(scope)) {
       scope = js::CheckedUnwrap(scope, /* stopAtOuter = */ false);
       if (!scope)
         return false;
       ac.construct(cx, scope);
     }
     bool tookOwnership = false;
     MOZ_ASSERT(js::IsObjectInContextCompartment(scope, cx));
     obj = value->WrapObject(cx, &tookOwnership);
     MOZ_ASSERT_IF(obj, tookOwnership);
     if (tookOwnership) {
       value.forget();
     }
   }
   if (!obj) {
     return false;
   }
   // We can end up here in all sorts of compartments, per above.  Make
   // sure to JS_WrapValue!
   rval.set(JS::ObjectValue(*obj));
   return JS_WrapValue(cx, rval);
 }
 // Helper for smart pointers (nsAutoPtr/nsRefPtr/nsCOMPtr).
 template <template <typename> class SmartPtr, typename T>
 inline bool
 WrapNewBindingNonWrapperCachedObject(JSContext* cx, JS::Handle<JSObject*> scope,
                                      const SmartPtr<T>& value,
                                      JS::MutableHandle<JS::Value> rval)
 {
   return WrapNewBindingNonWrapperCachedObject(cx, scope, value.get(), rval);
 }
 // Only set allowNativeWrapper to false if you really know you need it, if in
 // doubt use true. Setting it to false disables security wrappers.
 bool
 NativeInterface2JSObjectAndThrowIfFailed(JSContext* aCx,
                                          JS::Handle<JSObject*> aScope,
                                          JS::MutableHandle<JS::Value> aRetval,
                                          xpcObjectHelper& aHelper,
                                          const nsIID* aIID,
                                          bool aAllowNativeWrapper);
 /**
  * A method to handle new-binding wrap failure, by possibly falling back to
  * wrapping as a non-new-binding object.
  */
 template <class T>
 MOZ_ALWAYS_INLINE bool
 HandleNewBindingWrappingFailure(JSContext* cx, JS::Handle<JSObject*> scope,
                                 T* value, JS::MutableHandle<JS::Value> rval)
 {
   if (JS_IsExceptionPending(cx)) {
     return false;
   }
   qsObjectHelper helper(value, GetWrapperCache(value));
   return NativeInterface2JSObjectAndThrowIfFailed(cx, scope, rval,
                                                   helper, nullptr, true);
 }
 // Helper for calling HandleNewBindingWrappingFailure with smart pointers
 // (nsAutoPtr/nsRefPtr/nsCOMPtr) or references.
 HAS_MEMBER(get)
 template <class T, bool isSmartPtr=HasgetMember<T>::Value>
 struct HandleNewBindingWrappingFailureHelper
 {
   static inline bool Wrap(JSContext* cx, JS::Handle<JSObject*> scope,
                           const T& value, JS::MutableHandle<JS::Value> rval)
   {
     return HandleNewBindingWrappingFailure(cx, scope, value.get(), rval);
   }
 };
 template <class T>
 struct HandleNewBindingWrappingFailureHelper<T, false>
 {
   static inline bool Wrap(JSContext* cx, JS::Handle<JSObject*> scope, T& value,
                           JS::MutableHandle<JS::Value> rval)
   {
     return HandleNewBindingWrappingFailure(cx, scope, &value, rval);
   }
 };
 template<class T>
 inline bool
 HandleNewBindingWrappingFailure(JSContext* cx, JS::Handle<JSObject*> scope,
                                 T& value, JS::MutableHandle<JS::Value> rval)
 {
   return HandleNewBindingWrappingFailureHelper<T>::Wrap(cx, scope, value, rval);
 }
 template<bool Fatal>
 inline bool
 EnumValueNotFound(JSContext* cx, const jschar* chars, size_t length,
                   const char* type, const char* sourceDescription)
 {
   return false;
 }
 template<>
 inline bool
 EnumValueNotFound<false>(JSContext* cx, const jschar* chars, size_t length,
                          const char* type, const char* sourceDescription)
 {
   // TODO: Log a warning to the console.
   return true;
 }
 template<>
 inline bool
 EnumValueNotFound<true>(JSContext* cx, const jschar* chars, size_t length,
                         const char* type, const char* sourceDescription)
 {
   NS_LossyConvertUTF16toASCII deflated(static_cast<const char16_t*>(chars),
                                        length);
   return ThrowErrorMessage(cx, MSG_INVALID_ENUM_VALUE, sourceDescription,
                            deflated.get(), type);
 }
 template<bool InvalidValueFatal>
 inline int
 FindEnumStringIndex(JSContext* cx, JS::Handle<JS::Value> v, const EnumEntry* values,
                     const char* type, const char* sourceDescription, bool* ok)
 {
   // JS_StringEqualsAscii is slow as molasses, so don't use it here.
   JSString* str = JS::ToString(cx, v);
   if (!str) {
     *ok = false;
     return 0;
   }
   JS::Anchor<JSString*> anchor(str);
   size_t length;
   const jschar* chars = JS_GetStringCharsAndLength(cx, str, &length);
   if (!chars) {
     *ok = false;
     return 0;
   }
   int i = 0;
   for (const EnumEntry* value = values; value->value; ++value, ++i) {
     if (length != value->length) {
       continue;
     }
     bool equal = true;
     const char* val = value->value;
     for (size_t j = 0; j != length; ++j) {
       if (unsigned(val[j]) != unsigned(chars[j])) {
         equal = false;
         break;
       }
     }
     if (equal) {
       *ok = true;
       return i;
     }
   }
   *ok = EnumValueNotFound<InvalidValueFatal>(cx, chars, length, type,
                                              sourceDescription);
   return -1;
 }
 inline nsWrapperCache*
 GetWrapperCache(const ParentObject& aParentObject)
 {
   return aParentObject.mWrapperCache;
 }
 template<class T>
 inline T*
 GetParentPointer(T* aObject)
 {
   return aObject;
 }
 inline nsISupports*
 GetParentPointer(const ParentObject& aObject)
 {
   return aObject.mObject;
 }
 template <typename T>
 inline bool
 GetUseXBLScope(T* aParentObject)
 {
   return false;
 }
 inline bool
 GetUseXBLScope(const ParentObject& aParentObject)
 {
   return aParentObject.mUseXBLScope;
 }
 template<class T>
 inline void
 ClearWrapper(T* p, nsWrapperCache* cache)
 {
   cache->ClearWrapper();
 }
 template<class T>
 inline void
 ClearWrapper(T* p, void*)
 {
   nsWrapperCache* cache;
   CallQueryInterface(p, &cache);
   ClearWrapper(p, cache);
 }
 // Attempt to preserve the wrapper, if any, for a Paris DOM bindings object.
 // Return true if we successfully preserved the wrapper, or there is no wrapper
 // to preserve. In the latter case we don't need to preserve the wrapper, because
 // the object can only be obtained by JS once, or they cannot be meaningfully
 // owned from the native side.
 //
 // This operation will return false only for non-nsISupports cycle-collected
 // objects, because we cannot determine if they are wrappercached or not.
 bool
 TryPreserveWrapper(JSObject* obj);
 // Can only be called with the immediate prototype of the instance object. Can
 // only be called on the prototype of an object known to be a DOM instance.
 bool
 InstanceClassHasProtoAtDepth(JSObject* protoObject, uint32_t protoID,
                              uint32_t depth);
 // Only set allowNativeWrapper to false if you really know you need it, if in
 // doubt use true. Setting it to false disables security wrappers.
 bool
 XPCOMObjectToJsval(JSContext* cx, JS::Handle<JSObject*> scope,
                    xpcObjectHelper& helper, const nsIID* iid,
                    bool allowNativeWrapper, JS::MutableHandle<JS::Value> rval);
 // Special-cased wrapping for variants
 bool
 VariantToJsval(JSContext* aCx, nsIVariant* aVariant,
                JS::MutableHandle<JS::Value> aRetval);
 // Wrap an object "p" which is not using WebIDL bindings yet.  This _will_
 // actually work on WebIDL binding objects that are wrappercached, but will be
 // much slower than WrapNewBindingObject.  "cache" must either be null or be the
 // nsWrapperCache for "p".
 template<class T>
 inline bool
 WrapObject(JSContext* cx, T* p, nsWrapperCache* cache, const nsIID* iid,
            JS::MutableHandle<JS::Value> rval)
 {
   if (xpc_FastGetCachedWrapper(cx, cache, rval))
     return true;
   qsObjectHelper helper(p, cache);
   JS::Rooted<JSObject*> scope(cx, JS::CurrentGlobalOrNull(cx));
   return XPCOMObjectToJsval(cx, scope, helper, iid, true, rval);
 }
 // A specialization of the above for nsIVariant, because that needs to
 // do something different.
 template<>
 inline bool
 WrapObject<nsIVariant>(JSContext* cx, nsIVariant* p,
                        nsWrapperCache* cache, const nsIID* iid,
                        JS::MutableHandle<JS::Value> rval)
 {
   MOZ_ASSERT(iid);
   MOZ_ASSERT(iid->Equals(NS_GET_IID(nsIVariant)));
   return VariantToJsval(cx, p, rval);
 }
 // Wrap an object "p" which is not using WebIDL bindings yet.  Just like the
 // variant that takes an nsWrapperCache above, but will try to auto-derive the
 // nsWrapperCache* from "p".
 template<class T>
 inline bool
 WrapObject(JSContext* cx, T* p, const nsIID* iid,
            JS::MutableHandle<JS::Value> rval)
 {
   return WrapObject(cx, p, GetWrapperCache(p), iid, rval);
 }
 // Just like the WrapObject above, but without requiring you to pick which
 // interface you're wrapping as.  This should only be used for objects that have
 // classinfo, for which it doesn't matter what IID is used to wrap.
 template<class T>
 inline bool
 WrapObject(JSContext* cx, T* p, JS::MutableHandle<JS::Value> rval)
 {
   return WrapObject(cx, p, nullptr, rval);
 }
 // Helper to make it possible to wrap directly out of an nsCOMPtr
 template<class T>
 inline bool
 WrapObject(JSContext* cx, const nsCOMPtr<T>& p,
            const nsIID* iid, JS::MutableHandle<JS::Value> rval)
 {
   return WrapObject(cx, p.get(), iid, rval);
 }
 // Helper to make it possible to wrap directly out of an nsCOMPtr
 template<class T>
 inline bool
 WrapObject(JSContext* cx, const nsCOMPtr<T>& p,
            JS::MutableHandle<JS::Value> rval)
 {
   return WrapObject(cx, p, nullptr, rval);
 }
 // Helper to make it possible to wrap directly out of an nsRefPtr
 template<class T>
 inline bool
 WrapObject(JSContext* cx, const nsRefPtr<T>& p,
            const nsIID* iid, JS::MutableHandle<JS::Value> rval)
 {
   return WrapObject(cx, p.get(), iid, rval);
 }
 // Helper to make it possible to wrap directly out of an nsRefPtr
 template<class T>
 inline bool
 WrapObject(JSContext* cx, const nsRefPtr<T>& p,
            JS::MutableHandle<JS::Value> rval)
 {
   return WrapObject(cx, p, nullptr, rval);
 }
 // Specialization to make it easy to use WrapObject in codegen.
 template<>
 inline bool
 WrapObject<JSObject>(JSContext* cx, JSObject* p,
                      JS::MutableHandle<JS::Value> rval)
 {
   rval.set(JS::ObjectOrNullValue(p));
   return true;
 }
 inline bool
 WrapObject(JSContext* cx, JSObject& p, JS::MutableHandle<JS::Value> rval)
 {
   rval.set(JS::ObjectValue(p));
   return true;
 }
 // Given an object "p" that inherits from nsISupports, wrap it and return the
 // result.  Null is returned on wrapping failure.  This is somewhat similar to
 // WrapObject() above, but does NOT allow Xrays around the result, since we
 // don't want those for our parent object.
 template<typename T>
 static inline JSObject*
 WrapNativeISupportsParent(JSContext* cx, T* p, nsWrapperCache* cache)
 {
   qsObjectHelper helper(ToSupports(p), cache);
   JS::Rooted<JSObject*> scope(cx, JS::CurrentGlobalOrNull(cx));
   JS::Rooted<JS::Value> v(cx);
   return XPCOMObjectToJsval(cx, scope, helper, nullptr, false, &v) ?
          v.toObjectOrNull() :
          nullptr;
 }
 // Fallback for when our parent is not a WebIDL binding object.
 template<typename T, bool isISupports=IsBaseOf<nsISupports, T>::value>
 struct WrapNativeParentFallback
 {
   static inline JSObject* Wrap(JSContext* cx, T* parent, nsWrapperCache* cache)
   {
     return nullptr;
   }
 };
 // Fallback for when our parent is not a WebIDL binding object but _is_ an
 // nsISupports object.
 template<typename T >
 struct WrapNativeParentFallback<T, true >
 {
   static inline JSObject* Wrap(JSContext* cx, T* parent, nsWrapperCache* cache)
   {
     return WrapNativeISupportsParent(cx, parent, cache);
   }
 };
 // Wrapping of our native parent, for cases when it's a WebIDL object (though
 // possibly preffed off).
 template<typename T, bool hasWrapObject=HasWrapObject<T>::Value >
 struct WrapNativeParentHelper
 {
   static inline JSObject* Wrap(JSContext* cx, T* parent, nsWrapperCache* cache)
   {
     MOZ_ASSERT(cache);
     JSObject* obj;
     if ((obj = cache->GetWrapper())) {
       return obj;
     }
     // Inline this here while we have non-dom objects in wrapper caches.
     if (!CouldBeDOMBinding(parent)) {
       obj = WrapNativeParentFallback<T>::Wrap(cx, parent, cache);
     } else {
       obj = parent->WrapObject(cx);
     }
     return obj;
   }
 };
 // Wrapping of our native parent, for cases when it's not a WebIDL object.  In
 // this case it must be nsISupports.
 template<typename T>
 struct WrapNativeParentHelper<T, false >
 {
   static inline JSObject* Wrap(JSContext* cx, T* parent, nsWrapperCache* cache)
   {
     JSObject* obj;
     if (cache && (obj = cache->GetWrapper())) {
 #ifdef DEBUG
       NS_ASSERTION(WrapNativeISupportsParent(cx, parent, cache) == obj,
                    "Unexpected object in nsWrapperCache");
 #endif
       return obj;
     }
     return WrapNativeISupportsParent(cx, parent, cache);
   }
 };
 // Wrapping of our native parent.
 template<typename T>
 static inline JSObject*
 WrapNativeParent(JSContext* cx, T* p, nsWrapperCache* cache,
                  bool useXBLScope = false)
 {
   if (!p) {
     return JS::CurrentGlobalOrNull(cx);
   }
   JSObject* parent = WrapNativeParentHelper<T>::Wrap(cx, p, cache);
   if (!useXBLScope) {
     return parent;
   }
   // If useXBLScope is true, it means that the canonical reflector for this
   // native object should live in the XBL scope.
   if (xpc::IsInXBLScope(parent)) {
     return parent;
   }
   JS::Rooted<JSObject*> rootedParent(cx, parent);
   JS::Rooted<JSObject*> xblScope(cx, xpc::GetXBLScope(cx, rootedParent));
   NS_ENSURE_TRUE(xblScope, nullptr);
   JSAutoCompartment ac(cx, xblScope);
   if (NS_WARN_IF(!JS_WrapObject(cx, &rootedParent))) {
     return nullptr;
   }
   return rootedParent;
 }
 // Wrapping of our native parent, when we don't want to explicitly pass in
 // things like the nsWrapperCache for it.
 template<typename T>
 static inline JSObject*
 WrapNativeParent(JSContext* cx, const T& p)
 {
   return WrapNativeParent(cx, GetParentPointer(p), GetWrapperCache(p), GetUseXBLScope(p));
 }
 // A way to differentiate between nodes, which use the parent object
 // returned by native->GetParentObject(), and all other objects, which
 // just use the parent's global.
 static inline JSObject*
 GetRealParentObject(void* aParent, JSObject* aParentObject)
 {
   return aParentObject ?
     js::GetGlobalForObjectCrossCompartment(aParentObject) : nullptr;
 }
 static inline JSObject*
 GetRealParentObject(Element* aParent, JSObject* aParentObject)
 {
   return aParentObject;
 }
 HAS_MEMBER(GetParentObject)
 template<typename T, bool WrapperCached=HasGetParentObjectMember<T>::Value>
 struct GetParentObject
 {
   static JSObject* Get(JSContext* cx, JS::Handle<JSObject*> obj)
   {
     MOZ_ASSERT(js::IsObjectInContextCompartment(obj, cx));
     T* native = UnwrapDOMObject<T>(obj);
     return
       GetRealParentObject(native,
                           WrapNativeParent(cx, native->GetParentObject()));
   }
 };
 template<typename T>
 struct GetParentObject<T, false>
 {
   static JSObject* Get(JSContext* cx, JS::Handle<JSObject*> obj)
   {
     MOZ_CRASH();
     return nullptr;
   }
 };
 MOZ_ALWAYS_INLINE
 JSObject* GetJSObjectFromCallback(CallbackObject* callback)
 {
   return callback->Callback();
 }
 MOZ_ALWAYS_INLINE
 JSObject* GetJSObjectFromCallback(void* noncallback)
 {
   return nullptr;
 }
 template<typename T>
 static inline JSObject*
 WrapCallThisObject(JSContext* cx, const T& p)
 {
   // Callbacks are nsISupports, so WrapNativeParent will just happily wrap them
   // up as an nsISupports XPCWrappedNative... which is not at all what we want.
   // So we need to special-case them.
   JS::Rooted<JSObject*> obj(cx, GetJSObjectFromCallback(p));
   if (!obj) {
     // WrapNativeParent is a bit of a Swiss army knife that will
     // wrap anything for us.
     obj = WrapNativeParent(cx, p);
     if (!obj) {
       return nullptr;
     }
   }
   // But all that won't necessarily put things in the compartment of cx.
   if (!JS_WrapObject(cx, &obj)) {
     return nullptr;
   }
   return obj;
 }
 /*
  * This specialized function simply wraps a JS::Rooted<> since
  * WrapNativeParent() is not applicable for JS objects.
  */
 template<>
 inline JSObject*
 WrapCallThisObject<JS::Rooted<JSObject*>>(JSContext* cx,
                                           const JS::Rooted<JSObject*>& p)
 {
   JS::Rooted<JSObject*> obj(cx, p);
   if (!JS_WrapObject(cx, &obj)) {
     return nullptr;
   }
   return obj;
 }
 // Helper for calling WrapNewBindingObject with smart pointers
 // (nsAutoPtr/nsRefPtr/nsCOMPtr) or references.
 template <class T, bool isSmartPtr=HasgetMember<T>::Value>
 struct WrapNewBindingObjectHelper
 {
   static inline bool Wrap(JSContext* cx, const T& value,
                           JS::MutableHandle<JS::Value> rval)
   {
     return WrapNewBindingObject(cx, value.get(), rval);
   }
 };
 template <class T>
 struct WrapNewBindingObjectHelper<T, false>
 {
   static inline bool Wrap(JSContext* cx, T& value,
                           JS::MutableHandle<JS::Value> rval)
   {
     return WrapNewBindingObject(cx, &value, rval);
   }
 };
 template<class T>
 inline bool
 WrapNewBindingObject(JSContext* cx, T& value, JS::MutableHandle<JS::Value> rval)
 {
   return WrapNewBindingObjectHelper<T>::Wrap(cx, value, rval);
 }
 // We need this version of WrapNewBindingObject for codegen, so it'll have the
 // same signature as WrapNewBindingNonWrapperCachedObject and
 // WrapNewBindingNonWrapperCachedOwnedObject, which still need the scope.
 template<class T>
 inline bool
 WrapNewBindingObject(JSContext* cx, JS::Handle<JSObject*> scope, T& value,
                      JS::MutableHandle<JS::Value> rval)
 {
   return WrapNewBindingObject(cx, value, rval);
 }
 template <class T>
 inline JSObject*
 GetCallbackFromCallbackObject(T* aObj)
 {
   return aObj->Callback();
 }
 // Helper for getting the callback JSObject* of a smart ptr around a
 // CallbackObject or a reference to a CallbackObject or something like
 // that.
 template <class T, bool isSmartPtr=HasgetMember<T>::Value>
 struct GetCallbackFromCallbackObjectHelper
 {
   static inline JSObject* Get(const T& aObj)
   {
     return GetCallbackFromCallbackObject(aObj.get());
   }
 };
 template <class T>
 struct GetCallbackFromCallbackObjectHelper<T, false>
 {
   static inline JSObject* Get(T& aObj)
   {
     return GetCallbackFromCallbackObject(&aObj);
   }
 };
 template<class T>
 inline JSObject*
 GetCallbackFromCallbackObject(T& aObj)
 {
   return GetCallbackFromCallbackObjectHelper<T>::Get(aObj);
 }
 static inline bool
 InternJSString(JSContext* cx, jsid& id, const char* chars)
 {
   if (JSString *str = ::JS_InternString(cx, chars)) {
     id = INTERNED_STRING_TO_JSID(cx, str);
     return true;
   }
   return false;
 }
 // Spec needs a name property
 template <typename Spec>
 static bool
 InitIds(JSContext* cx, const Prefable<Spec>* prefableSpecs, jsid* ids)
 {
   MOZ_ASSERT(prefableSpecs);
   MOZ_ASSERT(prefableSpecs->specs);
   do {
     // We ignore whether the set of ids is enabled and just intern all the IDs,
     // because this is only done once per application runtime.
     Spec* spec = prefableSpecs->specs;
     do {
       if (!InternJSString(cx, *ids, spec->name)) {
         return false;
       }
     } while (++ids, (++spec)->name);
     // We ran out of ids for that pref.  Put a JSID_VOID in on the id
     // corresponding to the list terminator for the pref.
     *ids = JSID_VOID;
     ++ids;
   } while ((++prefableSpecs)->specs);
   return true;
 }
 bool
 QueryInterface(JSContext* cx, unsigned argc, JS::Value* vp);
 template <class T>
 struct
 WantsQueryInterface
 {
   static_assert(IsBaseOf<nsISupports, T>::value,
                 "QueryInterface can't work without an nsISupports.");
   static bool Enabled(JSContext* aCx, JSObject* aGlobal)
   {
     return NS_IsMainThread() && IsChromeOrXBL(aCx, aGlobal);
   }
 };
 void
 GetInterfaceImpl(JSContext* aCx, nsIInterfaceRequestor* aRequestor,
                  nsWrapperCache* aCache, nsIJSID* aIID,
                  JS::MutableHandle<JS::Value> aRetval, ErrorResult& aError);
 template<class T>
 void
 GetInterface(JSContext* aCx, T* aThis, nsIJSID* aIID,
              JS::MutableHandle<JS::Value> aRetval, ErrorResult& aError)
 {
   GetInterfaceImpl(aCx, aThis, aThis, aIID, aRetval, aError);
 }
 bool
 ThrowingConstructor(JSContext* cx, unsigned argc, JS::Value* vp);
 bool
 ThrowConstructorWithoutNew(JSContext* cx, const char* name);
 // vp is allowed to be null; in that case no get will be attempted,
 // and *found will simply indicate whether the property exists.
 bool
 GetPropertyOnPrototype(JSContext* cx, JS::Handle<JSObject*> proxy,
                        JS::Handle<jsid> id, bool* found,
                        JS::Value* vp);
 bool
 HasPropertyOnPrototype(JSContext* cx, JS::Handle<JSObject*> proxy,
                        JS::Handle<jsid> id);
 // Append the property names in "names" to "props". If
 // shadowPrototypeProperties is false then skip properties that are also
 // present on the proto chain of proxy.  If shadowPrototypeProperties is true,
 // then the "proxy" argument is ignored.
 bool
 AppendNamedPropertyIds(JSContext* cx, JS::Handle<JSObject*> proxy,
                        nsTArray<nsString>& names,
                        bool shadowPrototypeProperties, JS::AutoIdVector& props);
 namespace binding_detail {
 // A struct that has the same layout as an nsDependentString but much
 // faster constructor and destructor behavior
 struct FakeDependentString {
   FakeDependentString() :
     mFlags(nsDependentString::F_TERMINATED)
   {
   }
   void SetData(const nsDependentString::char_type* aData,
                nsDependentString::size_type aLength) {
     MOZ_ASSERT(mFlags == nsDependentString::F_TERMINATED);
     mData = aData;
     mLength = aLength;
   }
   void Truncate() {
     mData = nsDependentString::char_traits::sEmptyBuffer;
     mLength = 0;
   }
   void SetNull() {
     Truncate();
     mFlags |= nsDependentString::F_VOIDED;
   }
   const nsDependentString::char_type* Data() const
   {
     return mData;
   }
   nsDependentString::size_type Length() const
   {
     return mLength;
   }
   // If this ever changes, change the corresponding code in the
   // Optional<nsAString> specialization as well.
   const nsAString* ToAStringPtr() const {
     return reinterpret_cast<const nsDependentString*>(this);
   }
   nsAString* ToAStringPtr() {
     return reinterpret_cast<nsDependentString*>(this);
   }
   operator const nsAString& () const {
     return *reinterpret_cast<const nsDependentString*>(this);
   }
 private:
   const nsDependentString::char_type* mData;
   nsDependentString::size_type mLength;
   uint32_t mFlags;
   // A class to use for our static asserts to ensure our object layout
   // matches that of nsDependentString.
   class DependentStringAsserter;
   friend class DependentStringAsserter;
   class DepedentStringAsserter : public nsDependentString {
   public:
     static void StaticAsserts() {
       static_assert(sizeof(FakeDependentString) == sizeof(nsDependentString),
                     "Must have right object size");
       static_assert(offsetof(FakeDependentString, mData) ==
                       offsetof(DepedentStringAsserter, mData),
                     "Offset of mData should match");
       static_assert(offsetof(FakeDependentString, mLength) ==
                       offsetof(DepedentStringAsserter, mLength),
                     "Offset of mLength should match");
       static_assert(offsetof(FakeDependentString, mFlags) ==
                       offsetof(DepedentStringAsserter, mFlags),
                     "Offset of mFlags should match");
     }
   };
 };
 } // namespace binding_detail
 enum StringificationBehavior {
   eStringify,
   eEmpty,
   eNull
 };
 // pval must not be null and must point to a rooted JS::Value
 static inline bool
 ConvertJSValueToString(JSContext* cx, JS::Handle<JS::Value> v,
                        JS::MutableHandle<JS::Value> pval,
                        StringificationBehavior nullBehavior,
                        StringificationBehavior undefinedBehavior,
                        binding_detail::FakeDependentString& result)
 {
   JSString *s;
   if (v.isString()) {
     s = v.toString();
   } else {
     StringificationBehavior behavior;
     if (v.isNull()) {
       behavior = nullBehavior;
     } else if (v.isUndefined()) {
       behavior = undefinedBehavior;
     } else {
       behavior = eStringify;
     }
     if (behavior != eStringify) {
       if (behavior == eEmpty) {
         result.Truncate();
       } else {
         result.SetNull();
       }
       return true;
     }
     s = JS::ToString(cx, v);
     if (!s) {
       return false;
     }
     pval.set(JS::StringValue(s));  // Root the new string.
   }
   size_t len;
   const jschar *chars = JS_GetStringCharsZAndLength(cx, s, &len);
   if (!chars) {
     return false;
   }
   result.SetData(chars, len);
   return true;
 }
 bool
 ConvertJSValueToByteString(JSContext* cx, JS::Handle<JS::Value> v,
                            JS::MutableHandle<JS::Value> pval, bool nullable,
                            nsACString& result);
 template<typename T>
 void DoTraceSequence(JSTracer* trc, FallibleTArray<T>& seq);
 template<typename T>
 void DoTraceSequence(JSTracer* trc, InfallibleTArray<T>& seq);
 // Class for simple sequence arguments, only used internally by codegen.
 namespace binding_detail {
 template<typename T>
 class AutoSequence : public AutoFallibleTArray<T, 16>
 {
 public:
   AutoSequence() : AutoFallibleTArray<T, 16>()
   {}
   // Allow converting to const sequences as needed
   operator const Sequence<T>&() const {
     return *reinterpret_cast<const Sequence<T>*>(this);
   }
 };
 } // namespace binding_detail
 // Class used to trace sequences, with specializations for various
 // sequence types.
 template<typename T,
          bool isDictionary=IsBaseOf<DictionaryBase, T>::value,
          bool isTypedArray=IsBaseOf<AllTypedArraysBase, T>::value,
          bool isOwningUnion=IsBaseOf<AllOwningUnionBase, T>::value>
 class SequenceTracer
 {
   explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
 };
 // sequence<object> or sequence<object?>
 template<>
 class SequenceTracer<JSObject*, false, false, false>
 {
   explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
 public:
   static void TraceSequence(JSTracer* trc, JSObject** objp, JSObject** end) {
     for (; objp != end; ++objp) {
       JS_CallObjectTracer(trc, objp, "sequence<object>");
     }
   }
 };
 // sequence<any>
 template<>
 class SequenceTracer<JS::Value, false, false, false>
 {
   explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
 public:
   static void TraceSequence(JSTracer* trc, JS::Value* valp, JS::Value* end) {
     for (; valp != end; ++valp) {
       JS_CallValueTracer(trc, valp, "sequence<any>");
     }
   }
 };
 // sequence<sequence<T>>
 template<typename T>
 class SequenceTracer<Sequence<T>, false, false, false>
 {
   explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
 public:
   static void TraceSequence(JSTracer* trc, Sequence<T>* seqp, Sequence<T>* end) {
     for (; seqp != end; ++seqp) {
       DoTraceSequence(trc, *seqp);
     }
   }
 };
 // sequence<sequence<T>> as return value
 template<typename T>
 class SequenceTracer<nsTArray<T>, false, false, false>
 {
   explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
 public:
   static void TraceSequence(JSTracer* trc, nsTArray<T>* seqp, nsTArray<T>* end) {
     for (; seqp != end; ++seqp) {
       DoTraceSequence(trc, *seqp);
     }
   }
 };
 // sequence<someDictionary>
 template<typename T>
 class SequenceTracer<T, true, false, false>
 {
   explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
 public:
   static void TraceSequence(JSTracer* trc, T* dictp, T* end) {
     for (; dictp != end; ++dictp) {
       dictp->TraceDictionary(trc);
     }
   }
 };
 // sequence<SomeTypedArray>
 template<typename T>
 class SequenceTracer<T, false, true, false>
 {
   explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
 public:
   static void TraceSequence(JSTracer* trc, T* arrayp, T* end) {
     for (; arrayp != end; ++arrayp) {
       arrayp->TraceSelf(trc);
     }
   }
 };
 // sequence<SomeOwningUnion>
 template<typename T>
 class SequenceTracer<T, false, false, true>
 {
   explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
 public:
   static void TraceSequence(JSTracer* trc, T* arrayp, T* end) {
     for (; arrayp != end; ++arrayp) {
       arrayp->TraceUnion(trc);
     }
   }
 };
 // sequence<T?> with T? being a Nullable<T>
 template<typename T>
 class SequenceTracer<Nullable<T>, false, false, false>
 {
   explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
 public:
   static void TraceSequence(JSTracer* trc, Nullable<T>* seqp,
                             Nullable<T>* end) {
     for (; seqp != end; ++seqp) {
       if (!seqp->IsNull()) {
         // Pretend like we actually have a length-one sequence here so
         // we can do template instantiation correctly for T.
         T& val = seqp->Value();
         T* ptr = &val;
         SequenceTracer<T>::TraceSequence(trc, ptr, ptr+1);
       }
     }
   }
 };
 // XXXbz It's not clear whether it's better to add a pldhash dependency here
 // (for PLDHashOperator) or add a BindingUtils.h dependency (for
 // SequenceTracer) to MozMap.h...
 template<typename T>
 static PLDHashOperator
 TraceMozMapValue(T* aValue, void* aClosure)
 {
   JSTracer* trc = static_cast<JSTracer*>(aClosure);
   // Act like it's a one-element sequence to leverage all that infrastructure.
   SequenceTracer<T>::TraceSequence(trc, aValue, aValue + 1);
   return PL_DHASH_NEXT;
 }
 // sequence<MozMap>
 template<typename T>
 class SequenceTracer<MozMap<T>, false, false, false>
 {
   explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
 public:
   static void TraceSequence(JSTracer* trc, MozMap<T>* seqp, MozMap<T>* end) {
     for (; seqp != end; ++seqp) {
       seqp->EnumerateValues(TraceMozMapValue<T>, trc);
     }
   }
 };
 template<typename T>
 void DoTraceSequence(JSTracer* trc, FallibleTArray<T>& seq)
 {
   SequenceTracer<T>::TraceSequence(trc, seq.Elements(),
                                    seq.Elements() + seq.Length());
 }
 template<typename T>
 void DoTraceSequence(JSTracer* trc, InfallibleTArray<T>& seq)
 {
   SequenceTracer<T>::TraceSequence(trc, seq.Elements(),
                                    seq.Elements() + seq.Length());
 }
 // Rooter class for sequences; this is what we mostly use in the codegen
 template<typename T>
 class MOZ_STACK_CLASS SequenceRooter : private JS::CustomAutoRooter
 {
 public:
   SequenceRooter(JSContext *aCx, FallibleTArray<T>* aSequence
                  MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
     : JS::CustomAutoRooter(aCx MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT),
       mFallibleArray(aSequence),
       mSequenceType(eFallibleArray)
   {
   }
   SequenceRooter(JSContext *aCx, InfallibleTArray<T>* aSequence
                  MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
     : JS::CustomAutoRooter(aCx MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT),
       mInfallibleArray(aSequence),
       mSequenceType(eInfallibleArray)
   {
   }
   SequenceRooter(JSContext *aCx, Nullable<nsTArray<T> >* aSequence
                  MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
     : JS::CustomAutoRooter(aCx MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT),
       mNullableArray(aSequence),
       mSequenceType(eNullableArray)
   {
   }
  private:
   enum SequenceType {
     eInfallibleArray,
     eFallibleArray,
     eNullableArray
   };
   virtual void trace(JSTracer *trc) MOZ_OVERRIDE
   {
     if (mSequenceType == eFallibleArray) {
       DoTraceSequence(trc, *mFallibleArray);
     } else if (mSequenceType == eInfallibleArray) {
       DoTraceSequence(trc, *mInfallibleArray);
     } else {
       MOZ_ASSERT(mSequenceType == eNullableArray);
       if (!mNullableArray->IsNull()) {
         DoTraceSequence(trc, mNullableArray->Value());
       }
     }
   }
   union {
     InfallibleTArray<T>* mInfallibleArray;
     FallibleTArray<T>* mFallibleArray;
     Nullable<nsTArray<T> >* mNullableArray;
   };
   SequenceType mSequenceType;
 };
 // Rooter class for MozMap; this is what we mostly use in the codegen.
 template<typename T>
 class MOZ_STACK_CLASS MozMapRooter : private JS::CustomAutoRooter
 {
 public:
   MozMapRooter(JSContext *aCx, MozMap<T>* aMozMap
                MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
     : JS::CustomAutoRooter(aCx MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT),
       mMozMap(aMozMap),
       mMozMapType(eMozMap)
   {
   }
   MozMapRooter(JSContext *aCx, Nullable<MozMap<T>>* aMozMap
                  MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
     : JS::CustomAutoRooter(aCx MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT),
       mNullableMozMap(aMozMap),
       mMozMapType(eNullableMozMap)
   {
   }
 private:
   enum MozMapType {
     eMozMap,
     eNullableMozMap
   };
   virtual void trace(JSTracer *trc) MOZ_OVERRIDE
   {
     MozMap<T>* mozMap;
     if (mMozMapType == eMozMap) {
       mozMap = mMozMap;
     } else {
       MOZ_ASSERT(mMozMapType == eNullableMozMap);
       if (mNullableMozMap->IsNull()) {
         // Nothing to do
         return;
       }
       mozMap = &mNullableMozMap->Value();
     }
     mozMap->EnumerateValues(TraceMozMapValue<T>, trc);
   }
   union {
     MozMap<T>* mMozMap;
     Nullable<MozMap<T>>* mNullableMozMap;
   };
   MozMapType mMozMapType;
 };
 template<typename T>
 class MOZ_STACK_CLASS RootedUnion : public T,
                                     private JS::CustomAutoRooter
 {
 public:
   RootedUnion(JSContext* cx MOZ_GUARD_OBJECT_NOTIFIER_PARAM) :
     T(),
     JS::CustomAutoRooter(cx MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT)
   {
   }
   virtual void trace(JSTracer *trc) MOZ_OVERRIDE
   {
     this->TraceUnion(trc);
   }
 };
 template<typename T>
 class MOZ_STACK_CLASS NullableRootedUnion : public Nullable<T>,
                                             private JS::CustomAutoRooter
 {
 public:
   NullableRootedUnion(JSContext* cx MOZ_GUARD_OBJECT_NOTIFIER_PARAM) :
     Nullable<T>(),
     JS::CustomAutoRooter(cx MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT)
   {
   }
   virtual void trace(JSTracer *trc) MOZ_OVERRIDE
   {
     if (!this->IsNull()) {
       this->Value().TraceUnion(trc);
     }
   }
 };
 inline bool
 IdEquals(jsid id, const char* string)
 {
   return JSID_IS_STRING(id) &&
          JS_FlatStringEqualsAscii(JSID_TO_FLAT_STRING(id), string);
 }
 inline bool
 AddStringToIDVector(JSContext* cx, JS::AutoIdVector& vector, const char* name)
 {
   return vector.growBy(1) &&
          InternJSString(cx, vector[vector.length() - 1], name);
 }
 // Implementation of the bits that XrayWrapper needs
 /**
  * This resolves indexed or named properties of obj.
  *
  * wrapper is the Xray JS object.
  * obj is the target object of the Xray, a binding's instance object or a
  *     interface or interface prototype object.
  */
 bool
 XrayResolveOwnProperty(JSContext* cx, JS::Handle<JSObject*> wrapper,
                        JS::Handle<JSObject*> obj,
                        JS::Handle<jsid> id,
                        JS::MutableHandle<JSPropertyDescriptor> desc);
 /**
  * This resolves operations, attributes and constants of the interfaces for obj.
  *
  * wrapper is the Xray JS object.
  * obj is the target object of the Xray, a binding's instance object or a
  *     interface or interface prototype object.
  */
 bool
 XrayResolveNativeProperty(JSContext* cx, JS::Handle<JSObject*> wrapper,
                           JS::Handle<JSObject*> obj,
                           JS::Handle<jsid> id, JS::MutableHandle<JSPropertyDescriptor> desc);
 /**
  * Define a property on obj through an Xray wrapper.
  *
  * wrapper is the Xray JS object.
  * obj is the target object of the Xray, a binding's instance object or a
  *     interface or interface prototype object.
  * defined will be set to true if a property was set as a result of this call.
  */
 bool
 XrayDefineProperty(JSContext* cx, JS::Handle<JSObject*> wrapper,
                    JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
                    JS::MutableHandle<JSPropertyDescriptor> desc, bool* defined);
 /**
  * This enumerates indexed or named properties of obj and operations, attributes
  * and constants of the interfaces for obj.
  *
  * wrapper is the Xray JS object.
  * obj is the target object of the Xray, a binding's instance object or a
  *     interface or interface prototype object.
  * flags are JSITER_* flags.
  */
 bool
 XrayEnumerateProperties(JSContext* cx, JS::Handle<JSObject*> wrapper,
                         JS::Handle<JSObject*> obj,
                         unsigned flags, JS::AutoIdVector& props);
 extern NativePropertyHooks sWorkerNativePropertyHooks;
 // We use one constructor JSNative to represent all DOM interface objects (so
 // we can easily detect when we need to wrap them in an Xray wrapper). We store
 // the real JSNative in the mNative member of a JSNativeHolder in the
 // CONSTRUCTOR_NATIVE_HOLDER_RESERVED_SLOT slot of the JSFunction object for a
 // specific interface object. We also store the NativeProperties in the
 // JSNativeHolder.
 // Note that some interface objects are not yet a JSFunction but a normal
 // JSObject with a DOMJSClass, those do not use these slots.
 enum {
   CONSTRUCTOR_NATIVE_HOLDER_RESERVED_SLOT = 0
 };
 bool
 Constructor(JSContext* cx, unsigned argc, JS::Value* vp);
 inline bool
 UseDOMXray(JSObject* obj)
 {
   const js::Class* clasp = js::GetObjectClass(obj);
   return IsDOMClass(clasp) ||
          JS_IsNativeFunction(obj, Constructor) ||
          IsDOMIfaceAndProtoClass(clasp);
 }
 #ifdef DEBUG
 inline bool
 HasConstructor(JSObject* obj)
 {
   return JS_IsNativeFunction(obj, Constructor) ||
          js::GetObjectClass(obj)->construct;
 }
  #endif
 // Transfer reference in ptr to smartPtr.
 template<class T>
 inline void
 Take(nsRefPtr<T>& smartPtr, T* ptr)
 {
   smartPtr = dont_AddRef(ptr);
 }
 // Transfer ownership of ptr to smartPtr.
 template<class T>
 inline void
 Take(nsAutoPtr<T>& smartPtr, T* ptr)
 {
   smartPtr = ptr;
 }
 inline void
 MustInheritFromNonRefcountedDOMObject(NonRefcountedDOMObject*)
 {
 }
 /**
  * This creates a JSString containing the value that the toString function for
  * obj should create according to the WebIDL specification, ignoring any
  * modifications by script. The value is prefixed with pre and postfixed with
  * post, unless this is called for an object that has a stringifier. It is
  * specifically for use by Xray code.
  *
  * wrapper is the Xray JS object.
  * obj is the target object of the Xray, a binding's instance object or a
  *     interface or interface prototype object.
  * pre is a string that should be prefixed to the value.
  * post is a string that should be prefixed to the value.
  * v contains the JSString for the value if the function returns true.
  */
 bool
 NativeToString(JSContext* cx, JS::Handle<JSObject*> wrapper,
                JS::Handle<JSObject*> obj, const char* pre,
                const char* post,
                JS::MutableHandle<JS::Value> v);
 HAS_MEMBER(JSBindingFinalized)
 template<class T, bool hasCallback=HasJSBindingFinalizedMember<T>::Value>
 struct JSBindingFinalized
 {
   static void Finalized(T* self)
   {
   }
 };
 template<class T>
 struct JSBindingFinalized<T, true>
 {
   static void Finalized(T* self)
   {
     self->JSBindingFinalized();
   }
 };
 // Helpers for creating a const version of a type.
 template<typename T>
 const T& Constify(T& arg)
 {
   return arg;
 }
 // Helper for turning (Owning)NonNull<T> into T&
 template<typename T>
 T& NonNullHelper(T& aArg)
 {
   return aArg;
 }
 template<typename T>
 T& NonNullHelper(NonNull<T>& aArg)
 {
   return aArg;
 }
 template<typename T>
 const T& NonNullHelper(const NonNull<T>& aArg)
 {
   return aArg;
 }
 template<typename T>
 T& NonNullHelper(OwningNonNull<T>& aArg)
 {
   return aArg;
 }
 template<typename T>
 const T& NonNullHelper(const OwningNonNull<T>& aArg)
 {
   return aArg;
 }
 inline
 void NonNullHelper(NonNull<binding_detail::FakeDependentString>& aArg)
 {
   // This overload is here to make sure that we never end up applying
   // NonNullHelper to a NonNull<binding_detail::FakeDependentString>. If we
   // try to, it should fail to compile, since presumably the caller will try to
   // use our nonexistent return value.
 }
 inline
 void NonNullHelper(const NonNull<binding_detail::FakeDependentString>& aArg)
 {
   // This overload is here to make sure that we never end up applying
   // NonNullHelper to a NonNull<binding_detail::FakeDependentString>. If we
   // try to, it should fail to compile, since presumably the caller will try to
   // use our nonexistent return value.
 }
 inline
 void NonNullHelper(binding_detail::FakeDependentString& aArg)
 {
   // This overload is here to make sure that we never end up applying
   // NonNullHelper to a FakeDependentString before we've constified it.  If we
   // try to, it should fail to compile, since presumably the caller will try to
   // use our nonexistent return value.
 }
 MOZ_ALWAYS_INLINE
 const nsAString& NonNullHelper(const binding_detail::FakeDependentString& aArg)
 {
   return aArg;
 }
 // Reparent the wrapper of aObj to whatever its native now thinks its
 // parent should be.
 nsresult
 ReparentWrapper(JSContext* aCx, JS::Handle<JSObject*> aObj);
 /**
  * Used to implement the hasInstance hook of an interface object.
  *
  * instance should not be a security wrapper.
  */
 bool
 InterfaceHasInstance(JSContext* cx, JS::Handle<JSObject*> obj,
                      JS::Handle<JSObject*> instance,
                      bool* bp);
 bool
 InterfaceHasInstance(JSContext* cx, JS::Handle<JSObject*> obj, JS::MutableHandle<JS::Value> vp,
                      bool* bp);
 bool
 InterfaceHasInstance(JSContext* cx, int prototypeID, int depth,
                      JS::Handle<JSObject*> instance,
                      bool* bp);
 // Helper for lenient getters/setters to report to console.  If this
 // returns false, we couldn't even get a global.
 bool
 ReportLenientThisUnwrappingFailure(JSContext* cx, JSObject* obj);
 inline JSObject*
 GetUnforgeableHolder(JSObject* aGlobal, prototypes::ID aId)
 {
   ProtoAndIfaceCache& protoAndIfaceCache = *GetProtoAndIfaceCache(aGlobal);
   JSObject* interfaceProto = protoAndIfaceCache.EntrySlotMustExist(aId);
   return &js::GetReservedSlot(interfaceProto,
                               DOM_INTERFACE_PROTO_SLOTS_BASE).toObject();
 }
 // Given a JSObject* that represents the chrome side of a JS-implemented WebIDL
 // interface, get the nsPIDOMWindow corresponding to the content side, if any.
 // A false return means an exception was thrown.
 bool
 GetWindowForJSImplementedObject(JSContext* cx, JS::Handle<JSObject*> obj,
                                 nsPIDOMWindow** window);
 void
 ConstructJSImplementation(JSContext* aCx, const char* aContractId,
                           nsPIDOMWindow* aWindow,
                           JS::MutableHandle<JSObject*> aObject,
                           ErrorResult& aRv);
 already_AddRefed<nsPIDOMWindow>
 ConstructJSImplementation(JSContext* aCx, const char* aContractId,
                           const GlobalObject& aGlobal,
                           JS::MutableHandle<JSObject*> aObject,
                           ErrorResult& aRv);
 /**
  * Convert an nsCString to jsval, returning true on success.
  * These functions are intended for ByteString implementations.
  * As such, the string is not UTF-8 encoded.  Any UTF8 strings passed to these
  * methods will be mangled.
  */
 bool NonVoidByteStringToJsval(JSContext *cx, const nsACString &str,
                               JS::MutableHandle<JS::Value> rval);
 inline bool ByteStringToJsval(JSContext *cx, const nsACString &str,
                               JS::MutableHandle<JS::Value> rval)
 {
     if (str.IsVoid()) {
         rval.setNull();
         return true;
     }
     return NonVoidByteStringToJsval(cx, str, rval);
 }
 template<class T, bool isISupports=IsBaseOf<nsISupports, T>::value>
 struct PreserveWrapperHelper
 {
   static void PreserveWrapper(T* aObject)
   {
     aObject->PreserveWrapper(aObject, NS_CYCLE_COLLECTION_PARTICIPANT(T));
   }
 };
 template<class T>
 struct PreserveWrapperHelper<T, true>
 {
   static void PreserveWrapper(T* aObject)
   {
     aObject->PreserveWrapper(reinterpret_cast<nsISupports*>(aObject));
   }
 };
 template<class T>
 void PreserveWrapper(T* aObject)
 {
   PreserveWrapperHelper<T>::PreserveWrapper(aObject);
 }
 template<class T, bool isISupports=IsBaseOf<nsISupports, T>::value>
 struct CastingAssertions
 {
   static bool ToSupportsIsCorrect(T*)
   {
     return true;
   }
   static bool ToSupportsIsOnPrimaryInheritanceChain(T*, nsWrapperCache*)
   {
     return true;
   }
 };
 template<class T>
 struct CastingAssertions<T, true>
 {
   static bool ToSupportsIsCorrect(T* aObject)
   {
     return ToSupports(aObject) ==  reinterpret_cast<nsISupports*>(aObject);
   }
   static bool ToSupportsIsOnPrimaryInheritanceChain(T* aObject,
                                                     nsWrapperCache* aCache)
   {
     return reinterpret_cast<void*>(aObject) != aCache;
   }
 };
 template<class T>
 bool
 ToSupportsIsCorrect(T* aObject)
 {
   return CastingAssertions<T>::ToSupportsIsCorrect(aObject);
 }
 template<class T>
 bool
 ToSupportsIsOnPrimaryInheritanceChain(T* aObject, nsWrapperCache* aCache)
 {
   return CastingAssertions<T>::ToSupportsIsOnPrimaryInheritanceChain(aObject,
                                                                      aCache);
 }
 template<class T, template <typename> class SmartPtr,
          bool isISupports=IsBaseOf<nsISupports, T>::value>
 class DeferredFinalizer
 {
   typedef nsTArray<SmartPtr<T> > SmartPtrArray;
   static void*
   AppendDeferredFinalizePointer(void* aData, void* aObject)
   {
     SmartPtrArray* pointers = static_cast<SmartPtrArray*>(aData);
     if (!pointers) {
       pointers = new SmartPtrArray();
     }
     T* self = static_cast<T*>(aObject);
     SmartPtr<T>* defer = pointers->AppendElement();
     Take(*defer, self);
     return pointers;
   }
   static bool
   DeferredFinalize(uint32_t aSlice, void* aData)
   {
     MOZ_ASSERT(aSlice > 0, "nonsensical/useless call with aSlice == 0");
     SmartPtrArray* pointers = static_cast<SmartPtrArray*>(aData);
     uint32_t oldLen = pointers->Length();
     if (oldLen < aSlice) {
       aSlice = oldLen;
     }
     uint32_t newLen = oldLen - aSlice;
     pointers->RemoveElementsAt(newLen, aSlice);
     if (newLen == 0) {
       delete pointers;
       return true;
     }
     return false;
   }
 public:
   static void
   AddForDeferredFinalization(T* aObject)
   {
     cyclecollector::DeferredFinalize(AppendDeferredFinalizePointer,
                                      DeferredFinalize, aObject);
   }
 };
 template<class T, template <typename> class SmartPtr>
 class DeferredFinalizer<T, SmartPtr, true>
 {
 public:
   static void
   AddForDeferredFinalization(T* aObject)
   {
     cyclecollector::DeferredFinalize(reinterpret_cast<nsISupports*>(aObject));
   }
 };
 template<class T, template <typename> class SmartPtr>
 static void
 AddForDeferredFinalization(T* aObject)
 {
   DeferredFinalizer<T, SmartPtr>::AddForDeferredFinalization(aObject);
 }
 // This returns T's CC participant if it participates in CC or null if it
 // doesn't. This also returns null for classes that don't inherit from
 // nsISupports (QI should be used to get the participant for those).
 template<class T, bool isISupports=IsBaseOf<nsISupports, T>::value>
 class GetCCParticipant
 {
   // Helper for GetCCParticipant for classes that participate in CC.
   template<class U>
   static MOZ_CONSTEXPR nsCycleCollectionParticipant*
   GetHelper(int, typename U::NS_CYCLE_COLLECTION_INNERCLASS* dummy=nullptr)
   {
     return T::NS_CYCLE_COLLECTION_INNERCLASS::GetParticipant();
   }
   // Helper for GetCCParticipant for classes that don't participate in CC.
   template<class U>
   static MOZ_CONSTEXPR nsCycleCollectionParticipant*
   GetHelper(double)
   {
     return nullptr;
   }
 public:
   static MOZ_CONSTEXPR nsCycleCollectionParticipant*
   Get()
   {
     // Passing int() here will try to call the GetHelper that takes an int as
     // its firt argument. If T doesn't participate in CC then substitution for
     // the second argument (with a default value) will fail and because of
     // SFINAE the next best match (the variant taking a double) will be called.
     return GetHelper<T>(int());
   }
 };
 template<class T>
 class GetCCParticipant<T, true>
 {
 public:
   static MOZ_CONSTEXPR nsCycleCollectionParticipant*
   Get()
   {
     return nullptr;
   }
 };
 /*
  * Helper function for testing whether the given object comes from a
  * privileged app.
  */
 bool
 IsInPrivilegedApp(JSContext* aCx, JSObject* aObj);
 /*
  * Helper function for testing whether the given object comes from a
  * certified app.
  */
 bool
 IsInCertifiedApp(JSContext* aCx, JSObject* aObj);
 void
 TraceGlobal(JSTracer* aTrc, JSObject* aObj);
 void
 FinalizeGlobal(JSFreeOp* aFop, JSObject* aObj);
 bool
 ResolveGlobal(JSContext* aCx, JS::Handle<JSObject*> aObj,
               JS::Handle<jsid> aId, JS::MutableHandle<JSObject*> aObjp);
 bool
 EnumerateGlobal(JSContext* aCx, JS::Handle<JSObject*> aObj);
 template <class T, JS::Handle<JSObject*> (*ProtoGetter)(JSContext*,
                                                         JS::Handle<JSObject*>)>
 JSObject*
 CreateGlobal(JSContext* aCx, T* aObject, nsWrapperCache* aCache,
              const JSClass* aClass, JS::CompartmentOptions& aOptions,
              JSPrincipals* aPrincipal)
 {
   MOZ_ASSERT(!NS_IsMainThread());
   aOptions.setTrace(TraceGlobal);
   JS::Rooted<JSObject*> global(aCx,
     JS_NewGlobalObject(aCx, aClass, aPrincipal, JS::DontFireOnNewGlobalHook,
                        aOptions));
   if (!global) {
     NS_WARNING("Failed to create global");
     return nullptr;
   }
   JSAutoCompartment ac(aCx, global);
   dom::AllocateProtoAndIfaceCache(global, ProtoAndIfaceCache::WindowLike);
   js::SetReservedSlot(global, DOM_OBJECT_SLOT, PRIVATE_TO_JSVAL(aObject));
   NS_ADDREF(aObject);
   aCache->SetIsDOMBinding();
   aCache->SetWrapper(global);
   /* Intl API is broken and makes this fail intermittently, see bug 934889.
   if (!JS_InitStandardClasses(aCx, global)) {
     NS_WARNING("Failed to init standard classes");
     return nullptr;
   }
   */
   JS::Handle<JSObject*> proto = ProtoGetter(aCx, global);
   NS_ENSURE_TRUE(proto, nullptr);
   if (!JS_SetPrototype(aCx, global, proto)) {
     NS_WARNING("Failed to set proto");
     return nullptr;
   }
   MOZ_ALWAYS_TRUE(TryPreserveWrapper(global));
   MOZ_ASSERT(UnwrapDOMObjectToISupports(global));
   return global;
 }
 /*
  * Holds a jsid that is initialized to an interned string, with conversion to
  * Handle<jsid>.
  */
 class InternedStringId
 {
   jsid id;
  public:
   InternedStringId() : id(JSID_VOID) {}
   bool init(JSContext *cx, const char *string) {
     JSString* str = JS_InternString(cx, string);
     if (!str)
       return false;
     id = INTERNED_STRING_TO_JSID(cx, str);
     return true;
   }
   operator const jsid& () {
     return id;
   }
   operator JS::Handle<jsid> () {
     /* This is safe because we have interned the string. */
     return JS::Handle<jsid>::fromMarkedLocation(&id);
   }
 };
 bool
 GenericBindingGetter(JSContext* cx, unsigned argc, JS::Value* vp);
 bool
 GenericBindingSetter(JSContext* cx, unsigned argc, JS::Value* vp);
 bool
 GenericBindingMethod(JSContext* cx, unsigned argc, JS::Value* vp);
 bool
 GenericPromiseReturningBindingMethod(JSContext* cx, unsigned argc, JS::Value* vp);
 bool
 StaticMethodPromiseWrapper(JSContext* cx, unsigned argc, JS::Value* vp);
 // ConvertExceptionToPromise should only be called when we have an error
 // condition (e.g. returned false from a JSAPI method).  Note that there may be
 // no exception on cx, in which case this is an uncatchable failure that will
 // simply be propagated.  Otherwise this method will attempt to convert the
 // exception to a Promise rejected with the exception that it will store in
 // rval.
 //
 // promiseScope should be the scope in which the Promise should be created.
 bool
 ConvertExceptionToPromise(JSContext* cx,
                           JSObject* promiseScope,
                           JS::MutableHandle<JS::Value> rval);
 } // namespace dom
 } // namespace mozilla
 #endif /* mozilla_dom_BindingUtils_h__ */

The Tor Browser / annotate

dom/bindings/BindingUtils.h@97036ab72558 (annotated)

dom/bindings/BindingUtils.h