summaryrefslogtreecommitdiffstats
path: root/dom/bindings/BindingUtils.h
diff options
context:
space:
mode:
Diffstat (limited to 'dom/bindings/BindingUtils.h')
-rw-r--r--dom/bindings/BindingUtils.h3441
1 files changed, 3441 insertions, 0 deletions
diff --git a/dom/bindings/BindingUtils.h b/dom/bindings/BindingUtils.h
new file mode 100644
index 000000000..3e58390c9
--- /dev/null
+++ b/dom/bindings/BindingUtils.h
@@ -0,0 +1,3441 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_dom_BindingUtils_h__
+#define mozilla_dom_BindingUtils_h__
+
+#include "jsfriendapi.h"
+#include "jswrapper.h"
+#include "js/Conversions.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/Alignment.h"
+#include "mozilla/Array.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/CycleCollectedJSContext.h"
+#include "mozilla/DeferredFinalize.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/CallbackObject.h"
+#include "mozilla/dom/DOMJSClass.h"
+#include "mozilla/dom/DOMJSProxyHandler.h"
+#include "mozilla/dom/Exceptions.h"
+#include "mozilla/dom/NonRefcountedDOMObject.h"
+#include "mozilla/dom/Nullable.h"
+#include "mozilla/dom/RootedDictionary.h"
+#include "mozilla/SegmentedVector.h"
+#include "mozilla/dom/workers/Workers.h"
+#include "mozilla/ErrorResult.h"
+#include "mozilla/Likely.h"
+#include "mozilla/MemoryReporting.h"
+#include "nsAutoPtr.h"
+#include "nsIDocument.h"
+#include "nsIGlobalObject.h"
+#include "nsIXPConnect.h"
+#include "nsJSUtils.h"
+#include "nsISupportsImpl.h"
+#include "qsObjectHelper.h"
+#include "xpcpublic.h"
+#include "nsIVariant.h"
+#include "mozilla/dom/FakeString.h"
+
+#include "nsWrapperCacheInlines.h"
+
+class nsIJSID;
+
+namespace mozilla {
+
+enum UseCounter : int16_t;
+
+namespace dom {
+template<typename DataType> class MozMap;
+
+nsresult
+UnwrapArgImpl(JS::Handle<JSObject*> src, const nsIID& iid, void** ppArg);
+
+nsresult
+UnwrapWindowProxyImpl(JS::Handle<JSObject*> src, nsPIDOMWindowOuter** ppArg);
+
+/** Convert a jsval to an XPCOM pointer. Caller must not assume that src will
+ keep the XPCOM pointer rooted. */
+template <class Interface>
+inline nsresult
+UnwrapArg(JS::Handle<JSObject*> src, Interface** ppArg)
+{
+ return UnwrapArgImpl(src, NS_GET_TEMPLATE_IID(Interface),
+ reinterpret_cast<void**>(ppArg));
+}
+
+template <>
+inline nsresult
+UnwrapArg<nsPIDOMWindowOuter>(JS::Handle<JSObject*> src, nsPIDOMWindowOuter** ppArg)
+{
+ return UnwrapWindowProxyImpl(src, ppArg);
+}
+
+nsresult
+UnwrapXPConnectImpl(JSContext* cx, JS::MutableHandle<JS::Value> src,
+ const nsIID& iid, void** ppArg);
+
+/*
+ * Convert a jsval being used as a Web IDL interface implementation to an XPCOM
+ * pointer; this is only used for Web IDL interfaces that specify
+ * hasXPConnectImpls. This is not the same as UnwrapArg because caller _can_
+ * assume that if unwrapping succeeds "val" will be updated so it's rooting the
+ * XPCOM pointer. Also, UnwrapXPConnect doesn't need to worry about doing
+ * XPCWrappedJS things.
+ *
+ * val must be an ObjectValue.
+ */
+template<class Interface>
+inline nsresult
+UnwrapXPConnect(JSContext* cx, JS::MutableHandle<JS::Value> val,
+ Interface** ppThis)
+{
+ return UnwrapXPConnectImpl(cx, val, NS_GET_TEMPLATE_IID(Interface),
+ reinterpret_cast<void**>(ppThis));
+}
+
+bool
+ThrowInvalidThis(JSContext* aCx, const JS::CallArgs& aArgs,
+ bool aSecurityError, const char* aInterfaceName);
+
+bool
+ThrowInvalidThis(JSContext* aCx, const JS::CallArgs& aArgs,
+ bool aSecurityError, prototypes::ID aProtoId);
+
+// Returns true if the JSClass is used for DOM objects.
+inline bool
+IsDOMClass(const JSClass* clasp)
+{
+ return clasp->flags & JSCLASS_IS_DOMJSCLASS;
+}
+
+inline bool
+IsDOMClass(const js::Class* clasp)
+{
+ return IsDOMClass(Jsvalify(clasp));
+}
+
+// Return true if the JSClass is used for non-proxy DOM objects.
+inline bool
+IsNonProxyDOMClass(const js::Class* clasp)
+{
+ return IsDOMClass(clasp) && !clasp->isProxy();
+}
+
+inline bool
+IsNonProxyDOMClass(const JSClass* clasp)
+{
+ return IsNonProxyDOMClass(js::Valueify(clasp));
+}
+
+// Returns true if the JSClass is used for DOM interface and interface
+// prototype objects.
+inline bool
+IsDOMIfaceAndProtoClass(const JSClass* clasp)
+{
+ return clasp->flags & JSCLASS_IS_DOMIFACEANDPROTOJSCLASS;
+}
+
+inline bool
+IsDOMIfaceAndProtoClass(const js::Class* clasp)
+{
+ return IsDOMIfaceAndProtoClass(Jsvalify(clasp));
+}
+
+static_assert(DOM_OBJECT_SLOT == 0,
+ "DOM_OBJECT_SLOT doesn't match the proxy private slot. "
+ "Expect bad things");
+template <class T>
+inline T*
+UnwrapDOMObject(JSObject* obj)
+{
+ MOZ_ASSERT(IsDOMClass(js::GetObjectClass(obj)),
+ "Don't pass non-DOM objects to this function");
+
+ JS::Value val = js::GetReservedOrProxyPrivateSlot(obj, DOM_OBJECT_SLOT);
+ return static_cast<T*>(val.toPrivate());
+}
+
+template <class T>
+inline T*
+UnwrapPossiblyNotInitializedDOMObject(JSObject* obj)
+{
+ // This is used by the OjectMoved JSClass hook which can be called before
+ // JS_NewObject has returned and so before we have a chance to set
+ // DOM_OBJECT_SLOT to anything useful.
+
+ MOZ_ASSERT(IsDOMClass(js::GetObjectClass(obj)),
+ "Don't pass non-DOM objects to this function");
+
+ JS::Value val = js::GetReservedOrProxyPrivateSlot(obj, DOM_OBJECT_SLOT);
+ if (val.isUndefined()) {
+ return nullptr;
+ }
+ return static_cast<T*>(val.toPrivate());
+}
+
+inline const DOMJSClass*
+GetDOMClass(const js::Class* clasp)
+{
+ return IsDOMClass(clasp) ? DOMJSClass::FromJSClass(clasp) : nullptr;
+}
+
+inline const DOMJSClass*
+GetDOMClass(JSObject* obj)
+{
+ return GetDOMClass(js::GetObjectClass(obj));
+}
+
+inline nsISupports*
+UnwrapDOMObjectToISupports(JSObject* aObject)
+{
+ const DOMJSClass* clasp = GetDOMClass(aObject);
+ if (!clasp || !clasp->mDOMObjectIsISupports) {
+ return nullptr;
+ }
+
+ return UnwrapPossiblyNotInitializedDOMObject<nsISupports>(aObject);
+}
+
+inline bool
+IsDOMObject(JSObject* obj)
+{
+ return IsDOMClass(js::GetObjectClass(obj));
+}
+
+// There are two valid ways to use UNWRAP_OBJECT: Either obj needs to
+// be a MutableHandle<JSObject*>, or value needs to be a strong-reference
+// smart pointer type (OwningNonNull or RefPtr or nsCOMPtr), in which case obj
+// can be anything that converts to JSObject*.
+#define UNWRAP_OBJECT(Interface, obj, value) \
+ mozilla::dom::UnwrapObject<mozilla::dom::prototypes::id::Interface, \
+ mozilla::dom::Interface##Binding::NativeType>(obj, value)
+
+// Test whether the given object is an instance of the given interface.
+#define IS_INSTANCE_OF(Interface, obj) \
+ mozilla::dom::IsInstanceOf<mozilla::dom::prototypes::id::Interface, \
+ mozilla::dom::Interface##Binding::NativeType>(obj)
+
+// Unwrap the given non-wrapper object. This can be used with any obj that
+// converts to JSObject*; as long as that JSObject* is live the return value
+// will be valid.
+#define UNWRAP_NON_WRAPPER_OBJECT(Interface, obj, value) \
+ mozilla::dom::UnwrapNonWrapperObject<mozilla::dom::prototypes::id::Interface, \
+ mozilla::dom::Interface##Binding::NativeType>(obj, value)
+
+// Some callers don't want to set an exception when unwrapping fails
+// (for example, overload resolution uses unwrapping to tell what sort
+// of thing it's looking at).
+// U must be something that a T* can be assigned to (e.g. T* or an RefPtr<T>).
+//
+// The obj argument will be mutated to point to CheckedUnwrap of itself if the
+// passed-in value is not a DOM object and CheckedUnwrap succeeds.
+//
+// If mayBeWrapper is true, there are three valid ways to invoke
+// UnwrapObjectInternal: Either obj needs to be a class wrapping a
+// MutableHandle<JSObject*>, with an assignment operator that sets the handle to
+// the given object, or U needs to be a strong-reference smart pointer type
+// (OwningNonNull or RefPtr or nsCOMPtr), or the value being stored in "value"
+// must not escape past being tested for falsiness immediately after the
+// UnwrapObjectInternal call.
+//
+// If mayBeWrapper is false, obj can just be a JSObject*, and U anything that a
+// T* can be assigned to.
+namespace binding_detail {
+template <class T, bool mayBeWrapper, typename U, typename V>
+MOZ_ALWAYS_INLINE nsresult
+UnwrapObjectInternal(V& obj, U& value, prototypes::ID protoID,
+ uint32_t protoDepth)
+{
+ /* First check to see whether we have a DOM object */
+ const DOMJSClass* domClass = GetDOMClass(obj);
+ if (domClass) {
+ /* This object is a DOM object. Double-check that it is safely
+ castable to T by checking whether it claims to inherit from the
+ class identified by protoID. */
+ if (domClass->mInterfaceChain[protoDepth] == protoID) {
+ value = UnwrapDOMObject<T>(obj);
+ return NS_OK;
+ }
+ }
+
+ /* Maybe we have a security wrapper or outer window? */
+ if (!mayBeWrapper || !js::IsWrapper(obj)) {
+ /* Not a DOM object, not a wrapper, just bail */
+ return NS_ERROR_XPC_BAD_CONVERT_JS;
+ }
+
+ JSObject* unwrappedObj =
+ js::CheckedUnwrap(obj, /* stopAtWindowProxy = */ false);
+ if (!unwrappedObj) {
+ return NS_ERROR_XPC_SECURITY_MANAGER_VETO;
+ }
+ MOZ_ASSERT(!js::IsWrapper(unwrappedObj));
+ // Recursive call is OK, because now we're using false for mayBeWrapper and
+ // we never reach this code if that boolean is false, so can't keep calling
+ // ourselves.
+ //
+ // Unwrap into a temporary pointer, because in general unwrapping into
+ // something of type U might trigger GC (e.g. release the value currently
+ // stored in there, with arbitrary consequences) and invalidate the
+ // "unwrappedObj" pointer.
+ T* tempValue;
+ nsresult rv = UnwrapObjectInternal<T, false>(unwrappedObj, tempValue,
+ protoID, protoDepth);
+ if (NS_SUCCEEDED(rv)) {
+ // It's very important to not update "obj" with the "unwrappedObj" value
+ // until we know the unwrap has succeeded. Otherwise, in a situation in
+ // which we have an overload of object and primitive we could end up
+ // converting to the primitive from the unwrappedObj, whereas we want to do
+ // it from the original object.
+ obj = unwrappedObj;
+ // And now assign to "value"; at this point we don't care if a GC happens
+ // and invalidates unwrappedObj.
+ value = tempValue;
+ return NS_OK;
+ }
+
+ /* It's the wrong sort of DOM object */
+ return NS_ERROR_XPC_BAD_CONVERT_JS;
+}
+
+struct MutableObjectHandleWrapper {
+ explicit MutableObjectHandleWrapper(JS::MutableHandle<JSObject*> aHandle)
+ : mHandle(aHandle)
+ {
+ }
+
+ void operator=(JSObject* aObject)
+ {
+ MOZ_ASSERT(aObject);
+ mHandle.set(aObject);
+ }
+
+ operator JSObject*() const
+ {
+ return mHandle;
+ }
+
+private:
+ JS::MutableHandle<JSObject*> mHandle;
+};
+
+struct MutableValueHandleWrapper {
+ explicit MutableValueHandleWrapper(JS::MutableHandle<JS::Value> aHandle)
+ : mHandle(aHandle)
+ {
+ }
+
+ void operator=(JSObject* aObject)
+ {
+ MOZ_ASSERT(aObject);
+ mHandle.setObject(*aObject);
+ }
+
+ operator JSObject*() const
+ {
+ return &mHandle.toObject();
+ }
+
+private:
+ JS::MutableHandle<JS::Value> mHandle;
+};
+
+} // namespace binding_detail
+
+// UnwrapObject overloads that ensure we have a MutableHandle to keep it alive.
+template<prototypes::ID PrototypeID, class T, typename U>
+MOZ_ALWAYS_INLINE nsresult
+UnwrapObject(JS::MutableHandle<JSObject*> obj, U& value)
+{
+ binding_detail::MutableObjectHandleWrapper wrapper(obj);
+ return binding_detail::UnwrapObjectInternal<T, true>(
+ wrapper, value, PrototypeID, PrototypeTraits<PrototypeID>::Depth);
+}
+
+template<prototypes::ID PrototypeID, class T, typename U>
+MOZ_ALWAYS_INLINE nsresult
+UnwrapObject(JS::MutableHandle<JS::Value> obj, U& value)
+{
+ MOZ_ASSERT(obj.isObject());
+ binding_detail::MutableValueHandleWrapper wrapper(obj);
+ return binding_detail::UnwrapObjectInternal<T, true>(
+ wrapper, value, PrototypeID, PrototypeTraits<PrototypeID>::Depth);
+}
+
+// UnwrapObject overloads that ensure we have a strong ref to keep it alive.
+template<prototypes::ID PrototypeID, class T, typename U>
+MOZ_ALWAYS_INLINE nsresult
+UnwrapObject(JSObject* obj, RefPtr<U>& value)
+{
+ return binding_detail::UnwrapObjectInternal<T, true>(
+ obj, value, PrototypeID, PrototypeTraits<PrototypeID>::Depth);
+}
+
+template<prototypes::ID PrototypeID, class T, typename U>
+MOZ_ALWAYS_INLINE nsresult
+UnwrapObject(JSObject* obj, nsCOMPtr<U>& value)
+{
+ return binding_detail::UnwrapObjectInternal<T, true>(
+ obj, value, PrototypeID, PrototypeTraits<PrototypeID>::Depth);
+}
+
+template<prototypes::ID PrototypeID, class T, typename U>
+MOZ_ALWAYS_INLINE nsresult
+UnwrapObject(JSObject* obj, OwningNonNull<U>& value)
+{
+ return binding_detail::UnwrapObjectInternal<T, true>(
+ obj, value, PrototypeID, PrototypeTraits<PrototypeID>::Depth);
+}
+
+// An UnwrapObject overload that just calls one of the JSObject* ones.
+template<prototypes::ID PrototypeID, class T, typename U>
+MOZ_ALWAYS_INLINE nsresult
+UnwrapObject(JS::Handle<JS::Value> obj, U& value)
+{
+ MOZ_ASSERT(obj.isObject());
+ return UnwrapObject<PrototypeID, T>(&obj.toObject(), value);
+}
+
+template<prototypes::ID PrototypeID, class T>
+MOZ_ALWAYS_INLINE bool
+IsInstanceOf(JSObject* obj)
+{
+ void* ignored;
+ nsresult unwrapped = binding_detail::UnwrapObjectInternal<T, true>(
+ obj, ignored, PrototypeID, PrototypeTraits<PrototypeID>::Depth);
+ return NS_SUCCEEDED(unwrapped);
+}
+
+template<prototypes::ID PrototypeID, class T, typename U>
+MOZ_ALWAYS_INLINE nsresult
+UnwrapNonWrapperObject(JSObject* obj, U& value)
+{
+ MOZ_ASSERT(!js::IsWrapper(obj));
+ return binding_detail::UnwrapObjectInternal<T, false>(
+ obj, value, PrototypeID, PrototypeTraits<PrototypeID>::Depth);
+}
+
+inline bool
+IsNotDateOrRegExp(JSContext* cx, JS::Handle<JSObject*> obj,
+ bool* notDateOrRegExp)
+{
+ MOZ_ASSERT(obj);
+
+ js::ESClass cls;
+ if (!js::GetBuiltinClass(cx, obj, &cls)) {
+ return false;
+ }
+
+ *notDateOrRegExp = cls != js::ESClass::Date && cls != js::ESClass::RegExp;
+ return true;
+}
+
+MOZ_ALWAYS_INLINE bool
+IsObjectValueConvertibleToDictionary(JSContext* cx,
+ JS::Handle<JS::Value> objVal,
+ bool* convertible)
+{
+ JS::Rooted<JSObject*> obj(cx, &objVal.toObject());
+ return IsNotDateOrRegExp(cx, obj, convertible);
+}
+
+MOZ_ALWAYS_INLINE bool
+IsConvertibleToDictionary(JSContext* cx, JS::Handle<JS::Value> val,
+ bool* convertible)
+{
+ if (val.isNullOrUndefined()) {
+ *convertible = true;
+ return true;
+ }
+ if (!val.isObject()) {
+ *convertible = false;
+ return true;
+ }
+ return IsObjectValueConvertibleToDictionary(cx, val, convertible);
+}
+
+MOZ_ALWAYS_INLINE bool
+IsConvertibleToCallbackInterface(JSContext* cx, JS::Handle<JSObject*> obj,
+ bool* convertible)
+{
+ return IsNotDateOrRegExp(cx, obj, convertible);
+}
+
+// The items in the protoAndIfaceCache are indexed by the prototypes::id::ID,
+// constructors::id::ID and namedpropertiesobjects::id::ID enums, in that order.
+// The end of the prototype objects should be the start of the interface
+// objects, and the end of the interface objects should be the start of the
+// named properties objects.
+static_assert((size_t)constructors::id::_ID_Start ==
+ (size_t)prototypes::id::_ID_Count &&
+ (size_t)namedpropertiesobjects::id::_ID_Start ==
+ (size_t)constructors::id::_ID_Count,
+ "Overlapping or discontiguous indexes.");
+const size_t kProtoAndIfaceCacheCount = namedpropertiesobjects::id::_ID_Count;
+
+class ProtoAndIfaceCache
+{
+ // The caching strategy we use depends on what sort of global we're dealing
+ // with. For a window-like global, we want everything to be as fast as
+ // possible, so we use a flat array, indexed by prototype/constructor ID.
+ // For everything else (e.g. globals for JSMs), space is more important than
+ // speed, so we use a two-level lookup table.
+
+ class ArrayCache : public Array<JS::Heap<JSObject*>, kProtoAndIfaceCacheCount>
+ {
+ public:
+ JSObject* EntrySlotIfExists(size_t i) {
+ return (*this)[i];
+ }
+
+ JS::Heap<JSObject*>& EntrySlotOrCreate(size_t i) {
+ return (*this)[i];
+ }
+
+ JS::Heap<JSObject*>& EntrySlotMustExist(size_t i) {
+ return (*this)[i];
+ }
+
+ void Trace(JSTracer* aTracer) {
+ for (size_t i = 0; i < ArrayLength(*this); ++i) {
+ JS::TraceEdge(aTracer, &(*this)[i], "protoAndIfaceCache[i]");
+ }
+ }
+
+ size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) {
+ return aMallocSizeOf(this);
+ }
+ };
+
+ class PageTableCache
+ {
+ public:
+ PageTableCache() {
+ memset(&mPages, 0, sizeof(mPages));
+ }
+
+ ~PageTableCache() {
+ for (size_t i = 0; i < ArrayLength(mPages); ++i) {
+ delete mPages[i];
+ }
+ }
+
+ JSObject* EntrySlotIfExists(size_t i) {
+ MOZ_ASSERT(i < kProtoAndIfaceCacheCount);
+ size_t pageIndex = i / kPageSize;
+ size_t leafIndex = i % kPageSize;
+ Page* p = mPages[pageIndex];
+ if (!p) {
+ return nullptr;
+ }
+ return (*p)[leafIndex];
+ }
+
+ JS::Heap<JSObject*>& EntrySlotOrCreate(size_t i) {
+ MOZ_ASSERT(i < kProtoAndIfaceCacheCount);
+ size_t pageIndex = i / kPageSize;
+ size_t leafIndex = i % kPageSize;
+ Page* p = mPages[pageIndex];
+ if (!p) {
+ p = new Page;
+ mPages[pageIndex] = p;
+ }
+ return (*p)[leafIndex];
+ }
+
+ JS::Heap<JSObject*>& EntrySlotMustExist(size_t i) {
+ MOZ_ASSERT(i < kProtoAndIfaceCacheCount);
+ size_t pageIndex = i / kPageSize;
+ size_t leafIndex = i % kPageSize;
+ Page* p = mPages[pageIndex];
+ MOZ_ASSERT(p);
+ return (*p)[leafIndex];
+ }
+
+ void Trace(JSTracer* trc) {
+ for (size_t i = 0; i < ArrayLength(mPages); ++i) {
+ Page* p = mPages[i];
+ if (p) {
+ for (size_t j = 0; j < ArrayLength(*p); ++j) {
+ JS::TraceEdge(trc, &(*p)[j], "protoAndIfaceCache[i]");
+ }
+ }
+ }
+ }
+
+ size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) {
+ size_t n = aMallocSizeOf(this);
+ for (size_t i = 0; i < ArrayLength(mPages); ++i) {
+ n += aMallocSizeOf(mPages[i]);
+ }
+ return n;
+ }
+
+ private:
+ static const size_t kPageSize = 16;
+ typedef Array<JS::Heap<JSObject*>, kPageSize> Page;
+ static const size_t kNPages = kProtoAndIfaceCacheCount / kPageSize +
+ size_t(bool(kProtoAndIfaceCacheCount % kPageSize));
+ Array<Page*, kNPages> mPages;
+ };
+
+public:
+ enum Kind {
+ WindowLike,
+ NonWindowLike
+ };
+
+ explicit ProtoAndIfaceCache(Kind aKind) : mKind(aKind) {
+ MOZ_COUNT_CTOR(ProtoAndIfaceCache);
+ if (aKind == WindowLike) {
+ mArrayCache = new ArrayCache();
+ } else {
+ mPageTableCache = new PageTableCache();
+ }
+ }
+
+ ~ProtoAndIfaceCache() {
+ if (mKind == WindowLike) {
+ delete mArrayCache;
+ } else {
+ delete mPageTableCache;
+ }
+ MOZ_COUNT_DTOR(ProtoAndIfaceCache);
+ }
+
+#define FORWARD_OPERATION(opName, args) \
+ do { \
+ if (mKind == WindowLike) { \
+ return mArrayCache->opName args; \
+ } else { \
+ return mPageTableCache->opName args; \
+ } \
+ } while(0)
+
+ // Return the JSObject stored in slot i, if that slot exists. If
+ // the slot does not exist, return null.
+ JSObject* EntrySlotIfExists(size_t i) {
+ FORWARD_OPERATION(EntrySlotIfExists, (i));
+ }
+
+ // Return a reference to slot i, creating it if necessary. There
+ // may not be an object in the returned slot.
+ JS::Heap<JSObject*>& EntrySlotOrCreate(size_t i) {
+ FORWARD_OPERATION(EntrySlotOrCreate, (i));
+ }
+
+ // Return a reference to slot i, which is guaranteed to already
+ // exist. There may not be an object in the slot, if prototype and
+ // constructor initialization for one of our bindings failed.
+ JS::Heap<JSObject*>& EntrySlotMustExist(size_t i) {
+ FORWARD_OPERATION(EntrySlotMustExist, (i));
+ }
+
+ void Trace(JSTracer *aTracer) {
+ FORWARD_OPERATION(Trace, (aTracer));
+ }
+
+ size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) {
+ size_t n = aMallocSizeOf(this);
+ n += (mKind == WindowLike
+ ? mArrayCache->SizeOfIncludingThis(aMallocSizeOf)
+ : mPageTableCache->SizeOfIncludingThis(aMallocSizeOf));
+ return n;
+ }
+#undef FORWARD_OPERATION
+
+private:
+ union {
+ ArrayCache *mArrayCache;
+ PageTableCache *mPageTableCache;
+ };
+ Kind mKind;
+};
+
+inline void
+AllocateProtoAndIfaceCache(JSObject* obj, ProtoAndIfaceCache::Kind aKind)
+{
+ MOZ_ASSERT(js::GetObjectClass(obj)->flags & JSCLASS_DOM_GLOBAL);
+ MOZ_ASSERT(js::GetReservedSlot(obj, DOM_PROTOTYPE_SLOT).isUndefined());
+
+ ProtoAndIfaceCache* protoAndIfaceCache = new ProtoAndIfaceCache(aKind);
+
+ js::SetReservedSlot(obj, DOM_PROTOTYPE_SLOT,
+ JS::PrivateValue(protoAndIfaceCache));
+}
+
+#ifdef DEBUG
+struct VerifyTraceProtoAndIfaceCacheCalledTracer : public JS::CallbackTracer
+{
+ bool ok;
+
+ explicit VerifyTraceProtoAndIfaceCacheCalledTracer(JSContext* cx)
+ : JS::CallbackTracer(cx), ok(false)
+ {}
+
+ void onChild(const JS::GCCellPtr&) override {
+ // We don't do anything here, we only want to verify that
+ // TraceProtoAndIfaceCache was called.
+ }
+
+ TracerKind getTracerKind() const override { return TracerKind::VerifyTraceProtoAndIface; }
+};
+#endif
+
+inline void
+TraceProtoAndIfaceCache(JSTracer* trc, JSObject* obj)
+{
+ MOZ_ASSERT(js::GetObjectClass(obj)->flags & JSCLASS_DOM_GLOBAL);
+
+#ifdef DEBUG
+ if (trc->isCallbackTracer() &&
+ (trc->asCallbackTracer()->getTracerKind() ==
+ JS::CallbackTracer::TracerKind::VerifyTraceProtoAndIface)) {
+ // We don't do anything here, we only want to verify that
+ // TraceProtoAndIfaceCache was called.
+ static_cast<VerifyTraceProtoAndIfaceCacheCalledTracer*>(trc)->ok = true;
+ return;
+ }
+#endif
+
+ if (!DOMGlobalHasProtoAndIFaceCache(obj))
+ return;
+ ProtoAndIfaceCache* protoAndIfaceCache = GetProtoAndIfaceCache(obj);
+ protoAndIfaceCache->Trace(trc);
+}
+
+inline void
+DestroyProtoAndIfaceCache(JSObject* obj)
+{
+ MOZ_ASSERT(js::GetObjectClass(obj)->flags & JSCLASS_DOM_GLOBAL);
+
+ if (!DOMGlobalHasProtoAndIFaceCache(obj)) {
+ return;
+ }
+
+ ProtoAndIfaceCache* protoAndIfaceCache = GetProtoAndIfaceCache(obj);
+
+ delete protoAndIfaceCache;
+}
+
+/**
+ * Add constants to an object.
+ */
+bool
+DefineConstants(JSContext* cx, JS::Handle<JSObject*> obj,
+ const ConstantSpec* cs);
+
+struct JSNativeHolder
+{
+ JSNative mNative;
+ const NativePropertyHooks* mPropertyHooks;
+};
+
+struct NamedConstructor
+{
+ const char* mName;
+ const JSNativeHolder mHolder;
+ unsigned mNargs;
+};
+
+/*
+ * Create a DOM interface object (if constructorClass is non-null) and/or a
+ * DOM interface prototype object (if protoClass is non-null).
+ *
+ * global is used as the parent of the interface object and the interface
+ * prototype object
+ * protoProto is the prototype to use for the interface prototype object.
+ * interfaceProto is the prototype to use for the interface object. This can be
+ * null if both constructorClass and constructor are null (as in,
+ * if we're not creating an interface object at all).
+ * protoClass is the JSClass to use for the interface prototype object.
+ * This is null if we should not create an interface prototype
+ * object.
+ * protoCache a pointer to a JSObject pointer where we should cache the
+ * interface prototype object. This must be null if protoClass is and
+ * vice versa.
+ * constructorClass is the JSClass to use for the interface object.
+ * This is null if we should not create an interface object or
+ * if it should be a function object.
+ * constructor holds the JSNative to back the interface object which should be a
+ * Function, unless constructorClass is non-null in which case it is
+ * ignored. If this is null and constructorClass is also null then
+ * we should not create an interface object at all.
+ * ctorNargs is the length of the constructor function; 0 if no constructor
+ * constructorCache a pointer to a JSObject pointer where we should cache the
+ * interface object. This must be null if both constructorClass
+ * and constructor are null, and non-null otherwise.
+ * properties contains the methods, attributes and constants to be defined on
+ * objects in any compartment.
+ * chromeProperties contains the methods, attributes and constants to be defined
+ * on objects in chrome compartments. This must be null if the
+ * interface doesn't have any ChromeOnly properties or if the
+ * object is being created in non-chrome compartment.
+ * defineOnGlobal controls whether properties should be defined on the given
+ * global for the interface object (if any) and named
+ * constructors (if any) for this interface. This can be
+ * false in situations where we want the properties to only
+ * appear on privileged Xrays but not on the unprivileged
+ * underlying global.
+ * unscopableNames if not null it points to a null-terminated list of const
+ * char* names of the unscopable properties for this interface.
+ * isGlobal if true, we're creating interface objects for a [Global] or
+ * [PrimaryGlobal] interface, and hence shouldn't define properties on
+ * the prototype object.
+ *
+ * At least one of protoClass, constructorClass or constructor should be
+ * non-null. If constructorClass or constructor are non-null, the resulting
+ * interface object will be defined on the given global with property name
+ * |name|, which must also be non-null.
+ */
+void
+CreateInterfaceObjects(JSContext* cx, JS::Handle<JSObject*> global,
+ JS::Handle<JSObject*> protoProto,
+ const js::Class* protoClass, JS::Heap<JSObject*>* protoCache,
+ JS::Handle<JSObject*> interfaceProto,
+ const js::Class* constructorClass,
+ unsigned ctorNargs, const NamedConstructor* namedConstructors,
+ JS::Heap<JSObject*>* constructorCache,
+ const NativeProperties* regularProperties,
+ const NativeProperties* chromeOnlyProperties,
+ const char* name, bool defineOnGlobal,
+ const char* const* unscopableNames,
+ bool isGlobal);
+
+/**
+ * Define the properties (regular and chrome-only) on obj.
+ *
+ * obj the object to instal the properties on. This should be the interface
+ * prototype object for regular interfaces and the instance object for
+ * interfaces marked with Global.
+ * properties contains the methods, attributes and constants to be defined on
+ * objects in any compartment.
+ * chromeProperties contains the methods, attributes and constants to be defined
+ * on objects in chrome compartments. This must be null if the
+ * interface doesn't have any ChromeOnly properties or if the
+ * object is being created in non-chrome compartment.
+ */
+bool
+DefineProperties(JSContext* cx, JS::Handle<JSObject*> obj,
+ const NativeProperties* properties,
+ const NativeProperties* chromeOnlyProperties);
+
+/*
+ * Define the unforgeable methods on an object.
+ */
+bool
+DefineUnforgeableMethods(JSContext* cx, JS::Handle<JSObject*> obj,
+ const Prefable<const JSFunctionSpec>* props);
+
+/*
+ * Define the unforgeable attributes on an object.
+ */
+bool
+DefineUnforgeableAttributes(JSContext* cx, JS::Handle<JSObject*> obj,
+ const Prefable<const JSPropertySpec>* props);
+
+#define HAS_MEMBER_TYPEDEFS \
+private: \
+ typedef char yes[1]; \
+ typedef char no[2]
+
+#ifdef _MSC_VER
+#define HAS_MEMBER_CHECK(_name) \
+ template<typename V> static yes& Check##_name(char (*)[(&V::_name == 0) + 1])
+#else
+#define HAS_MEMBER_CHECK(_name) \
+ template<typename V> static yes& Check##_name(char (*)[sizeof(&V::_name) + 1])
+#endif
+
+#define HAS_MEMBER(_memberName, _valueName) \
+private: \
+ HAS_MEMBER_CHECK(_memberName); \
+ template<typename V> static no& Check##_memberName(...); \
+ \
+public: \
+ static bool const _valueName = \
+ sizeof(Check##_memberName<T>(nullptr)) == sizeof(yes)
+
+template<class T>
+struct NativeHasMember
+{
+ HAS_MEMBER_TYPEDEFS;
+
+ HAS_MEMBER(GetParentObject, GetParentObject);
+ HAS_MEMBER(WrapObject, WrapObject);
+};
+
+template<class T>
+struct IsSmartPtr
+{
+ HAS_MEMBER_TYPEDEFS;
+
+ HAS_MEMBER(get, value);
+};
+
+template<class T>
+struct IsRefcounted
+{
+ HAS_MEMBER_TYPEDEFS;
+
+ HAS_MEMBER(AddRef, HasAddref);
+ HAS_MEMBER(Release, HasRelease);
+
+public:
+ static bool const value = HasAddref && HasRelease;
+
+private:
+ // This struct only works if T is fully declared (not just forward declared).
+ // The IsBaseOf check will ensure that, we don't really need it for any other
+ // reason (the static assert will of course always be true).
+ static_assert(!IsBaseOf<nsISupports, T>::value || IsRefcounted::value,
+ "Classes derived from nsISupports are refcounted!");
+
+};
+
+#undef HAS_MEMBER
+#undef HAS_MEMBER_CHECK
+#undef HAS_MEMBER_TYPEDEFS
+
+#ifdef DEBUG
+template <class T, bool isISupports=IsBaseOf<nsISupports, T>::value>
+struct
+CheckWrapperCacheCast
+{
+ static bool Check()
+ {
+ return reinterpret_cast<uintptr_t>(
+ static_cast<nsWrapperCache*>(
+ reinterpret_cast<T*>(1))) == 1;
+ }
+};
+template <class T>
+struct
+CheckWrapperCacheCast<T, true>
+{
+ static bool Check()
+ {
+ return true;
+ }
+};
+#endif
+
+MOZ_ALWAYS_INLINE bool
+CouldBeDOMBinding(void*)
+{
+ return true;
+}
+
+MOZ_ALWAYS_INLINE bool
+CouldBeDOMBinding(nsWrapperCache* aCache)
+{
+ return aCache->IsDOMBinding();
+}
+
+inline bool
+TryToOuterize(JS::MutableHandle<JS::Value> rval)
+{
+ if (js::IsWindow(&rval.toObject())) {
+ JSObject* obj = js::ToWindowProxyIfWindow(&rval.toObject());
+ MOZ_ASSERT(obj);
+ rval.set(JS::ObjectValue(*obj));
+ }
+
+ return true;
+}
+
+// Make sure to wrap the given string value into the right compartment, as
+// needed.
+MOZ_ALWAYS_INLINE
+bool
+MaybeWrapStringValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
+{
+ MOZ_ASSERT(rval.isString());
+ JSString* str = rval.toString();
+ if (JS::GetStringZone(str) != js::GetContextZone(cx)) {
+ return JS_WrapValue(cx, rval);
+ }
+ return true;
+}
+
+// Make sure to wrap the given object value into the right compartment as
+// needed. This will work correctly, but possibly slowly, on all objects.
+MOZ_ALWAYS_INLINE
+bool
+MaybeWrapObjectValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
+{
+ MOZ_ASSERT(rval.isObject());
+
+ // Cross-compartment always requires wrapping.
+ JSObject* obj = &rval.toObject();
+ if (js::GetObjectCompartment(obj) != js::GetContextCompartment(cx)) {
+ return JS_WrapValue(cx, rval);
+ }
+
+ // We're same-compartment, but even then we might need to wrap
+ // objects specially. Check for that.
+ if (IsDOMObject(obj)) {
+ return TryToOuterize(rval);
+ }
+
+ // It's not a WebIDL object, so it's OK to just leave it as-is: only WebIDL
+ // objects (specifically only windows) require outerization.
+ return true;
+}
+
+// Like MaybeWrapObjectValue, but also allows null
+MOZ_ALWAYS_INLINE
+bool
+MaybeWrapObjectOrNullValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
+{
+ MOZ_ASSERT(rval.isObjectOrNull());
+ if (rval.isNull()) {
+ return true;
+ }
+ return MaybeWrapObjectValue(cx, rval);
+}
+
+// Wrapping for objects that are known to not be DOM or XPConnect objects
+MOZ_ALWAYS_INLINE
+bool
+MaybeWrapNonDOMObjectValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
+{
+ MOZ_ASSERT(rval.isObject());
+ MOZ_ASSERT(!GetDOMClass(&rval.toObject()));
+ MOZ_ASSERT(!(js::GetObjectClass(&rval.toObject())->flags &
+ JSCLASS_PRIVATE_IS_NSISUPPORTS));
+
+ JSObject* obj = &rval.toObject();
+ if (js::GetObjectCompartment(obj) == js::GetContextCompartment(cx)) {
+ return true;
+ }
+ return JS_WrapValue(cx, rval);
+}
+
+// Like MaybeWrapNonDOMObjectValue but allows null
+MOZ_ALWAYS_INLINE
+bool
+MaybeWrapNonDOMObjectOrNullValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
+{
+ MOZ_ASSERT(rval.isObjectOrNull());
+ if (rval.isNull()) {
+ return true;
+ }
+ return MaybeWrapNonDOMObjectValue(cx, rval);
+}
+
+// If rval is a gcthing and is not in the compartment of cx, wrap rval
+// into the compartment of cx (typically by replacing it with an Xray or
+// cross-compartment wrapper around the original object).
+MOZ_ALWAYS_INLINE bool
+MaybeWrapValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
+{
+ if (rval.isString()) {
+ return MaybeWrapStringValue(cx, rval);
+ }
+
+ if (!rval.isObject()) {
+ return true;
+ }
+
+ return MaybeWrapObjectValue(cx, rval);
+}
+
+namespace binding_detail {
+enum GetOrCreateReflectorWrapBehavior {
+ eWrapIntoContextCompartment,
+ eDontWrapIntoContextCompartment
+};
+
+template <class T>
+struct TypeNeedsOuterization
+{
+ // We only need to outerize Window objects, so anything inheriting from
+ // nsGlobalWindow (which inherits from EventTarget itself).
+ static const bool value =
+ IsBaseOf<nsGlobalWindow, T>::value || IsSame<EventTarget, T>::value;
+};
+
+#ifdef DEBUG
+template<typename T, bool isISupports=IsBaseOf<nsISupports, T>::value>
+struct CheckWrapperCacheTracing
+{
+ static inline void Check(T* aObject)
+ {
+ }
+};
+
+template<typename T>
+struct CheckWrapperCacheTracing<T, true>
+{
+ static void Check(T* aObject)
+ {
+ // Rooting analysis thinks QueryInterface may GC, but we're dealing with
+ // a subset of QueryInterface, C++ only types here.
+ JS::AutoSuppressGCAnalysis nogc;
+
+ nsWrapperCache* wrapperCacheFromQI = nullptr;
+ aObject->QueryInterface(NS_GET_IID(nsWrapperCache),
+ reinterpret_cast<void**>(&wrapperCacheFromQI));
+
+ MOZ_ASSERT(wrapperCacheFromQI,
+ "Missing nsWrapperCache from QueryInterface implementation?");
+
+ if (!wrapperCacheFromQI->GetWrapperPreserveColor()) {
+ // Can't assert that we trace the wrapper, since we don't have any
+ // wrapper to trace.
+ return;
+ }
+
+ nsISupports* ccISupports = nullptr;
+ aObject->QueryInterface(NS_GET_IID(nsCycleCollectionISupports),
+ reinterpret_cast<void**>(&ccISupports));
+ MOZ_ASSERT(ccISupports,
+ "nsWrapperCache object which isn't cycle collectable?");
+
+ nsXPCOMCycleCollectionParticipant* participant = nullptr;
+ CallQueryInterface(ccISupports, &participant);
+ MOZ_ASSERT(participant, "Can't QI to CycleCollectionParticipant?");
+
+ bool wasPreservingWrapper = wrapperCacheFromQI->PreservingWrapper();
+ wrapperCacheFromQI->SetPreservingWrapper(true);
+ wrapperCacheFromQI->CheckCCWrapperTraversal(ccISupports, participant);
+ wrapperCacheFromQI->SetPreservingWrapper(wasPreservingWrapper);
+ }
+};
+
+void
+AssertReflectorHasGivenProto(JSContext* aCx, JSObject* aReflector,
+ JS::Handle<JSObject*> aGivenProto);
+#endif // DEBUG
+
+template <class T, GetOrCreateReflectorWrapBehavior wrapBehavior>
+MOZ_ALWAYS_INLINE bool
+DoGetOrCreateDOMReflector(JSContext* cx, T* value,
+ JS::Handle<JSObject*> givenProto,
+ JS::MutableHandle<JS::Value> rval)
+{
+ MOZ_ASSERT(value);
+ // We can get rid of this when we remove support for hasXPConnectImpls.
+ bool couldBeDOMBinding = CouldBeDOMBinding(value);
+ JSObject* obj = value->GetWrapper();
+ if (obj) {
+#ifdef DEBUG
+ AssertReflectorHasGivenProto(cx, obj, givenProto);
+ // Have to reget obj because AssertReflectorHasGivenProto can
+ // trigger gc so the pointer may now be invalid.
+ obj = value->GetWrapper();
+#endif
+ } else {
+ // Inline this here while we have non-dom objects in wrapper caches.
+ if (!couldBeDOMBinding) {
+ return false;
+ }
+
+ obj = value->WrapObject(cx, givenProto);
+ if (!obj) {
+ // At this point, obj is null, so just return false.
+ // Callers seem to be testing JS_IsExceptionPending(cx) to
+ // figure out whether WrapObject() threw.
+ return false;
+ }
+
+#ifdef DEBUG
+ if (IsBaseOf<nsWrapperCache, T>::value) {
+ CheckWrapperCacheTracing<T>::Check(value);
+ }
+#endif
+ }
+
+#ifdef DEBUG
+ const DOMJSClass* clasp = GetDOMClass(obj);
+ // clasp can be null if the cache contained a non-DOM object.
+ if (clasp) {
+ // Some sanity asserts about our object. Specifically:
+ // 1) If our class claims we're nsISupports, we better be nsISupports
+ // XXXbz ideally, we could assert that reinterpret_cast to nsISupports
+ // does the right thing, but I don't see a way to do it. :(
+ // 2) If our class doesn't claim we're nsISupports we better be
+ // reinterpret_castable to nsWrapperCache.
+ MOZ_ASSERT(clasp, "What happened here?");
+ MOZ_ASSERT_IF(clasp->mDOMObjectIsISupports, (IsBaseOf<nsISupports, T>::value));
+ MOZ_ASSERT(CheckWrapperCacheCast<T>::Check());
+ }
+#endif
+
+ rval.set(JS::ObjectValue(*obj));
+
+ bool sameCompartment =
+ js::GetObjectCompartment(obj) == js::GetContextCompartment(cx);
+ if (sameCompartment && couldBeDOMBinding) {
+ return TypeNeedsOuterization<T>::value ? TryToOuterize(rval) : true;
+ }
+
+ if (wrapBehavior == eDontWrapIntoContextCompartment) {
+ if (TypeNeedsOuterization<T>::value) {
+ JSAutoCompartment ac(cx, obj);
+ return TryToOuterize(rval);
+ }
+
+ return true;
+ }
+
+ return JS_WrapValue(cx, rval);
+}
+
+} // namespace binding_detail
+
+// Create a JSObject wrapping "value", if there isn't one already, and store it
+// in rval. "value" must be a concrete class that implements a
+// GetWrapperPreserveColor() which can return its existing wrapper, if any, and
+// a WrapObject() which will try to create a wrapper. Typically, this is done by
+// having "value" inherit from nsWrapperCache.
+//
+// The value stored in rval will be ready to be exposed to whatever JS
+// is running on cx right now. In particular, it will be in the
+// compartment of cx, and outerized as needed.
+template <class T>
+MOZ_ALWAYS_INLINE bool
+GetOrCreateDOMReflector(JSContext* cx, T* value,
+ JS::MutableHandle<JS::Value> rval,
+ JS::Handle<JSObject*> givenProto = nullptr)
+{
+ using namespace binding_detail;
+ return DoGetOrCreateDOMReflector<T, eWrapIntoContextCompartment>(cx, value,
+ givenProto,
+ rval);
+}
+
+// Like GetOrCreateDOMReflector but doesn't wrap into the context compartment,
+// and hence does not actually require cx to be in a compartment.
+template <class T>
+MOZ_ALWAYS_INLINE bool
+GetOrCreateDOMReflectorNoWrap(JSContext* cx, T* value,
+ JS::MutableHandle<JS::Value> rval)
+{
+ using namespace binding_detail;
+ return DoGetOrCreateDOMReflector<T, eDontWrapIntoContextCompartment>(cx,
+ value,
+ nullptr,
+ rval);
+}
+
+// Create a JSObject wrapping "value", for cases when "value" is a
+// non-wrapper-cached object using WebIDL bindings. "value" must implement a
+// WrapObject() method taking a JSContext and a scope.
+template <class T>
+inline bool
+WrapNewBindingNonWrapperCachedObject(JSContext* cx,
+ JS::Handle<JSObject*> scopeArg,
+ T* value,
+ JS::MutableHandle<JS::Value> rval,
+ JS::Handle<JSObject*> givenProto = nullptr)
+{
+ static_assert(IsRefcounted<T>::value, "Don't pass owned classes in here.");
+ MOZ_ASSERT(value);
+ // We try to wrap in the compartment of the underlying object of "scope"
+ JS::Rooted<JSObject*> obj(cx);
+ {
+ // scope for the JSAutoCompartment so that we restore the compartment
+ // before we call JS_WrapValue.
+ Maybe<JSAutoCompartment> ac;
+ // Maybe<Handle> doesn't so much work, and in any case, adding
+ // more Maybe (one for a Rooted and one for a Handle) adds more
+ // code (and branches!) than just adding a single rooted.
+ JS::Rooted<JSObject*> scope(cx, scopeArg);
+ JS::Rooted<JSObject*> proto(cx, givenProto);
+ if (js::IsWrapper(scope)) {
+ scope = js::CheckedUnwrap(scope, /* stopAtWindowProxy = */ false);
+ if (!scope)
+ return false;
+ ac.emplace(cx, scope);
+ if (!JS_WrapObject(cx, &proto)) {
+ return false;
+ }
+ }
+
+ MOZ_ASSERT(js::IsObjectInContextCompartment(scope, cx));
+ if (!value->WrapObject(cx, proto, &obj)) {
+ return false;
+ }
+ }
+
+ // We can end up here in all sorts of compartments, per above. Make
+ // sure to JS_WrapValue!
+ rval.set(JS::ObjectValue(*obj));
+ return MaybeWrapObjectValue(cx, rval);
+}
+
+// Create a JSObject wrapping "value", for cases when "value" is a
+// non-wrapper-cached owned object using WebIDL bindings. "value" must implement a
+// WrapObject() method taking a JSContext, a scope, and a boolean outparam that
+// is true if the JSObject took ownership
+template <class T>
+inline bool
+WrapNewBindingNonWrapperCachedObject(JSContext* cx,
+ JS::Handle<JSObject*> scopeArg,
+ nsAutoPtr<T>& value,
+ JS::MutableHandle<JS::Value> rval,
+ JS::Handle<JSObject*> givenProto = nullptr)
+{
+ static_assert(!IsRefcounted<T>::value, "Only pass owned classes in here.");
+ // We do a runtime check on value, because otherwise we might in
+ // fact end up wrapping a null and invoking methods on it later.
+ if (!value) {
+ NS_RUNTIMEABORT("Don't try to wrap null objects");
+ }
+ // We try to wrap in the compartment of the underlying object of "scope"
+ JS::Rooted<JSObject*> obj(cx);
+ {
+ // scope for the JSAutoCompartment so that we restore the compartment
+ // before we call JS_WrapValue.
+ Maybe<JSAutoCompartment> ac;
+ // Maybe<Handle> doesn't so much work, and in any case, adding
+ // more Maybe (one for a Rooted and one for a Handle) adds more
+ // code (and branches!) than just adding a single rooted.
+ JS::Rooted<JSObject*> scope(cx, scopeArg);
+ JS::Rooted<JSObject*> proto(cx, givenProto);
+ if (js::IsWrapper(scope)) {
+ scope = js::CheckedUnwrap(scope, /* stopAtWindowProxy = */ false);
+ if (!scope)
+ return false;
+ ac.emplace(cx, scope);
+ if (!JS_WrapObject(cx, &proto)) {
+ return false;
+ }
+ }
+
+ MOZ_ASSERT(js::IsObjectInContextCompartment(scope, cx));
+ if (!value->WrapObject(cx, proto, &obj)) {
+ return false;
+ }
+
+ value.forget();
+ }
+
+ // We can end up here in all sorts of compartments, per above. Make
+ // sure to JS_WrapValue!
+ rval.set(JS::ObjectValue(*obj));
+ return MaybeWrapObjectValue(cx, rval);
+}
+
+// Helper for smart pointers (nsRefPtr/nsCOMPtr).
+template <template <typename> class SmartPtr, typename T,
+ typename U=typename EnableIf<IsRefcounted<T>::value, T>::Type,
+ typename V=typename EnableIf<IsSmartPtr<SmartPtr<T>>::value, T>::Type>
+inline bool
+WrapNewBindingNonWrapperCachedObject(JSContext* cx, JS::Handle<JSObject*> scope,
+ const SmartPtr<T>& value,
+ JS::MutableHandle<JS::Value> rval,
+ JS::Handle<JSObject*> givenProto = nullptr)
+{
+ return WrapNewBindingNonWrapperCachedObject(cx, scope, value.get(), rval,
+ givenProto);
+}
+
+// Helper for object references (as opposed to pointers).
+template <typename T,
+ typename U=typename EnableIf<!IsSmartPtr<T>::value, T>::Type>
+inline bool
+WrapNewBindingNonWrapperCachedObject(JSContext* cx, JS::Handle<JSObject*> scope,
+ T& value,
+ JS::MutableHandle<JS::Value> rval,
+ JS::Handle<JSObject*> givenProto = nullptr)
+{
+ return WrapNewBindingNonWrapperCachedObject(cx, scope, &value, rval,
+ givenProto);
+}
+
+// Only set allowNativeWrapper to false if you really know you need it, if in
+// doubt use true. Setting it to false disables security wrappers.
+bool
+NativeInterface2JSObjectAndThrowIfFailed(JSContext* aCx,
+ JS::Handle<JSObject*> aScope,
+ JS::MutableHandle<JS::Value> aRetval,
+ xpcObjectHelper& aHelper,
+ const nsIID* aIID,
+ bool aAllowNativeWrapper);
+
+/**
+ * A method to handle new-binding wrap failure, by possibly falling back to
+ * wrapping as a non-new-binding object.
+ */
+template <class T>
+MOZ_ALWAYS_INLINE bool
+HandleNewBindingWrappingFailure(JSContext* cx, JS::Handle<JSObject*> scope,
+ T* value, JS::MutableHandle<JS::Value> rval)
+{
+ if (JS_IsExceptionPending(cx)) {
+ return false;
+ }
+
+ qsObjectHelper helper(value, GetWrapperCache(value));
+ return NativeInterface2JSObjectAndThrowIfFailed(cx, scope, rval,
+ helper, nullptr, true);
+}
+
+// Helper for calling HandleNewBindingWrappingFailure with smart pointers
+// (nsAutoPtr/nsRefPtr/nsCOMPtr) or references.
+
+template <class T, bool isSmartPtr=IsSmartPtr<T>::value>
+struct HandleNewBindingWrappingFailureHelper
+{
+ static inline bool Wrap(JSContext* cx, JS::Handle<JSObject*> scope,
+ const T& value, JS::MutableHandle<JS::Value> rval)
+ {
+ return HandleNewBindingWrappingFailure(cx, scope, value.get(), rval);
+ }
+};
+
+template <class T>
+struct HandleNewBindingWrappingFailureHelper<T, false>
+{
+ static inline bool Wrap(JSContext* cx, JS::Handle<JSObject*> scope, T& value,
+ JS::MutableHandle<JS::Value> rval)
+ {
+ return HandleNewBindingWrappingFailure(cx, scope, &value, rval);
+ }
+};
+
+template<class T>
+inline bool
+HandleNewBindingWrappingFailure(JSContext* cx, JS::Handle<JSObject*> scope,
+ T& value, JS::MutableHandle<JS::Value> rval)
+{
+ return HandleNewBindingWrappingFailureHelper<T>::Wrap(cx, scope, value, rval);
+}
+
+template<bool Fatal>
+inline bool
+EnumValueNotFound(JSContext* cx, JS::HandleString str, const char* type,
+ const char* sourceDescription);
+
+template<>
+inline bool
+EnumValueNotFound<false>(JSContext* cx, JS::HandleString str, const char* type,
+ const char* sourceDescription)
+{
+ // TODO: Log a warning to the console.
+ return true;
+}
+
+template<>
+inline bool
+EnumValueNotFound<true>(JSContext* cx, JS::HandleString str, const char* type,
+ const char* sourceDescription)
+{
+ JSAutoByteString deflated;
+ if (!deflated.encodeUtf8(cx, str)) {
+ return false;
+ }
+ return ThrowErrorMessage(cx, MSG_INVALID_ENUM_VALUE, sourceDescription,
+ deflated.ptr(), type);
+}
+
+template<typename CharT>
+inline int
+FindEnumStringIndexImpl(const CharT* chars, size_t length, const EnumEntry* values)
+{
+ int i = 0;
+ for (const EnumEntry* value = values; value->value; ++value, ++i) {
+ if (length != value->length) {
+ continue;
+ }
+
+ bool equal = true;
+ const char* val = value->value;
+ for (size_t j = 0; j != length; ++j) {
+ if (unsigned(val[j]) != unsigned(chars[j])) {
+ equal = false;
+ break;
+ }
+ }
+
+ if (equal) {
+ return i;
+ }
+ }
+
+ return -1;
+}
+
+template<bool InvalidValueFatal>
+inline bool
+FindEnumStringIndex(JSContext* cx, JS::Handle<JS::Value> v, const EnumEntry* values,
+ const char* type, const char* sourceDescription, int* index)
+{
+ // JS_StringEqualsAscii is slow as molasses, so don't use it here.
+ JS::RootedString str(cx, JS::ToString(cx, v));
+ if (!str) {
+ return false;
+ }
+
+ {
+ size_t length;
+ JS::AutoCheckCannotGC nogc;
+ if (js::StringHasLatin1Chars(str)) {
+ const JS::Latin1Char* chars = JS_GetLatin1StringCharsAndLength(cx, nogc, str,
+ &length);
+ if (!chars) {
+ return false;
+ }
+ *index = FindEnumStringIndexImpl(chars, length, values);
+ } else {
+ const char16_t* chars = JS_GetTwoByteStringCharsAndLength(cx, nogc, str,
+ &length);
+ if (!chars) {
+ return false;
+ }
+ *index = FindEnumStringIndexImpl(chars, length, values);
+ }
+ if (*index >= 0) {
+ return true;
+ }
+ }
+
+ return EnumValueNotFound<InvalidValueFatal>(cx, str, type, sourceDescription);
+}
+
+inline nsWrapperCache*
+GetWrapperCache(const ParentObject& aParentObject)
+{
+ return aParentObject.mWrapperCache;
+}
+
+template<class T>
+inline T*
+GetParentPointer(T* aObject)
+{
+ return aObject;
+}
+
+inline nsISupports*
+GetParentPointer(const ParentObject& aObject)
+{
+ return aObject.mObject;
+}
+
+template <typename T>
+inline bool
+GetUseXBLScope(T* aParentObject)
+{
+ return false;
+}
+
+inline bool
+GetUseXBLScope(const ParentObject& aParentObject)
+{
+ return aParentObject.mUseXBLScope;
+}
+
+template<class T>
+inline void
+ClearWrapper(T* p, nsWrapperCache* cache)
+{
+ cache->ClearWrapper();
+}
+
+template<class T>
+inline void
+ClearWrapper(T* p, void*)
+{
+ nsWrapperCache* cache;
+ CallQueryInterface(p, &cache);
+ ClearWrapper(p, cache);
+}
+
+template<class T>
+inline void
+UpdateWrapper(T* p, nsWrapperCache* cache, JSObject* obj, const JSObject* old)
+{
+ JS::AutoAssertGCCallback inCallback(obj);
+ cache->UpdateWrapper(obj, old);
+}
+
+template<class T>
+inline void
+UpdateWrapper(T* p, void*, JSObject* obj, const JSObject* old)
+{
+ JS::AutoAssertGCCallback inCallback(obj);
+ nsWrapperCache* cache;
+ CallQueryInterface(p, &cache);
+ UpdateWrapper(p, cache, obj, old);
+}
+
+// Attempt to preserve the wrapper, if any, for a Paris DOM bindings object.
+// Return true if we successfully preserved the wrapper, or there is no wrapper
+// to preserve. In the latter case we don't need to preserve the wrapper, because
+// the object can only be obtained by JS once, or they cannot be meaningfully
+// owned from the native side.
+//
+// This operation will return false only for non-nsISupports cycle-collected
+// objects, because we cannot determine if they are wrappercached or not.
+bool
+TryPreserveWrapper(JSObject* obj);
+
+// Can only be called with a DOM JSClass.
+bool
+InstanceClassHasProtoAtDepth(const js::Class* clasp,
+ uint32_t protoID, uint32_t depth);
+
+// Only set allowNativeWrapper to false if you really know you need it, if in
+// doubt use true. Setting it to false disables security wrappers.
+bool
+XPCOMObjectToJsval(JSContext* cx, JS::Handle<JSObject*> scope,
+ xpcObjectHelper& helper, const nsIID* iid,
+ bool allowNativeWrapper, JS::MutableHandle<JS::Value> rval);
+
+// Special-cased wrapping for variants
+bool
+VariantToJsval(JSContext* aCx, nsIVariant* aVariant,
+ JS::MutableHandle<JS::Value> aRetval);
+
+// Wrap an object "p" which is not using WebIDL bindings yet. This _will_
+// actually work on WebIDL binding objects that are wrappercached, but will be
+// much slower than GetOrCreateDOMReflector. "cache" must either be null or be
+// the nsWrapperCache for "p".
+template<class T>
+inline bool
+WrapObject(JSContext* cx, T* p, nsWrapperCache* cache, const nsIID* iid,
+ JS::MutableHandle<JS::Value> rval)
+{
+ if (xpc_FastGetCachedWrapper(cx, cache, rval))
+ return true;
+ qsObjectHelper helper(p, cache);
+ JS::Rooted<JSObject*> scope(cx, JS::CurrentGlobalOrNull(cx));
+ return XPCOMObjectToJsval(cx, scope, helper, iid, true, rval);
+}
+
+// A specialization of the above for nsIVariant, because that needs to
+// do something different.
+template<>
+inline bool
+WrapObject<nsIVariant>(JSContext* cx, nsIVariant* p,
+ nsWrapperCache* cache, const nsIID* iid,
+ JS::MutableHandle<JS::Value> rval)
+{
+ MOZ_ASSERT(iid);
+ MOZ_ASSERT(iid->Equals(NS_GET_IID(nsIVariant)));
+ return VariantToJsval(cx, p, rval);
+}
+
+// Wrap an object "p" which is not using WebIDL bindings yet. Just like the
+// variant that takes an nsWrapperCache above, but will try to auto-derive the
+// nsWrapperCache* from "p".
+template<class T>
+inline bool
+WrapObject(JSContext* cx, T* p, const nsIID* iid,
+ JS::MutableHandle<JS::Value> rval)
+{
+ return WrapObject(cx, p, GetWrapperCache(p), iid, rval);
+}
+
+// Just like the WrapObject above, but without requiring you to pick which
+// interface you're wrapping as. This should only be used for objects that have
+// classinfo, for which it doesn't matter what IID is used to wrap.
+template<class T>
+inline bool
+WrapObject(JSContext* cx, T* p, JS::MutableHandle<JS::Value> rval)
+{
+ return WrapObject(cx, p, nullptr, rval);
+}
+
+// Helper to make it possible to wrap directly out of an nsCOMPtr
+template<class T>
+inline bool
+WrapObject(JSContext* cx, const nsCOMPtr<T>& p,
+ const nsIID* iid, JS::MutableHandle<JS::Value> rval)
+{
+ return WrapObject(cx, p.get(), iid, rval);
+}
+
+// Helper to make it possible to wrap directly out of an nsCOMPtr
+template<class T>
+inline bool
+WrapObject(JSContext* cx, const nsCOMPtr<T>& p,
+ JS::MutableHandle<JS::Value> rval)
+{
+ return WrapObject(cx, p, nullptr, rval);
+}
+
+// Helper to make it possible to wrap directly out of an nsRefPtr
+template<class T>
+inline bool
+WrapObject(JSContext* cx, const RefPtr<T>& p,
+ const nsIID* iid, JS::MutableHandle<JS::Value> rval)
+{
+ return WrapObject(cx, p.get(), iid, rval);
+}
+
+// Helper to make it possible to wrap directly out of an nsRefPtr
+template<class T>
+inline bool
+WrapObject(JSContext* cx, const RefPtr<T>& p,
+ JS::MutableHandle<JS::Value> rval)
+{
+ return WrapObject(cx, p, nullptr, rval);
+}
+
+// Specialization to make it easy to use WrapObject in codegen.
+template<>
+inline bool
+WrapObject<JSObject>(JSContext* cx, JSObject* p,
+ JS::MutableHandle<JS::Value> rval)
+{
+ rval.set(JS::ObjectOrNullValue(p));
+ return true;
+}
+
+inline bool
+WrapObject(JSContext* cx, JSObject& p, JS::MutableHandle<JS::Value> rval)
+{
+ rval.set(JS::ObjectValue(p));
+ return true;
+}
+
+// Given an object "p" that inherits from nsISupports, wrap it and return the
+// result. Null is returned on wrapping failure. This is somewhat similar to
+// WrapObject() above, but does NOT allow Xrays around the result, since we
+// don't want those for our parent object.
+template<typename T>
+static inline JSObject*
+WrapNativeISupports(JSContext* cx, T* p, nsWrapperCache* cache)
+{
+ qsObjectHelper helper(ToSupports(p), cache);
+ JS::Rooted<JSObject*> scope(cx, JS::CurrentGlobalOrNull(cx));
+ JS::Rooted<JS::Value> v(cx);
+ return XPCOMObjectToJsval(cx, scope, helper, nullptr, false, &v) ?
+ v.toObjectOrNull() :
+ nullptr;
+}
+
+
+// Fallback for when our parent is not a WebIDL binding object.
+template<typename T, bool isISupports=IsBaseOf<nsISupports, T>::value>
+struct WrapNativeFallback
+{
+ static inline JSObject* Wrap(JSContext* cx, T* parent, nsWrapperCache* cache)
+ {
+ return nullptr;
+ }
+};
+
+// Fallback for when our parent is not a WebIDL binding object but _is_ an
+// nsISupports object.
+template<typename T >
+struct WrapNativeFallback<T, true >
+{
+ static inline JSObject* Wrap(JSContext* cx, T* parent, nsWrapperCache* cache)
+ {
+ return WrapNativeISupports(cx, parent, cache);
+ }
+};
+
+// Wrapping of our native parent, for cases when it's a WebIDL object (though
+// possibly preffed off).
+template<typename T, bool hasWrapObject=NativeHasMember<T>::WrapObject>
+struct WrapNativeHelper
+{
+ static inline JSObject* Wrap(JSContext* cx, T* parent, nsWrapperCache* cache)
+ {
+ MOZ_ASSERT(cache);
+
+ JSObject* obj;
+ if ((obj = cache->GetWrapper())) {
+ // GetWrapper always unmarks gray.
+ MOZ_ASSERT(!JS::ObjectIsMarkedGray(obj));
+ return obj;
+ }
+
+ // Inline this here while we have non-dom objects in wrapper caches.
+ if (!CouldBeDOMBinding(parent)) {
+ // WrapNativeFallback never returns a gray thing.
+ obj = WrapNativeFallback<T>::Wrap(cx, parent, cache);
+ MOZ_ASSERT_IF(obj, !JS::ObjectIsMarkedGray(obj));
+ } else {
+ // WrapObject never returns a gray thing.
+ obj = parent->WrapObject(cx, nullptr);
+ MOZ_ASSERT_IF(obj, !JS::ObjectIsMarkedGray(obj));
+ }
+
+ return obj;
+ }
+};
+
+// Wrapping of our native parent, for cases when it's not a WebIDL object. In
+// this case it must be nsISupports.
+template<typename T>
+struct WrapNativeHelper<T, false>
+{
+ static inline JSObject* Wrap(JSContext* cx, T* parent, nsWrapperCache* cache)
+ {
+ JSObject* obj;
+ if (cache && (obj = cache->GetWrapper())) {
+#ifdef DEBUG
+ JS::Rooted<JSObject*> rootedObj(cx, obj);
+ NS_ASSERTION(WrapNativeISupports(cx, parent, cache) == rootedObj,
+ "Unexpected object in nsWrapperCache");
+ obj = rootedObj;
+#endif
+ MOZ_ASSERT(!JS::ObjectIsMarkedGray(obj));
+ return obj;
+ }
+
+ obj = WrapNativeISupports(cx, parent, cache);
+ MOZ_ASSERT_IF(obj, !JS::ObjectIsMarkedGray(obj));
+ return obj;
+ }
+};
+
+// Finding the associated global for an object.
+template<typename T>
+static inline JSObject*
+FindAssociatedGlobal(JSContext* cx, T* p, nsWrapperCache* cache,
+ bool useXBLScope = false)
+{
+ if (!p) {
+ return JS::CurrentGlobalOrNull(cx);
+ }
+
+ JSObject* obj = WrapNativeHelper<T>::Wrap(cx, p, cache);
+ if (!obj) {
+ return nullptr;
+ }
+ MOZ_ASSERT(!JS::ObjectIsMarkedGray(obj));
+
+ obj = js::GetGlobalForObjectCrossCompartment(obj);
+
+ if (!useXBLScope) {
+ return obj;
+ }
+
+ // If useXBLScope is true, it means that the canonical reflector for this
+ // native object should live in the content XBL scope. Note that we never put
+ // anonymous content inside an add-on scope.
+ if (xpc::IsInContentXBLScope(obj)) {
+ return obj;
+ }
+ JS::Rooted<JSObject*> rootedObj(cx, obj);
+ JSObject* xblScope = xpc::GetXBLScope(cx, rootedObj);
+ MOZ_ASSERT_IF(xblScope, JS_IsGlobalObject(xblScope));
+ MOZ_ASSERT_IF(xblScope, !JS::ObjectIsMarkedGray(xblScope));
+ return xblScope;
+}
+
+// Finding of the associated global for an object, when we don't want to
+// explicitly pass in things like the nsWrapperCache for it.
+template<typename T>
+static inline JSObject*
+FindAssociatedGlobal(JSContext* cx, const T& p)
+{
+ return FindAssociatedGlobal(cx, GetParentPointer(p), GetWrapperCache(p), GetUseXBLScope(p));
+}
+
+// Specialization for the case of nsIGlobalObject, since in that case
+// we can just get the JSObject* directly.
+template<>
+inline JSObject*
+FindAssociatedGlobal(JSContext* cx, nsIGlobalObject* const& p)
+{
+ if (!p) {
+ return JS::CurrentGlobalOrNull(cx);
+ }
+
+ JSObject* global = p->GetGlobalJSObject();
+ if (!global) {
+ return nullptr;
+ }
+
+ MOZ_ASSERT(JS_IsGlobalObject(global));
+ // This object could be gray if the nsIGlobalObject is the only thing keeping
+ // it alive.
+ JS::ExposeObjectToActiveJS(global);
+ return global;
+}
+
+template<typename T,
+ bool hasAssociatedGlobal=NativeHasMember<T>::GetParentObject>
+struct FindAssociatedGlobalForNative
+{
+ static JSObject* Get(JSContext* cx, JS::Handle<JSObject*> obj)
+ {
+ MOZ_ASSERT(js::IsObjectInContextCompartment(obj, cx));
+ T* native = UnwrapDOMObject<T>(obj);
+ return FindAssociatedGlobal(cx, native->GetParentObject());
+ }
+};
+
+template<typename T>
+struct FindAssociatedGlobalForNative<T, false>
+{
+ static JSObject* Get(JSContext* cx, JS::Handle<JSObject*> obj)
+ {
+ MOZ_CRASH();
+ return nullptr;
+ }
+};
+
+// Helper for calling GetOrCreateDOMReflector with smart pointers
+// (nsAutoPtr/nsRefPtr/nsCOMPtr) or references.
+template <class T, bool isSmartPtr=IsSmartPtr<T>::value>
+struct GetOrCreateDOMReflectorHelper
+{
+ static inline bool GetOrCreate(JSContext* cx, const T& value,
+ JS::Handle<JSObject*> givenProto,
+ JS::MutableHandle<JS::Value> rval)
+ {
+ return GetOrCreateDOMReflector(cx, value.get(), rval, givenProto);
+ }
+};
+
+template <class T>
+struct GetOrCreateDOMReflectorHelper<T, false>
+{
+ static inline bool GetOrCreate(JSContext* cx, T& value,
+ JS::Handle<JSObject*> givenProto,
+ JS::MutableHandle<JS::Value> rval)
+ {
+ static_assert(IsRefcounted<T>::value, "Don't pass owned classes in here.");
+ return GetOrCreateDOMReflector(cx, &value, rval, givenProto);
+ }
+};
+
+template<class T>
+inline bool
+GetOrCreateDOMReflector(JSContext* cx, T& value,
+ JS::MutableHandle<JS::Value> rval,
+ JS::Handle<JSObject*> givenProto = nullptr)
+{
+ return GetOrCreateDOMReflectorHelper<T>::GetOrCreate(cx, value, givenProto,
+ rval);
+}
+
+// Helper for calling GetOrCreateDOMReflectorNoWrap with smart pointers
+// (nsAutoPtr/nsRefPtr/nsCOMPtr) or references.
+template <class T, bool isSmartPtr=IsSmartPtr<T>::value>
+struct GetOrCreateDOMReflectorNoWrapHelper
+{
+ static inline bool GetOrCreate(JSContext* cx, const T& value,
+ JS::MutableHandle<JS::Value> rval)
+ {
+ return GetOrCreateDOMReflectorNoWrap(cx, value.get(), rval);
+ }
+};
+
+template <class T>
+struct GetOrCreateDOMReflectorNoWrapHelper<T, false>
+{
+ static inline bool GetOrCreate(JSContext* cx, T& value,
+ JS::MutableHandle<JS::Value> rval)
+ {
+ return GetOrCreateDOMReflectorNoWrap(cx, &value, rval);
+ }
+};
+
+template<class T>
+inline bool
+GetOrCreateDOMReflectorNoWrap(JSContext* cx, T& value,
+ JS::MutableHandle<JS::Value> rval)
+{
+ return
+ GetOrCreateDOMReflectorNoWrapHelper<T>::GetOrCreate(cx, value, rval);
+}
+
+template <class T>
+inline JSObject*
+GetCallbackFromCallbackObject(T* aObj)
+{
+ return aObj->Callback();
+}
+
+// Helper for getting the callback JSObject* of a smart ptr around a
+// CallbackObject or a reference to a CallbackObject or something like
+// that.
+template <class T, bool isSmartPtr=IsSmartPtr<T>::value>
+struct GetCallbackFromCallbackObjectHelper
+{
+ static inline JSObject* Get(const T& aObj)
+ {
+ return GetCallbackFromCallbackObject(aObj.get());
+ }
+};
+
+template <class T>
+struct GetCallbackFromCallbackObjectHelper<T, false>
+{
+ static inline JSObject* Get(T& aObj)
+ {
+ return GetCallbackFromCallbackObject(&aObj);
+ }
+};
+
+template<class T>
+inline JSObject*
+GetCallbackFromCallbackObject(T& aObj)
+{
+ return GetCallbackFromCallbackObjectHelper<T>::Get(aObj);
+}
+
+static inline bool
+AtomizeAndPinJSString(JSContext* cx, jsid& id, const char* chars)
+{
+ if (JSString *str = ::JS_AtomizeAndPinString(cx, chars)) {
+ id = INTERNED_STRING_TO_JSID(cx, str);
+ return true;
+ }
+ return false;
+}
+
+// Spec needs a name property
+template <typename Spec>
+static bool
+InitIds(JSContext* cx, const Prefable<Spec>* prefableSpecs, jsid* ids)
+{
+ MOZ_ASSERT(prefableSpecs);
+ MOZ_ASSERT(prefableSpecs->specs);
+ do {
+ // We ignore whether the set of ids is enabled and just intern all the IDs,
+ // because this is only done once per application runtime.
+ Spec* spec = prefableSpecs->specs;
+ do {
+ if (!JS::PropertySpecNameToPermanentId(cx, spec->name, ids)) {
+ return false;
+ }
+ } while (++ids, (++spec)->name);
+
+ // We ran out of ids for that pref. Put a JSID_VOID in on the id
+ // corresponding to the list terminator for the pref.
+ *ids = JSID_VOID;
+ ++ids;
+ } while ((++prefableSpecs)->specs);
+
+ return true;
+}
+
+bool
+QueryInterface(JSContext* cx, unsigned argc, JS::Value* vp);
+
+template <class T>
+struct
+WantsQueryInterface
+{
+ static_assert(IsBaseOf<nsISupports, T>::value,
+ "QueryInterface can't work without an nsISupports.");
+ static bool Enabled(JSContext* aCx, JSObject* aGlobal)
+ {
+ return NS_IsMainThread() && IsChromeOrXBL(aCx, aGlobal);
+ }
+};
+
+void
+GetInterfaceImpl(JSContext* aCx, nsIInterfaceRequestor* aRequestor,
+ nsWrapperCache* aCache, nsIJSID* aIID,
+ JS::MutableHandle<JS::Value> aRetval, ErrorResult& aError);
+
+template<class T>
+void
+GetInterface(JSContext* aCx, T* aThis, nsIJSID* aIID,
+ JS::MutableHandle<JS::Value> aRetval, ErrorResult& aError)
+{
+ GetInterfaceImpl(aCx, aThis, aThis, aIID, aRetval, aError);
+}
+
+bool
+UnforgeableValueOf(JSContext* cx, unsigned argc, JS::Value* vp);
+
+bool
+ThrowingConstructor(JSContext* cx, unsigned argc, JS::Value* vp);
+
+bool
+ThrowConstructorWithoutNew(JSContext* cx, const char* name);
+
+bool
+GetPropertyOnPrototype(JSContext* cx, JS::Handle<JSObject*> proxy,
+ JS::Handle<JS::Value> receiver, JS::Handle<jsid> id,
+ bool* found, JS::MutableHandle<JS::Value> vp);
+
+//
+bool
+HasPropertyOnPrototype(JSContext* cx, JS::Handle<JSObject*> proxy,
+ JS::Handle<jsid> id, bool* has);
+
+
+// Append the property names in "names" to "props". If
+// shadowPrototypeProperties is false then skip properties that are also
+// present on the proto chain of proxy. If shadowPrototypeProperties is true,
+// then the "proxy" argument is ignored.
+bool
+AppendNamedPropertyIds(JSContext* cx, JS::Handle<JSObject*> proxy,
+ nsTArray<nsString>& names,
+ bool shadowPrototypeProperties, JS::AutoIdVector& props);
+
+namespace binding_detail {
+
+class FastErrorResult :
+ public mozilla::binding_danger::TErrorResult<
+ mozilla::binding_danger::JustAssertCleanupPolicy>
+{
+};
+
+} // namespace binding_detail
+
+enum StringificationBehavior {
+ eStringify,
+ eEmpty,
+ eNull
+};
+
+template<typename T>
+static inline bool
+ConvertJSValueToString(JSContext* cx, JS::Handle<JS::Value> v,
+ StringificationBehavior nullBehavior,
+ StringificationBehavior undefinedBehavior,
+ T& result)
+{
+ JSString *s;
+ if (v.isString()) {
+ s = v.toString();
+ } else {
+ StringificationBehavior behavior;
+ if (v.isNull()) {
+ behavior = nullBehavior;
+ } else if (v.isUndefined()) {
+ behavior = undefinedBehavior;
+ } else {
+ behavior = eStringify;
+ }
+
+ if (behavior != eStringify) {
+ if (behavior == eEmpty) {
+ result.Truncate();
+ } else {
+ result.SetIsVoid(true);
+ }
+ return true;
+ }
+
+ s = JS::ToString(cx, v);
+ if (!s) {
+ return false;
+ }
+ }
+
+ return AssignJSString(cx, result, s);
+}
+
+void
+NormalizeUSVString(JSContext* aCx, nsAString& aString);
+
+void
+NormalizeUSVString(JSContext* aCx, binding_detail::FakeString& aString);
+
+template<typename T>
+inline bool
+ConvertIdToString(JSContext* cx, JS::HandleId id, T& result, bool& isSymbol)
+{
+ if (MOZ_LIKELY(JSID_IS_STRING(id))) {
+ if (!AssignJSString(cx, result, JSID_TO_STRING(id))) {
+ return false;
+ }
+ } else if (JSID_IS_SYMBOL(id)) {
+ isSymbol = true;
+ return true;
+ } else {
+ JS::RootedValue nameVal(cx, js::IdToValue(id));
+ if (!ConvertJSValueToString(cx, nameVal, eStringify, eStringify, result)) {
+ return false;
+ }
+ }
+ isSymbol = false;
+ return true;
+}
+
+bool
+ConvertJSValueToByteString(JSContext* cx, JS::Handle<JS::Value> v,
+ bool nullable, nsACString& result);
+
+template<typename T>
+void DoTraceSequence(JSTracer* trc, FallibleTArray<T>& seq);
+template<typename T>
+void DoTraceSequence(JSTracer* trc, InfallibleTArray<T>& seq);
+
+// Class used to trace sequences, with specializations for various
+// sequence types.
+template<typename T,
+ bool isDictionary=IsBaseOf<DictionaryBase, T>::value,
+ bool isTypedArray=IsBaseOf<AllTypedArraysBase, T>::value,
+ bool isOwningUnion=IsBaseOf<AllOwningUnionBase, T>::value>
+class SequenceTracer
+{
+ explicit SequenceTracer() = delete; // Should never be instantiated
+};
+
+// sequence<object> or sequence<object?>
+template<>
+class SequenceTracer<JSObject*, false, false, false>
+{
+ explicit SequenceTracer() = delete; // Should never be instantiated
+
+public:
+ static void TraceSequence(JSTracer* trc, JSObject** objp, JSObject** end) {
+ for (; objp != end; ++objp) {
+ JS::UnsafeTraceRoot(trc, objp, "sequence<object>");
+ }
+ }
+};
+
+// sequence<any>
+template<>
+class SequenceTracer<JS::Value, false, false, false>
+{
+ explicit SequenceTracer() = delete; // Should never be instantiated
+
+public:
+ static void TraceSequence(JSTracer* trc, JS::Value* valp, JS::Value* end) {
+ for (; valp != end; ++valp) {
+ JS::UnsafeTraceRoot(trc, valp, "sequence<any>");
+ }
+ }
+};
+
+// sequence<sequence<T>>
+template<typename T>
+class SequenceTracer<Sequence<T>, false, false, false>
+{
+ explicit SequenceTracer() = delete; // Should never be instantiated
+
+public:
+ static void TraceSequence(JSTracer* trc, Sequence<T>* seqp, Sequence<T>* end) {
+ for (; seqp != end; ++seqp) {
+ DoTraceSequence(trc, *seqp);
+ }
+ }
+};
+
+// sequence<sequence<T>> as return value
+template<typename T>
+class SequenceTracer<nsTArray<T>, false, false, false>
+{
+ explicit SequenceTracer() = delete; // Should never be instantiated
+
+public:
+ static void TraceSequence(JSTracer* trc, nsTArray<T>* seqp, nsTArray<T>* end) {
+ for (; seqp != end; ++seqp) {
+ DoTraceSequence(trc, *seqp);
+ }
+ }
+};
+
+// sequence<someDictionary>
+template<typename T>
+class SequenceTracer<T, true, false, false>
+{
+ explicit SequenceTracer() = delete; // Should never be instantiated
+
+public:
+ static void TraceSequence(JSTracer* trc, T* dictp, T* end) {
+ for (; dictp != end; ++dictp) {
+ dictp->TraceDictionary(trc);
+ }
+ }
+};
+
+// sequence<SomeTypedArray>
+template<typename T>
+class SequenceTracer<T, false, true, false>
+{
+ explicit SequenceTracer() = delete; // Should never be instantiated
+
+public:
+ static void TraceSequence(JSTracer* trc, T* arrayp, T* end) {
+ for (; arrayp != end; ++arrayp) {
+ arrayp->TraceSelf(trc);
+ }
+ }
+};
+
+// sequence<SomeOwningUnion>
+template<typename T>
+class SequenceTracer<T, false, false, true>
+{
+ explicit SequenceTracer() = delete; // Should never be instantiated
+
+public:
+ static void TraceSequence(JSTracer* trc, T* arrayp, T* end) {
+ for (; arrayp != end; ++arrayp) {
+ arrayp->TraceUnion(trc);
+ }
+ }
+};
+
+// sequence<T?> with T? being a Nullable<T>
+template<typename T>
+class SequenceTracer<Nullable<T>, false, false, false>
+{
+ explicit SequenceTracer() = delete; // Should never be instantiated
+
+public:
+ static void TraceSequence(JSTracer* trc, Nullable<T>* seqp,
+ Nullable<T>* end) {
+ for (; seqp != end; ++seqp) {
+ if (!seqp->IsNull()) {
+ // Pretend like we actually have a length-one sequence here so
+ // we can do template instantiation correctly for T.
+ T& val = seqp->Value();
+ T* ptr = &val;
+ SequenceTracer<T>::TraceSequence(trc, ptr, ptr+1);
+ }
+ }
+ }
+};
+
+template<typename T>
+static void
+TraceMozMapValue(T* aValue, void* aClosure)
+{
+ JSTracer* trc = static_cast<JSTracer*>(aClosure);
+ // Act like it's a one-element sequence to leverage all that infrastructure.
+ SequenceTracer<T>::TraceSequence(trc, aValue, aValue + 1);
+}
+
+template<typename T>
+void TraceMozMap(JSTracer* trc, MozMap<T>& map)
+{
+ map.EnumerateValues(TraceMozMapValue<T>, trc);
+}
+
+// sequence<MozMap>
+template<typename T>
+class SequenceTracer<MozMap<T>, false, false, false>
+{
+ explicit SequenceTracer() = delete; // Should never be instantiated
+
+public:
+ static void TraceSequence(JSTracer* trc, MozMap<T>* seqp, MozMap<T>* end) {
+ for (; seqp != end; ++seqp) {
+ seqp->EnumerateValues(TraceMozMapValue<T>, trc);
+ }
+ }
+};
+
+template<typename T>
+void DoTraceSequence(JSTracer* trc, FallibleTArray<T>& seq)
+{
+ SequenceTracer<T>::TraceSequence(trc, seq.Elements(),
+ seq.Elements() + seq.Length());
+}
+
+template<typename T>
+void DoTraceSequence(JSTracer* trc, InfallibleTArray<T>& seq)
+{
+ SequenceTracer<T>::TraceSequence(trc, seq.Elements(),
+ seq.Elements() + seq.Length());
+}
+
+// Rooter class for sequences; this is what we mostly use in the codegen
+template<typename T>
+class MOZ_RAII SequenceRooter final : private JS::CustomAutoRooter
+{
+public:
+ SequenceRooter(JSContext *aCx, FallibleTArray<T>* aSequence
+ MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
+ : JS::CustomAutoRooter(aCx MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT),
+ mFallibleArray(aSequence),
+ mSequenceType(eFallibleArray)
+ {
+ }
+
+ SequenceRooter(JSContext *aCx, InfallibleTArray<T>* aSequence
+ MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
+ : JS::CustomAutoRooter(aCx MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT),
+ mInfallibleArray(aSequence),
+ mSequenceType(eInfallibleArray)
+ {
+ }
+
+ SequenceRooter(JSContext *aCx, Nullable<nsTArray<T> >* aSequence
+ MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
+ : JS::CustomAutoRooter(aCx MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT),
+ mNullableArray(aSequence),
+ mSequenceType(eNullableArray)
+ {
+ }
+
+ private:
+ enum SequenceType {
+ eInfallibleArray,
+ eFallibleArray,
+ eNullableArray
+ };
+
+ virtual void trace(JSTracer *trc) override
+ {
+ if (mSequenceType == eFallibleArray) {
+ DoTraceSequence(trc, *mFallibleArray);
+ } else if (mSequenceType == eInfallibleArray) {
+ DoTraceSequence(trc, *mInfallibleArray);
+ } else {
+ MOZ_ASSERT(mSequenceType == eNullableArray);
+ if (!mNullableArray->IsNull()) {
+ DoTraceSequence(trc, mNullableArray->Value());
+ }
+ }
+ }
+
+ union {
+ InfallibleTArray<T>* mInfallibleArray;
+ FallibleTArray<T>* mFallibleArray;
+ Nullable<nsTArray<T> >* mNullableArray;
+ };
+
+ SequenceType mSequenceType;
+};
+
+// Rooter class for MozMap; this is what we mostly use in the codegen.
+template<typename T>
+class MOZ_RAII MozMapRooter final : private JS::CustomAutoRooter
+{
+public:
+ MozMapRooter(JSContext *aCx, MozMap<T>* aMozMap
+ MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
+ : JS::CustomAutoRooter(aCx MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT),
+ mMozMap(aMozMap),
+ mMozMapType(eMozMap)
+ {
+ }
+
+ MozMapRooter(JSContext *aCx, Nullable<MozMap<T>>* aMozMap
+ MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
+ : JS::CustomAutoRooter(aCx MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT),
+ mNullableMozMap(aMozMap),
+ mMozMapType(eNullableMozMap)
+ {
+ }
+
+private:
+ enum MozMapType {
+ eMozMap,
+ eNullableMozMap
+ };
+
+ virtual void trace(JSTracer *trc) override
+ {
+ if (mMozMapType == eMozMap) {
+ TraceMozMap(trc, *mMozMap);
+ } else {
+ MOZ_ASSERT(mMozMapType == eNullableMozMap);
+ if (!mNullableMozMap->IsNull()) {
+ TraceMozMap(trc, mNullableMozMap->Value());
+ }
+ }
+ }
+
+ union {
+ MozMap<T>* mMozMap;
+ Nullable<MozMap<T>>* mNullableMozMap;
+ };
+
+ MozMapType mMozMapType;
+};
+
+template<typename T>
+class MOZ_RAII RootedUnion : public T,
+ private JS::CustomAutoRooter
+{
+public:
+ explicit RootedUnion(JSContext* cx MOZ_GUARD_OBJECT_NOTIFIER_PARAM) :
+ T(),
+ JS::CustomAutoRooter(cx MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT)
+ {
+ }
+
+ virtual void trace(JSTracer *trc) override
+ {
+ this->TraceUnion(trc);
+ }
+};
+
+template<typename T>
+class MOZ_STACK_CLASS NullableRootedUnion : public Nullable<T>,
+ private JS::CustomAutoRooter
+{
+public:
+ explicit NullableRootedUnion(JSContext* cx MOZ_GUARD_OBJECT_NOTIFIER_PARAM) :
+ Nullable<T>(),
+ JS::CustomAutoRooter(cx MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT)
+ {
+ }
+
+ virtual void trace(JSTracer *trc) override
+ {
+ if (!this->IsNull()) {
+ this->Value().TraceUnion(trc);
+ }
+ }
+};
+
+inline bool
+IdEquals(jsid id, const char* string)
+{
+ return JSID_IS_STRING(id) &&
+ JS_FlatStringEqualsAscii(JSID_TO_FLAT_STRING(id), string);
+}
+
+inline bool
+AddStringToIDVector(JSContext* cx, JS::AutoIdVector& vector, const char* name)
+{
+ return vector.growBy(1) &&
+ AtomizeAndPinJSString(cx, *(vector[vector.length() - 1]).address(), name);
+}
+
+// We use one constructor JSNative to represent all DOM interface objects (so
+// we can easily detect when we need to wrap them in an Xray wrapper). We store
+// the real JSNative in the mNative member of a JSNativeHolder in the
+// CONSTRUCTOR_NATIVE_HOLDER_RESERVED_SLOT slot of the JSFunction object for a
+// specific interface object. We also store the NativeProperties in the
+// JSNativeHolder.
+// Note that some interface objects are not yet a JSFunction but a normal
+// JSObject with a DOMJSClass, those do not use these slots.
+
+enum {
+ CONSTRUCTOR_NATIVE_HOLDER_RESERVED_SLOT = 0
+};
+
+bool
+Constructor(JSContext* cx, unsigned argc, JS::Value* vp);
+
+// Implementation of the bits that XrayWrapper needs
+
+/**
+ * This resolves operations, attributes and constants of the interfaces for obj.
+ *
+ * wrapper is the Xray JS object.
+ * obj is the target object of the Xray, a binding's instance object or a
+ * interface or interface prototype object.
+ */
+bool
+XrayResolveOwnProperty(JSContext* cx, JS::Handle<JSObject*> wrapper,
+ JS::Handle<JSObject*> obj,
+ JS::Handle<jsid> id,
+ JS::MutableHandle<JS::PropertyDescriptor> desc,
+ bool& cacheOnHolder);
+
+/**
+ * Define a property on obj through an Xray wrapper.
+ *
+ * wrapper is the Xray JS object.
+ * obj is the target object of the Xray, a binding's instance object or a
+ * interface or interface prototype object.
+ * id and desc are the parameters for the property to be defined.
+ * result is the out-parameter indicating success (read it only if
+ * this returns true and also sets *defined to true).
+ * defined will be set to true if a property was set as a result of this call.
+ */
+bool
+XrayDefineProperty(JSContext* cx, JS::Handle<JSObject*> wrapper,
+ JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
+ JS::Handle<JS::PropertyDescriptor> desc,
+ JS::ObjectOpResult &result,
+ bool *defined);
+
+/**
+ * Add to props the property keys of all indexed or named properties of obj and
+ * operations, attributes and constants of the interfaces for obj.
+ *
+ * wrapper is the Xray JS object.
+ * obj is the target object of the Xray, a binding's instance object or a
+ * interface or interface prototype object.
+ * flags are JSITER_* flags.
+ */
+bool
+XrayOwnPropertyKeys(JSContext* cx, JS::Handle<JSObject*> wrapper,
+ JS::Handle<JSObject*> obj,
+ unsigned flags, JS::AutoIdVector& props);
+
+/**
+ * Returns the prototype to use for an Xray for a DOM object, wrapped in cx's
+ * compartment. This always returns the prototype that would be used for a DOM
+ * object if we ignore any changes that might have been done to the prototype
+ * chain by JS, the XBL code or plugins.
+ *
+ * cx should be in the Xray's compartment.
+ * obj is the target object of the Xray, a binding's instance object or an
+ * interface or interface prototype object.
+ */
+inline bool
+XrayGetNativeProto(JSContext* cx, JS::Handle<JSObject*> obj,
+ JS::MutableHandle<JSObject*> protop)
+{
+ JS::Rooted<JSObject*> global(cx, js::GetGlobalForObjectCrossCompartment(obj));
+ {
+ JSAutoCompartment ac(cx, global);
+ const DOMJSClass* domClass = GetDOMClass(obj);
+ if (domClass) {
+ ProtoHandleGetter protoGetter = domClass->mGetProto;
+ if (protoGetter) {
+ protop.set(protoGetter(cx));
+ } else {
+ protop.set(JS::GetRealmObjectPrototype(cx));
+ }
+ } else if (JS_ObjectIsFunction(cx, obj)) {
+ MOZ_ASSERT(JS_IsNativeFunction(obj, Constructor));
+ protop.set(JS::GetRealmFunctionPrototype(cx));
+ } else {
+ const js::Class* clasp = js::GetObjectClass(obj);
+ MOZ_ASSERT(IsDOMIfaceAndProtoClass(clasp));
+ ProtoGetter protoGetter =
+ DOMIfaceAndProtoJSClass::FromJSClass(clasp)->mGetParentProto;
+ protop.set(protoGetter(cx));
+ }
+ }
+
+ return JS_WrapObject(cx, protop);
+}
+
+/**
+ * Get the Xray expando class to use for the given DOM object.
+ */
+const JSClass*
+XrayGetExpandoClass(JSContext* cx, JS::Handle<JSObject*> obj);
+
+/**
+ * Delete a named property, if any. Return value is false if exception thrown,
+ * true otherwise. The caller should not do any more work after calling this
+ * function, because it has no way whether a deletion was performed and hence
+ * opresult already has state set on it. If callers ever need to change that,
+ * add a "bool* found" argument and change the generated DeleteNamedProperty to
+ * use it instead of a local variable.
+ */
+bool
+XrayDeleteNamedProperty(JSContext* cx, JS::Handle<JSObject*> wrapper,
+ JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
+ JS::ObjectOpResult& opresult);
+
+/**
+ * Get the object which should be used to cache the return value of a property
+ * getter in the case of a [Cached] or [StoreInSlot] property. `obj` is the
+ * `this` value for our property getter that we're working with.
+ *
+ * This function can return null on failure to allocate the object, throwing on
+ * the JSContext in the process.
+ *
+ * The isXray outparam will be set to true if obj is an Xray and false
+ * otherwise.
+ *
+ * Note that the Slow version should only be called from
+ * GetCachedSlotStorageObject.
+ */
+JSObject*
+GetCachedSlotStorageObjectSlow(JSContext* cx, JS::Handle<JSObject*> obj,
+ bool* isXray);
+
+inline JSObject*
+GetCachedSlotStorageObject(JSContext* cx, JS::Handle<JSObject*> obj,
+ bool* isXray) {
+ if (IsDOMObject(obj)) {
+ *isXray = false;
+ return obj;
+ }
+
+ return GetCachedSlotStorageObjectSlow(cx, obj, isXray);
+}
+
+extern NativePropertyHooks sEmptyNativePropertyHooks;
+
+extern const js::ClassOps sBoringInterfaceObjectClassClassOps;
+
+extern const js::ObjectOps sInterfaceObjectClassObjectOps;
+
+inline bool
+UseDOMXray(JSObject* obj)
+{
+ const js::Class* clasp = js::GetObjectClass(obj);
+ return IsDOMClass(clasp) ||
+ JS_IsNativeFunction(obj, Constructor) ||
+ IsDOMIfaceAndProtoClass(clasp);
+}
+
+#ifdef DEBUG
+inline bool
+HasConstructor(JSObject* obj)
+{
+ return JS_IsNativeFunction(obj, Constructor) ||
+ js::GetObjectClass(obj)->getConstruct();
+}
+#endif
+
+// Helpers for creating a const version of a type.
+template<typename T>
+const T& Constify(T& arg)
+{
+ return arg;
+}
+
+// Helper for turning (Owning)NonNull<T> into T&
+template<typename T>
+T& NonNullHelper(T& aArg)
+{
+ return aArg;
+}
+
+template<typename T>
+T& NonNullHelper(NonNull<T>& aArg)
+{
+ return aArg;
+}
+
+template<typename T>
+const T& NonNullHelper(const NonNull<T>& aArg)
+{
+ return aArg;
+}
+
+template<typename T>
+T& NonNullHelper(OwningNonNull<T>& aArg)
+{
+ return aArg;
+}
+
+template<typename T>
+const T& NonNullHelper(const OwningNonNull<T>& aArg)
+{
+ return aArg;
+}
+
+inline
+void NonNullHelper(NonNull<binding_detail::FakeString>& aArg)
+{
+ // This overload is here to make sure that we never end up applying
+ // NonNullHelper to a NonNull<binding_detail::FakeString>. If we
+ // try to, it should fail to compile, since presumably the caller will try to
+ // use our nonexistent return value.
+}
+
+inline
+void NonNullHelper(const NonNull<binding_detail::FakeString>& aArg)
+{
+ // This overload is here to make sure that we never end up applying
+ // NonNullHelper to a NonNull<binding_detail::FakeString>. If we
+ // try to, it should fail to compile, since presumably the caller will try to
+ // use our nonexistent return value.
+}
+
+inline
+void NonNullHelper(binding_detail::FakeString& aArg)
+{
+ // This overload is here to make sure that we never end up applying
+ // NonNullHelper to a FakeString before we've constified it. If we
+ // try to, it should fail to compile, since presumably the caller will try to
+ // use our nonexistent return value.
+}
+
+MOZ_ALWAYS_INLINE
+const nsAString& NonNullHelper(const binding_detail::FakeString& aArg)
+{
+ return aArg;
+}
+
+// Reparent the wrapper of aObj to whatever its native now thinks its
+// parent should be.
+nsresult
+ReparentWrapper(JSContext* aCx, JS::Handle<JSObject*> aObj);
+
+/**
+ * Used to implement the Symbol.hasInstance property of an interface object.
+ */
+bool
+InterfaceHasInstance(JSContext* cx, unsigned argc, JS::Value* vp);
+
+bool
+InterfaceHasInstance(JSContext* cx, int prototypeID, int depth,
+ JS::Handle<JSObject*> instance,
+ bool* bp);
+
+// Helper for lenient getters/setters to report to console. If this
+// returns false, we couldn't even get a global.
+bool
+ReportLenientThisUnwrappingFailure(JSContext* cx, JSObject* obj);
+
+// Given a JSObject* that represents the chrome side of a JS-implemented WebIDL
+// interface, get the nsIGlobalObject corresponding to the content side, if any.
+// A false return means an exception was thrown.
+bool
+GetContentGlobalForJSImplementedObject(JSContext* cx, JS::Handle<JSObject*> obj,
+ nsIGlobalObject** global);
+
+void
+ConstructJSImplementation(const char* aContractId,
+ nsIGlobalObject* aGlobal,
+ JS::MutableHandle<JSObject*> aObject,
+ ErrorResult& aRv);
+
+already_AddRefed<nsIGlobalObject>
+ConstructJSImplementation(const char* aContractId,
+ const GlobalObject& aGlobal,
+ JS::MutableHandle<JSObject*> aObject,
+ ErrorResult& aRv);
+
+/**
+ * Convert an nsCString to jsval, returning true on success.
+ * These functions are intended for ByteString implementations.
+ * As such, the string is not UTF-8 encoded. Any UTF8 strings passed to these
+ * methods will be mangled.
+ */
+bool NonVoidByteStringToJsval(JSContext *cx, const nsACString &str,
+ JS::MutableHandle<JS::Value> rval);
+inline bool ByteStringToJsval(JSContext *cx, const nsACString &str,
+ JS::MutableHandle<JS::Value> rval)
+{
+ if (str.IsVoid()) {
+ rval.setNull();
+ return true;
+ }
+ return NonVoidByteStringToJsval(cx, str, rval);
+}
+
+template<class T, bool isISupports=IsBaseOf<nsISupports, T>::value>
+struct PreserveWrapperHelper
+{
+ static void PreserveWrapper(T* aObject)
+ {
+ aObject->PreserveWrapper(aObject, NS_CYCLE_COLLECTION_PARTICIPANT(T));
+ }
+};
+
+template<class T>
+struct PreserveWrapperHelper<T, true>
+{
+ static void PreserveWrapper(T* aObject)
+ {
+ aObject->PreserveWrapper(reinterpret_cast<nsISupports*>(aObject));
+ }
+};
+
+template<class T>
+void PreserveWrapper(T* aObject)
+{
+ PreserveWrapperHelper<T>::PreserveWrapper(aObject);
+}
+
+template<class T, bool isISupports=IsBaseOf<nsISupports, T>::value>
+struct CastingAssertions
+{
+ static bool ToSupportsIsCorrect(T*)
+ {
+ return true;
+ }
+ static bool ToSupportsIsOnPrimaryInheritanceChain(T*, nsWrapperCache*)
+ {
+ return true;
+ }
+};
+
+template<class T>
+struct CastingAssertions<T, true>
+{
+ static bool ToSupportsIsCorrect(T* aObject)
+ {
+ return ToSupports(aObject) == reinterpret_cast<nsISupports*>(aObject);
+ }
+ static bool ToSupportsIsOnPrimaryInheritanceChain(T* aObject,
+ nsWrapperCache* aCache)
+ {
+ return reinterpret_cast<void*>(aObject) != aCache;
+ }
+};
+
+template<class T>
+bool
+ToSupportsIsCorrect(T* aObject)
+{
+ return CastingAssertions<T>::ToSupportsIsCorrect(aObject);
+}
+
+template<class T>
+bool
+ToSupportsIsOnPrimaryInheritanceChain(T* aObject, nsWrapperCache* aCache)
+{
+ return CastingAssertions<T>::ToSupportsIsOnPrimaryInheritanceChain(aObject,
+ aCache);
+}
+
+// The BindingJSObjectCreator class is supposed to be used by a caller that
+// wants to create and initialise a binding JSObject. After initialisation has
+// been successfully completed it should call ForgetObject().
+// The BindingJSObjectCreator object will root the JSObject until ForgetObject()
+// is called on it. If the native object for the binding is refcounted it will
+// also hold a strong reference to it, that reference is transferred to the
+// JSObject (which holds the native in a slot) when ForgetObject() is called. If
+// the BindingJSObjectCreator object is destroyed and ForgetObject() was never
+// called on it then the JSObject's slot holding the native will be set to
+// undefined, and for a refcounted native the strong reference will be released.
+template<class T>
+class MOZ_STACK_CLASS BindingJSObjectCreator
+{
+public:
+ explicit BindingJSObjectCreator(JSContext* aCx)
+ : mReflector(aCx)
+ {
+ }
+
+ ~BindingJSObjectCreator()
+ {
+ if (mReflector) {
+ js::SetReservedOrProxyPrivateSlot(mReflector, DOM_OBJECT_SLOT,
+ JS::UndefinedValue());
+ }
+ }
+
+ void
+ CreateProxyObject(JSContext* aCx, const js::Class* aClass,
+ const DOMProxyHandler* aHandler,
+ JS::Handle<JSObject*> aProto, T* aNative,
+ JS::MutableHandle<JSObject*> aReflector)
+ {
+ js::ProxyOptions options;
+ options.setClass(aClass);
+ JS::Rooted<JS::Value> proxyPrivateVal(aCx, JS::PrivateValue(aNative));
+ aReflector.set(js::NewProxyObject(aCx, aHandler, proxyPrivateVal, aProto,
+ options));
+ if (aReflector) {
+ mNative = aNative;
+ mReflector = aReflector;
+ }
+ }
+
+ void
+ CreateObject(JSContext* aCx, const JSClass* aClass,
+ JS::Handle<JSObject*> aProto,
+ T* aNative, JS::MutableHandle<JSObject*> aReflector)
+ {
+ aReflector.set(JS_NewObjectWithGivenProto(aCx, aClass, aProto));
+ if (aReflector) {
+ js::SetReservedSlot(aReflector, DOM_OBJECT_SLOT, JS::PrivateValue(aNative));
+ mNative = aNative;
+ mReflector = aReflector;
+ }
+ }
+
+ void
+ InitializationSucceeded()
+ {
+ void* dummy;
+ mNative.forget(&dummy);
+ mReflector = nullptr;
+ }
+
+private:
+ struct OwnedNative
+ {
+ // Make sure the native objects inherit from NonRefcountedDOMObject so
+ // that we log their ctor and dtor.
+ static_assert(IsBaseOf<NonRefcountedDOMObject, T>::value,
+ "Non-refcounted objects with DOM bindings should inherit "
+ "from NonRefcountedDOMObject.");
+
+ OwnedNative&
+ operator=(T* aNative)
+ {
+ return *this;
+ }
+
+ // This signature sucks, but it's the only one that will make a nsRefPtr
+ // just forget about its pointer without warning.
+ void
+ forget(void**)
+ {
+ }
+ };
+
+ JS::Rooted<JSObject*> mReflector;
+ typename Conditional<IsRefcounted<T>::value, RefPtr<T>, OwnedNative>::Type mNative;
+};
+
+template<class T>
+struct DeferredFinalizerImpl
+{
+ typedef typename Conditional<IsSame<T, nsISupports>::value,
+ nsCOMPtr<T>,
+ typename Conditional<IsRefcounted<T>::value,
+ RefPtr<T>,
+ nsAutoPtr<T>>::Type>::Type SmartPtr;
+ typedef SegmentedVector<SmartPtr> SmartPtrArray;
+
+ static_assert(IsSame<T, nsISupports>::value || !IsBaseOf<nsISupports, T>::value,
+ "nsISupports classes should all use the nsISupports instantiation");
+
+ static inline void
+ AppendAndTake(SegmentedVector<nsCOMPtr<nsISupports>>& smartPtrArray, nsISupports* ptr)
+ {
+ smartPtrArray.InfallibleAppend(dont_AddRef(ptr));
+ }
+ template<class U>
+ static inline void
+ AppendAndTake(SegmentedVector<RefPtr<U>>& smartPtrArray, U* ptr)
+ {
+ smartPtrArray.InfallibleAppend(dont_AddRef(ptr));
+ }
+ template<class U>
+ static inline void
+ AppendAndTake(SegmentedVector<nsAutoPtr<U>>& smartPtrArray, U* ptr)
+ {
+ smartPtrArray.InfallibleAppend(ptr);
+ }
+
+ static void*
+ AppendDeferredFinalizePointer(void* aData, void* aObject)
+ {
+ SmartPtrArray* pointers = static_cast<SmartPtrArray*>(aData);
+ if (!pointers) {
+ pointers = new SmartPtrArray();
+ }
+ AppendAndTake(*pointers, static_cast<T*>(aObject));
+ return pointers;
+ }
+ static bool
+ DeferredFinalize(uint32_t aSlice, void* aData)
+ {
+ MOZ_ASSERT(aSlice > 0, "nonsensical/useless call with aSlice == 0");
+ SmartPtrArray* pointers = static_cast<SmartPtrArray*>(aData);
+ uint32_t oldLen = pointers->Length();
+ if (oldLen < aSlice) {
+ aSlice = oldLen;
+ }
+ uint32_t newLen = oldLen - aSlice;
+ pointers->PopLastN(aSlice);
+ if (newLen == 0) {
+ delete pointers;
+ return true;
+ }
+ return false;
+ }
+};
+
+template<class T,
+ bool isISupports=IsBaseOf<nsISupports, T>::value>
+struct DeferredFinalizer
+{
+ static void
+ AddForDeferredFinalization(T* aObject)
+ {
+ typedef DeferredFinalizerImpl<T> Impl;
+ DeferredFinalize(Impl::AppendDeferredFinalizePointer,
+ Impl::DeferredFinalize, aObject);
+ }
+};
+
+template<class T>
+struct DeferredFinalizer<T, true>
+{
+ static void
+ AddForDeferredFinalization(T* aObject)
+ {
+ DeferredFinalize(reinterpret_cast<nsISupports*>(aObject));
+ }
+};
+
+template<class T>
+static void
+AddForDeferredFinalization(T* aObject)
+{
+ DeferredFinalizer<T>::AddForDeferredFinalization(aObject);
+}
+
+// This returns T's CC participant if it participates in CC or null if it
+// doesn't. This also returns null for classes that don't inherit from
+// nsISupports (QI should be used to get the participant for those).
+template<class T, bool isISupports=IsBaseOf<nsISupports, T>::value>
+class GetCCParticipant
+{
+ // Helper for GetCCParticipant for classes that participate in CC.
+ template<class U>
+ static constexpr nsCycleCollectionParticipant*
+ GetHelper(int, typename U::NS_CYCLE_COLLECTION_INNERCLASS* dummy=nullptr)
+ {
+ return T::NS_CYCLE_COLLECTION_INNERCLASS::GetParticipant();
+ }
+ // Helper for GetCCParticipant for classes that don't participate in CC.
+ template<class U>
+ static constexpr nsCycleCollectionParticipant*
+ GetHelper(double)
+ {
+ return nullptr;
+ }
+
+public:
+ static constexpr nsCycleCollectionParticipant*
+ Get()
+ {
+ // Passing int() here will try to call the GetHelper that takes an int as
+ // its firt argument. If T doesn't participate in CC then substitution for
+ // the second argument (with a default value) will fail and because of
+ // SFINAE the next best match (the variant taking a double) will be called.
+ return GetHelper<T>(int());
+ }
+};
+
+template<class T>
+class GetCCParticipant<T, true>
+{
+public:
+ static constexpr nsCycleCollectionParticipant*
+ Get()
+ {
+ return nullptr;
+ }
+};
+
+void
+FinalizeGlobal(JSFreeOp* aFop, JSObject* aObj);
+
+bool
+ResolveGlobal(JSContext* aCx, JS::Handle<JSObject*> aObj,
+ JS::Handle<jsid> aId, bool* aResolvedp);
+
+bool
+MayResolveGlobal(const JSAtomState& aNames, jsid aId, JSObject* aMaybeObj);
+
+bool
+EnumerateGlobal(JSContext* aCx, JS::Handle<JSObject*> aObj);
+
+template <class T>
+struct CreateGlobalOptions
+{
+ static constexpr ProtoAndIfaceCache::Kind ProtoAndIfaceCacheKind =
+ ProtoAndIfaceCache::NonWindowLike;
+ static void TraceGlobal(JSTracer* aTrc, JSObject* aObj)
+ {
+ mozilla::dom::TraceProtoAndIfaceCache(aTrc, aObj);
+ }
+ static bool PostCreateGlobal(JSContext* aCx, JS::Handle<JSObject*> aGlobal)
+ {
+ MOZ_ALWAYS_TRUE(TryPreserveWrapper(aGlobal));
+
+ return true;
+ }
+};
+
+template <>
+struct CreateGlobalOptions<nsGlobalWindow>
+{
+ static constexpr ProtoAndIfaceCache::Kind ProtoAndIfaceCacheKind =
+ ProtoAndIfaceCache::WindowLike;
+ static void TraceGlobal(JSTracer* aTrc, JSObject* aObj);
+ static bool PostCreateGlobal(JSContext* aCx, JS::Handle<JSObject*> aGlobal);
+};
+
+nsresult
+RegisterDOMNames();
+
+// The return value is true if we created and successfully performed our part of
+// the setup for the global, false otherwise.
+//
+// Typically this method's caller will want to ensure that
+// xpc::InitGlobalObjectOptions is called before, and xpc::InitGlobalObject is
+// called after, this method, to ensure that this global object and its
+// compartment are consistent with other global objects.
+template <class T, ProtoHandleGetter GetProto>
+bool
+CreateGlobal(JSContext* aCx, T* aNative, nsWrapperCache* aCache,
+ const JSClass* aClass, JS::CompartmentOptions& aOptions,
+ JSPrincipals* aPrincipal, bool aInitStandardClasses,
+ JS::MutableHandle<JSObject*> aGlobal)
+{
+ aOptions.creationOptions().setTrace(CreateGlobalOptions<T>::TraceGlobal);
+ if (xpc::SharedMemoryEnabled()) {
+ aOptions.creationOptions().setSharedMemoryAndAtomicsEnabled(true);
+ }
+
+ aGlobal.set(JS_NewGlobalObject(aCx, aClass, aPrincipal,
+ JS::DontFireOnNewGlobalHook, aOptions));
+ if (!aGlobal) {
+ NS_WARNING("Failed to create global");
+ return false;
+ }
+
+ JSAutoCompartment ac(aCx, aGlobal);
+
+ {
+ js::SetReservedSlot(aGlobal, DOM_OBJECT_SLOT, JS::PrivateValue(aNative));
+ NS_ADDREF(aNative);
+
+ aCache->SetWrapper(aGlobal);
+
+ dom::AllocateProtoAndIfaceCache(aGlobal,
+ CreateGlobalOptions<T>::ProtoAndIfaceCacheKind);
+
+ if (!CreateGlobalOptions<T>::PostCreateGlobal(aCx, aGlobal)) {
+ return false;
+ }
+ }
+
+ if (aInitStandardClasses &&
+ !JS_InitStandardClasses(aCx, aGlobal)) {
+ NS_WARNING("Failed to init standard classes");
+ return false;
+ }
+
+ JS::Handle<JSObject*> proto = GetProto(aCx);
+ if (!proto || !JS_SplicePrototype(aCx, aGlobal, proto)) {
+ NS_WARNING("Failed to set proto");
+ return false;
+ }
+
+ bool succeeded;
+ if (!JS_SetImmutablePrototype(aCx, aGlobal, &succeeded)) {
+ return false;
+ }
+ MOZ_ASSERT(succeeded,
+ "making a fresh global object's [[Prototype]] immutable can "
+ "internally fail, but it should never be unsuccessful");
+
+ return true;
+}
+
+/*
+ * Holds a jsid that is initialized to a pinned string, with automatic
+ * conversion to Handle<jsid>, as it is held live forever by pinning.
+ */
+class PinnedStringId
+{
+ jsid id;
+
+ public:
+ PinnedStringId() : id(JSID_VOID) {}
+
+ bool init(JSContext *cx, const char *string) {
+ JSString* str = JS_AtomizeAndPinString(cx, string);
+ if (!str)
+ return false;
+ id = INTERNED_STRING_TO_JSID(cx, str);
+ return true;
+ }
+
+ operator const jsid& () {
+ return id;
+ }
+
+ operator JS::Handle<jsid> () {
+ /* This is safe because we have pinned the string. */
+ return JS::Handle<jsid>::fromMarkedLocation(&id);
+ }
+};
+
+bool
+GenericBindingGetter(JSContext* cx, unsigned argc, JS::Value* vp);
+
+bool
+GenericBindingSetter(JSContext* cx, unsigned argc, JS::Value* vp);
+
+bool
+GenericBindingMethod(JSContext* cx, unsigned argc, JS::Value* vp);
+
+bool
+GenericPromiseReturningBindingMethod(JSContext* cx, unsigned argc, JS::Value* vp);
+
+bool
+StaticMethodPromiseWrapper(JSContext* cx, unsigned argc, JS::Value* vp);
+
+// ConvertExceptionToPromise should only be called when we have an error
+// condition (e.g. returned false from a JSAPI method). Note that there may be
+// no exception on cx, in which case this is an uncatchable failure that will
+// simply be propagated. Otherwise this method will attempt to convert the
+// exception to a Promise rejected with the exception that it will store in
+// rval.
+//
+// promiseScope should be the scope in which the Promise should be created.
+bool
+ConvertExceptionToPromise(JSContext* cx,
+ JSObject* promiseScope,
+ JS::MutableHandle<JS::Value> rval);
+
+#ifdef DEBUG
+void
+AssertReturnTypeMatchesJitinfo(const JSJitInfo* aJitinfo,
+ JS::Handle<JS::Value> aValue);
+#endif
+
+// This function is called by the bindings layer for methods/getters/setters
+// that are not safe to be called in prerendering mode. It checks to make sure
+// that the |this| object is not running in a global that is in prerendering
+// mode. Otherwise, it aborts execution of timers and event handlers, and
+// returns false which gets converted to an uncatchable exception by the
+// bindings layer.
+bool
+EnforceNotInPrerendering(JSContext* aCx, JSObject* aObj);
+
+// Handles the violation of a blacklisted action in prerendering mode by
+// aborting the scripts, and preventing timers and event handlers from running
+// in the window in the future.
+void
+HandlePrerenderingViolation(nsPIDOMWindowInner* aWindow);
+
+bool
+CallerSubsumes(JSObject* aObject);
+
+MOZ_ALWAYS_INLINE bool
+CallerSubsumes(JS::Handle<JS::Value> aValue)
+{
+ if (!aValue.isObject()) {
+ return true;
+ }
+ return CallerSubsumes(&aValue.toObject());
+}
+
+template<class T>
+inline bool
+WrappedJSToDictionary(JSContext* aCx, nsISupports* aObject, T& aDictionary)
+{
+ nsCOMPtr<nsIXPConnectWrappedJS> wrappedObj = do_QueryInterface(aObject);
+ if (!wrappedObj) {
+ return false;
+ }
+
+ JS::Rooted<JSObject*> obj(aCx, wrappedObj->GetJSObject());
+ if (!obj) {
+ return false;
+ }
+
+ JSAutoCompartment ac(aCx, obj);
+ JS::Rooted<JS::Value> v(aCx, JS::ObjectValue(*obj));
+ return aDictionary.Init(aCx, v);
+}
+
+template<class T>
+inline bool
+WrappedJSToDictionary(nsISupports* aObject, T& aDictionary)
+{
+ nsCOMPtr<nsIXPConnectWrappedJS> wrappedObj = do_QueryInterface(aObject);
+ NS_ENSURE_TRUE(wrappedObj, false);
+ JS::Rooted<JSObject*> obj(RootingCx(), wrappedObj->GetJSObject());
+ NS_ENSURE_TRUE(obj, false);
+
+ nsIGlobalObject* global = xpc::NativeGlobal(obj);
+ NS_ENSURE_TRUE(global, false);
+
+ // we need this AutoEntryScript here because the spec requires us to execute
+ // getters when parsing a dictionary
+ AutoEntryScript aes(global, "WebIDL dictionary creation");
+
+ JS::Rooted<JS::Value> v(aes.cx(), JS::ObjectValue(*obj));
+ return aDictionary.Init(aes.cx(), v);
+}
+
+
+template<class T, class S>
+inline RefPtr<T>
+StrongOrRawPtr(already_AddRefed<S>&& aPtr)
+{
+ return aPtr.template downcast<T>();
+}
+
+template<class T,
+ class ReturnType=typename Conditional<IsRefcounted<T>::value, T*,
+ nsAutoPtr<T>>::Type>
+inline ReturnType
+StrongOrRawPtr(T* aPtr)
+{
+ return ReturnType(aPtr);
+}
+
+template<class T, template<typename> class SmartPtr, class S>
+inline void
+StrongOrRawPtr(SmartPtr<S>&& aPtr) = delete;
+
+template<class T>
+struct StrongPtrForMember
+{
+ typedef typename Conditional<IsRefcounted<T>::value,
+ RefPtr<T>, nsAutoPtr<T>>::Type Type;
+};
+
+namespace binding_detail {
+inline
+JSObject*
+GetHackedNamespaceProtoObject(JSContext* aCx)
+{
+ return JS_NewPlainObject(aCx);
+}
+} // namespace binding_detail
+
+// Resolve an id on the given global object that wants to be included in
+// Exposed=System webidl annotations. False return value means exception
+// thrown.
+bool SystemGlobalResolve(JSContext* cx, JS::Handle<JSObject*> obj,
+ JS::Handle<jsid> id, bool* resolvedp);
+
+// Enumerate all ids on the given global object that wants to be included in
+// Exposed=System webidl annotations. False return value means exception
+// thrown.
+bool SystemGlobalEnumerate(JSContext* cx, JS::Handle<JSObject*> obj);
+
+// Slot indexes for maplike/setlike forEach functions
+#define FOREACH_CALLBACK_SLOT 0
+#define FOREACH_MAPLIKEORSETLIKEOBJ_SLOT 1
+
+// Backing function for running .forEach() on maplike/setlike interfaces.
+// Unpacks callback and maplike/setlike object from reserved slots, then runs
+// callback for each key (and value, for maplikes)
+bool ForEachHandler(JSContext* aCx, unsigned aArgc, JS::Value* aVp);
+
+// Unpacks backing object (ES6 map/set) from the reserved slot of a reflector
+// for a maplike/setlike interface. If backing object does not exist, creates
+// backing object in the compartment of the reflector involved, making this safe
+// to use across compartments/via xrays. Return values of these methods will
+// always be in the context compartment.
+bool GetMaplikeBackingObject(JSContext* aCx, JS::Handle<JSObject*> aObj,
+ size_t aSlotIndex,
+ JS::MutableHandle<JSObject*> aBackingObj,
+ bool* aBackingObjCreated);
+bool GetSetlikeBackingObject(JSContext* aCx, JS::Handle<JSObject*> aObj,
+ size_t aSlotIndex,
+ JS::MutableHandle<JSObject*> aBackingObj,
+ bool* aBackingObjCreated);
+
+// Get the desired prototype object for an object construction from the given
+// CallArgs. Null is returned if the default prototype should be used.
+bool
+GetDesiredProto(JSContext* aCx, const JS::CallArgs& aCallArgs,
+ JS::MutableHandle<JSObject*> aDesiredProto);
+
+void
+SetDocumentAndPageUseCounter(JSContext* aCx, JSObject* aObject,
+ UseCounter aUseCounter);
+
+// Warnings
+void
+DeprecationWarning(JSContext* aCx, JSObject* aObject,
+ nsIDocument::DeprecatedOperations aOperation);
+
+// A callback to perform funToString on an interface object
+JSString*
+InterfaceObjectToString(JSContext* aCx, JS::Handle<JSObject*> aObject,
+ unsigned /* indent */);
+
+namespace binding_detail {
+// Get a JS global object that can be used for some temporary allocations. The
+// idea is that this should be used for situations when you need to operate in
+// _some_ compartment but don't care which one. A typical example is when you
+// have non-JS input, non-JS output, but have to go through some sort of JS
+// representation in the middle, so need a compartment to allocate things in.
+//
+// It's VERY important that any consumers of this function only do things that
+// are guaranteed to be side-effect-free, even in the face of a script
+// environment controlled by a hostile adversary. This is because in the worker
+// case the global is in fact the worker global, so it and its standard objects
+// are controlled by the worker script. This is why this function is in the
+// binding_detail namespace. Any use of this function MUST be very carefully
+// reviewed by someone who is sufficiently devious and has a very good
+// understanding of all the code that will run while we're using the return
+// value, including the SpiderMonkey parts.
+JSObject* UnprivilegedJunkScopeOrWorkerGlobal();
+} // namespace binding_detail
+
+} // namespace dom
+} // namespace mozilla
+
+#endif /* mozilla_dom_BindingUtils_h__ */