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