The Tor Browser: dom/bindings/DOMJSClass.h@6474c204b198 (annotated)

dom/bindings/DOMJSClass.h@6474c204b198 (annotated)

dom/bindings/DOMJSClass.h

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

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

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

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-*/
 /* 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_DOMJSClass_h
 #define mozilla_dom_DOMJSClass_h
 #include "jsfriendapi.h"
 #include "mozilla/Assertions.h"
 #include "mozilla/dom/PrototypeList.h" // auto-generated
 #include "mozilla/dom/JSSlots.h"
 class nsCycleCollectionParticipant;
 // All DOM globals must have a slot at DOM_PROTOTYPE_SLOT.
 #define DOM_PROTOTYPE_SLOT JSCLASS_GLOBAL_SLOT_COUNT
 // Keep this count up to date with any extra global slots added above.
 #define DOM_GLOBAL_SLOTS 1
 // We use these flag bits for the new bindings.
 #define JSCLASS_DOM_GLOBAL JSCLASS_USERBIT1
 #define JSCLASS_IS_DOMIFACEANDPROTOJSCLASS JSCLASS_USERBIT2
 namespace mozilla {
 namespace dom {
 typedef bool
 (* ResolveOwnProperty)(JSContext* cx, JS::Handle<JSObject*> wrapper,
                        JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
                        JS::MutableHandle<JSPropertyDescriptor> desc);
 typedef bool
 (* EnumerateOwnProperties)(JSContext* cx, JS::Handle<JSObject*> wrapper,
                            JS::Handle<JSObject*> obj,
                            JS::AutoIdVector& props);
 struct ConstantSpec
 {
   const char* name;
   JS::Value value;
 };
 typedef bool (*PropertyEnabled)(JSContext* cx, JSObject* global);
 template<typename T>
 struct Prefable {
   inline bool isEnabled(JSContext* cx, JSObject* obj) const {
     if (!enabled) {
       return false;
     }
     if (!enabledFunc && !availableFunc) {
       return true;
     }
     // Just go ahead and root obj, in case enabledFunc GCs
     JS::Rooted<JSObject*> rootedObj(cx, obj);
     if (enabledFunc &&
         !enabledFunc(cx, js::GetGlobalForObjectCrossCompartment(rootedObj))) {
       return false;
     }
     if (availableFunc &&
         !availableFunc(cx, js::GetGlobalForObjectCrossCompartment(rootedObj))) {
       return false;
     }
     return true;
   }
   // A boolean indicating whether this set of specs is enabled
   bool enabled;
   // A function pointer to a function that can say the property is disabled
   // even if "enabled" is set to true.  If the pointer is null the value of
   // "enabled" is used as-is unless availableFunc overrides.
   PropertyEnabled enabledFunc;
   // A function pointer to a function that can be used to disable a
   // property even if "enabled" is true and enabledFunc allowed.  This
   // is basically a hack to avoid having to codegen PropertyEnabled
   // implementations in case when we need to do two separate checks.
   PropertyEnabled availableFunc;
   // Array of specs, terminated in whatever way is customary for T.
   // Null to indicate a end-of-array for Prefable, when such an
   // indicator is needed.
   const T* specs;
 };
 struct NativeProperties
 {
   const Prefable<const JSFunctionSpec>* staticMethods;
   jsid* staticMethodIds;
   const JSFunctionSpec* staticMethodsSpecs;
   const Prefable<const JSPropertySpec>* staticAttributes;
   jsid* staticAttributeIds;
   const JSPropertySpec* staticAttributeSpecs;
   const Prefable<const JSFunctionSpec>* methods;
   jsid* methodIds;
   const JSFunctionSpec* methodsSpecs;
   const Prefable<const JSPropertySpec>* attributes;
   jsid* attributeIds;
   const JSPropertySpec* attributeSpecs;
   const Prefable<const JSPropertySpec>* unforgeableAttributes;
   jsid* unforgeableAttributeIds;
   const JSPropertySpec* unforgeableAttributeSpecs;
   const Prefable<const ConstantSpec>* constants;
   jsid* constantIds;
   const ConstantSpec* constantSpecs;
 };
 struct NativePropertiesHolder
 {
   const NativeProperties* regular;
   const NativeProperties* chromeOnly;
 };
 // Helper structure for Xrays for DOM binding objects. The same instance is used
 // for instances, interface objects and interface prototype objects of a
 // specific interface.
 struct NativePropertyHooks
 {
   // The hook to call for resolving indexed or named properties. May be null if
   // there can't be any.
   ResolveOwnProperty mResolveOwnProperty;
   // The hook to call for enumerating indexed or named properties. May be null
   // if there can't be any.
   EnumerateOwnProperties mEnumerateOwnProperties;
   // The property arrays for this interface.
   NativePropertiesHolder mNativeProperties;
   // This will be set to the ID of the interface prototype object for the
   // interface, if it has one. If it doesn't have one it will be set to
   // prototypes::id::_ID_Count.
   prototypes::ID mPrototypeID;
   // This will be set to the ID of the interface object for the interface, if it
   // has one. If it doesn't have one it will be set to
   // constructors::id::_ID_Count.
   constructors::ID mConstructorID;
   // The NativePropertyHooks instance for the parent interface.
   const NativePropertyHooks* mProtoHooks;
 };
 enum DOMObjectType {
   eInstance,
   eInterface,
   eInterfacePrototype
 };
 typedef JSObject* (*ParentGetter)(JSContext* aCx, JS::Handle<JSObject*> aObj);
 /**
  * Returns a handle to the relevent WebIDL prototype object for the given global
  * (which may be a handle to null on out of memory).  Once allocated, the
  * prototype object is guaranteed to exist as long as the global does, since the
  * global traces its array of WebIDL prototypes and constructors.
  */
 typedef JS::Handle<JSObject*> (*ProtoGetter)(JSContext* aCx,
                                              JS::Handle<JSObject*> aGlobal);
 struct DOMClass
 {
   // A list of interfaces that this object implements, in order of decreasing
   // derivedness.
   const prototypes::ID mInterfaceChain[MAX_PROTOTYPE_CHAIN_LENGTH];
   // We store the DOM object in reserved slot with index DOM_OBJECT_SLOT or in
   // the proxy private if we use a proxy object.
   // Sometimes it's an nsISupports and sometimes it's not; this class tells
   // us which it is.
   const bool mDOMObjectIsISupports;
   const NativePropertyHooks* mNativeHooks;
   ParentGetter mGetParent;
   ProtoGetter mGetProto;
   // This stores the CC participant for the native, null if this class is for a
   // worker or for a native inheriting from nsISupports (we can get the CC
   // participant by QI'ing in that case).
   nsCycleCollectionParticipant* mParticipant;
 };
 // Special JSClass for reflected DOM objects.
 struct DOMJSClass
 {
   // It would be nice to just inherit from JSClass, but that precludes pure
   // compile-time initialization of the form |DOMJSClass = {...};|, since C++
   // only allows brace initialization for aggregate/POD types.
   const js::Class mBase;
   const DOMClass mClass;
   static const DOMJSClass* FromJSClass(const JSClass* base) {
     MOZ_ASSERT(base->flags & JSCLASS_IS_DOMJSCLASS);
     return reinterpret_cast<const DOMJSClass*>(base);
   }
   static const DOMJSClass* FromJSClass(const js::Class* base) {
     return FromJSClass(Jsvalify(base));
   }
   const JSClass* ToJSClass() const { return Jsvalify(&mBase); }
 };
 // Special JSClass for DOM interface and interface prototype objects.
 struct DOMIfaceAndProtoJSClass
 {
   // It would be nice to just inherit from JSClass, but that precludes pure
   // compile-time initialization of the form
   // |DOMJSInterfaceAndPrototypeClass = {...};|, since C++ only allows brace
   // initialization for aggregate/POD types.
   const JSClass mBase;
   // Either eInterface or eInterfacePrototype
   DOMObjectType mType;
   const NativePropertyHooks* mNativeHooks;
   // The value to return for toString() on this interface or interface prototype
   // object.
   const char* mToString;
   const prototypes::ID mPrototypeID;
   const uint32_t mDepth;
   static const DOMIfaceAndProtoJSClass* FromJSClass(const JSClass* base) {
     MOZ_ASSERT(base->flags & JSCLASS_IS_DOMIFACEANDPROTOJSCLASS);
     return reinterpret_cast<const DOMIfaceAndProtoJSClass*>(base);
   }
   static const DOMIfaceAndProtoJSClass* FromJSClass(const js::Class* base) {
     return FromJSClass(Jsvalify(base));
   }
   const JSClass* ToJSClass() const { return &mBase; }
 };
 class ProtoAndIfaceCache;
 inline bool
 HasProtoAndIfaceCache(JSObject* global)
 {
   MOZ_ASSERT(js::GetObjectClass(global)->flags & JSCLASS_DOM_GLOBAL);
   // This can be undefined if we GC while creating the global
   return !js::GetReservedSlot(global, DOM_PROTOTYPE_SLOT).isUndefined();
 }
 inline ProtoAndIfaceCache*
 GetProtoAndIfaceCache(JSObject* global)
 {
   MOZ_ASSERT(js::GetObjectClass(global)->flags & JSCLASS_DOM_GLOBAL);
   return static_cast<ProtoAndIfaceCache*>(
     js::GetReservedSlot(global, DOM_PROTOTYPE_SLOT).toPrivate());
 }
 } // namespace dom
 } // namespace mozilla
 #endif /* mozilla_dom_DOMJSClass_h */

The Tor Browser / annotate

dom/bindings/DOMJSClass.h@6474c204b198 (annotated)

dom/bindings/DOMJSClass.h