/* THIS FILE IS AUTOGENERATED FROM WebGLRenderingContext.webidl BY Codegen.py - DO NOT EDIT */ #ifndef mozilla_dom_WebGLRenderingContextBinding_h #define mozilla_dom_WebGLRenderingContextBinding_h #include "js/RootingAPI.h" #include "jsfriendapi.h" #include "jspubtd.h" #include "mozilla/ErrorResult.h" #include "mozilla/dom/BindingDeclarations.h" #include "mozilla/dom/FakeString.h" #include "mozilla/dom/Nullable.h" #include "mozilla/dom/TypedArray.h" #include "mozilla/dom/UnionMember.h" namespace mozilla { class WebGLActiveInfo; struct WebGLActiveInfoAtoms; class WebGLBuffer; struct WebGLBufferAtoms; class WebGLContext; struct WebGLContextAtoms; class WebGLExtensionBlendMinMax; struct WebGLExtensionBlendMinMaxAtoms; class WebGLExtensionColorBufferFloat; struct WebGLExtensionColorBufferFloatAtoms; class WebGLExtensionColorBufferHalfFloat; struct WebGLExtensionColorBufferHalfFloatAtoms; class WebGLExtensionCompressedTextureATC; struct WebGLExtensionCompressedTextureATCAtoms; class WebGLExtensionCompressedTextureES3; struct WebGLExtensionCompressedTextureES3Atoms; class WebGLExtensionCompressedTextureETC1; struct WebGLExtensionCompressedTextureETC1Atoms; class WebGLExtensionCompressedTexturePVRTC; struct WebGLExtensionCompressedTexturePVRTCAtoms; class WebGLExtensionCompressedTextureS3TC; struct WebGLExtensionCompressedTextureS3TCAtoms; class WebGLExtensionDebugRendererInfo; struct WebGLExtensionDebugRendererInfoAtoms; class WebGLExtensionDebugShaders; struct WebGLExtensionDebugShadersAtoms; class WebGLExtensionDepthTexture; struct WebGLExtensionDepthTextureAtoms; class WebGLExtensionDisjointTimerQuery; struct WebGLExtensionDisjointTimerQueryAtoms; class WebGLExtensionDrawBuffers; struct WebGLExtensionDrawBuffersAtoms; class WebGLExtensionElementIndexUint; struct WebGLExtensionElementIndexUintAtoms; class WebGLExtensionFragDepth; struct WebGLExtensionFragDepthAtoms; class WebGLExtensionInstancedArrays; struct WebGLExtensionInstancedArraysAtoms; class WebGLExtensionLoseContext; struct WebGLExtensionLoseContextAtoms; class WebGLExtensionSRGB; struct WebGLExtensionSRGBAtoms; class WebGLExtensionShaderTextureLod; struct WebGLExtensionShaderTextureLodAtoms; class WebGLExtensionStandardDerivatives; struct WebGLExtensionStandardDerivativesAtoms; class WebGLExtensionTextureFilterAnisotropic; struct WebGLExtensionTextureFilterAnisotropicAtoms; class WebGLExtensionTextureFloat; struct WebGLExtensionTextureFloatAtoms; class WebGLExtensionTextureFloatLinear; struct WebGLExtensionTextureFloatLinearAtoms; class WebGLExtensionTextureHalfFloat; struct WebGLExtensionTextureHalfFloatAtoms; class WebGLExtensionTextureHalfFloatLinear; struct WebGLExtensionTextureHalfFloatLinearAtoms; class WebGLExtensionVertexArray; struct WebGLExtensionVertexArrayAtoms; class WebGLFramebuffer; struct WebGLFramebufferAtoms; class WebGLProgram; struct WebGLProgramAtoms; class WebGLQuery; struct WebGLQueryAtoms; class WebGLRenderbuffer; struct WebGLRenderbufferAtoms; class WebGLShader; struct WebGLShaderAtoms; class WebGLShaderPrecisionFormat; struct WebGLShaderPrecisionFormatAtoms; class WebGLTexture; struct WebGLTextureAtoms; class WebGLUniformLocation; struct WebGLUniformLocationAtoms; class WebGLVertexArray; struct WebGLVertexArrayAtoms; namespace dom { class HTMLCanvasElement; struct NativePropertyHooks; class OffscreenCanvas; class OwningHTMLCanvasElementOrOffscreenCanvas; class ProtoAndIfaceCache; struct WebGLContextAttributesAtoms; } // namespace dom } // namespace mozilla namespace mozilla { namespace dom { void ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback, OwningHTMLCanvasElementOrOffscreenCanvas& aUnion, const char* aName, uint32_t aFlags = 0); void ImplCycleCollectionUnlink(OwningHTMLCanvasElementOrOffscreenCanvas& aUnion); class Float32ArrayOrUnrestrictedFloatSequence { friend class Float32ArrayOrUnrestrictedFloatSequenceArgument; enum Type { eUninitialized, eFloat32Array, eUnrestrictedFloatSequence }; union Value { UnionMember > mFloat32Array; UnionMember > mUnrestrictedFloatSequence; }; Type mType; Value mValue; Float32ArrayOrUnrestrictedFloatSequence(const Float32ArrayOrUnrestrictedFloatSequence&) = delete; void operator=(const Float32ArrayOrUnrestrictedFloatSequence&) = delete; public: explicit inline Float32ArrayOrUnrestrictedFloatSequence() : mType(eUninitialized) { } inline ~Float32ArrayOrUnrestrictedFloatSequence() { Uninit(); } inline RootedTypedArray& RawSetAsFloat32Array(JSContext* cx) { if (mType == eFloat32Array) { return mValue.mFloat32Array.Value(); } MOZ_ASSERT(mType == eUninitialized); mType = eFloat32Array; return mValue.mFloat32Array.SetValue(cx); } inline RootedTypedArray& SetAsFloat32Array(JSContext* cx) { if (mType == eFloat32Array) { return mValue.mFloat32Array.Value(); } Uninit(); mType = eFloat32Array; return mValue.mFloat32Array.SetValue(cx); } inline bool IsFloat32Array() const { return mType == eFloat32Array; } inline RootedTypedArray& GetAsFloat32Array() { MOZ_ASSERT(IsFloat32Array(), "Wrong type!"); return mValue.mFloat32Array.Value(); } inline Float32Array const & GetAsFloat32Array() const { MOZ_ASSERT(IsFloat32Array(), "Wrong type!"); return mValue.mFloat32Array.Value(); } inline binding_detail::AutoSequence& RawSetAsUnrestrictedFloatSequence() { if (mType == eUnrestrictedFloatSequence) { return mValue.mUnrestrictedFloatSequence.Value(); } MOZ_ASSERT(mType == eUninitialized); mType = eUnrestrictedFloatSequence; return mValue.mUnrestrictedFloatSequence.SetValue(); } inline binding_detail::AutoSequence& SetAsUnrestrictedFloatSequence() { if (mType == eUnrestrictedFloatSequence) { return mValue.mUnrestrictedFloatSequence.Value(); } Uninit(); mType = eUnrestrictedFloatSequence; return mValue.mUnrestrictedFloatSequence.SetValue(); } inline bool IsUnrestrictedFloatSequence() const { return mType == eUnrestrictedFloatSequence; } inline binding_detail::AutoSequence& GetAsUnrestrictedFloatSequence() { MOZ_ASSERT(IsUnrestrictedFloatSequence(), "Wrong type!"); return mValue.mUnrestrictedFloatSequence.Value(); } inline const Sequence& GetAsUnrestrictedFloatSequence() const { MOZ_ASSERT(IsUnrestrictedFloatSequence(), "Wrong type!"); return mValue.mUnrestrictedFloatSequence.Value(); } inline void Uninit() { switch (mType) { case eUninitialized: { break; } case eFloat32Array: { DestroyFloat32Array(); break; } case eUnrestrictedFloatSequence: { DestroyUnrestrictedFloatSequence(); break; } } } bool ToJSVal(JSContext* cx, JS::Handle scopeObj, JS::MutableHandle rval) const; private: inline void DestroyFloat32Array() { MOZ_ASSERT(IsFloat32Array(), "Wrong type!"); mValue.mFloat32Array.Destroy(); mType = eUninitialized; } inline void DestroyUnrestrictedFloatSequence() { MOZ_ASSERT(IsUnrestrictedFloatSequence(), "Wrong type!"); mValue.mUnrestrictedFloatSequence.Destroy(); mType = eUninitialized; } }; class OwningFloat32ArrayOrUnrestrictedFloatSequence : public AllOwningUnionBase { friend void ImplCycleCollectionUnlink(OwningFloat32ArrayOrUnrestrictedFloatSequence& aUnion); enum Type { eUninitialized, eFloat32Array, eUnrestrictedFloatSequence }; union Value { UnionMember mFloat32Array; UnionMember > mUnrestrictedFloatSequence; }; Type mType; Value mValue; OwningFloat32ArrayOrUnrestrictedFloatSequence(const OwningFloat32ArrayOrUnrestrictedFloatSequence&) = delete; void operator=(const OwningFloat32ArrayOrUnrestrictedFloatSequence&) = delete; public: explicit inline OwningFloat32ArrayOrUnrestrictedFloatSequence() : mType(eUninitialized) { } inline ~OwningFloat32ArrayOrUnrestrictedFloatSequence() { Uninit(); } Float32Array& RawSetAsFloat32Array(); Float32Array& SetAsFloat32Array(); bool TrySetToFloat32Array(JSContext* cx, JS::Handle value, bool& tryNext, bool passedToJSImpl = false); inline bool IsFloat32Array() const { return mType == eFloat32Array; } inline Float32Array& GetAsFloat32Array() { MOZ_ASSERT(IsFloat32Array(), "Wrong type!"); return mValue.mFloat32Array.Value(); } inline Float32Array const & GetAsFloat32Array() const { MOZ_ASSERT(IsFloat32Array(), "Wrong type!"); return mValue.mFloat32Array.Value(); } Sequence& RawSetAsUnrestrictedFloatSequence(); Sequence& SetAsUnrestrictedFloatSequence(); bool TrySetToUnrestrictedFloatSequence(JSContext* cx, JS::Handle value, bool& tryNext, bool passedToJSImpl = false); inline bool IsUnrestrictedFloatSequence() const { return mType == eUnrestrictedFloatSequence; } inline Sequence& GetAsUnrestrictedFloatSequence() { MOZ_ASSERT(IsUnrestrictedFloatSequence(), "Wrong type!"); return mValue.mUnrestrictedFloatSequence.Value(); } inline Sequence const & GetAsUnrestrictedFloatSequence() const { MOZ_ASSERT(IsUnrestrictedFloatSequence(), "Wrong type!"); return mValue.mUnrestrictedFloatSequence.Value(); } void Uninit(); bool ToJSVal(JSContext* cx, JS::Handle scopeObj, JS::MutableHandle rval) const; void TraceUnion(JSTracer* trc); private: void DestroyFloat32Array(); void DestroyUnrestrictedFloatSequence(); }; class HTMLCanvasElementOrOffscreenCanvas { friend class HTMLCanvasElementOrOffscreenCanvasArgument; enum Type { eUninitialized, eHTMLCanvasElement, eOffscreenCanvas }; union Value { UnionMember > mHTMLCanvasElement; UnionMember > mOffscreenCanvas; }; Type mType; Value mValue; HTMLCanvasElementOrOffscreenCanvas(const HTMLCanvasElementOrOffscreenCanvas&) = delete; void operator=(const HTMLCanvasElementOrOffscreenCanvas&) = delete; public: explicit inline HTMLCanvasElementOrOffscreenCanvas() : mType(eUninitialized) { } inline ~HTMLCanvasElementOrOffscreenCanvas() { Uninit(); } inline NonNull& RawSetAsHTMLCanvasElement() { if (mType == eHTMLCanvasElement) { return mValue.mHTMLCanvasElement.Value(); } MOZ_ASSERT(mType == eUninitialized); mType = eHTMLCanvasElement; return mValue.mHTMLCanvasElement.SetValue(); } inline NonNull& SetAsHTMLCanvasElement() { if (mType == eHTMLCanvasElement) { return mValue.mHTMLCanvasElement.Value(); } Uninit(); mType = eHTMLCanvasElement; return mValue.mHTMLCanvasElement.SetValue(); } inline bool IsHTMLCanvasElement() const { return mType == eHTMLCanvasElement; } inline NonNull& GetAsHTMLCanvasElement() { MOZ_ASSERT(IsHTMLCanvasElement(), "Wrong type!"); return mValue.mHTMLCanvasElement.Value(); } inline mozilla::dom::HTMLCanvasElement& GetAsHTMLCanvasElement() const { MOZ_ASSERT(IsHTMLCanvasElement(), "Wrong type!"); return mValue.mHTMLCanvasElement.Value(); } inline NonNull& RawSetAsOffscreenCanvas() { if (mType == eOffscreenCanvas) { return mValue.mOffscreenCanvas.Value(); } MOZ_ASSERT(mType == eUninitialized); mType = eOffscreenCanvas; return mValue.mOffscreenCanvas.SetValue(); } inline NonNull& SetAsOffscreenCanvas() { if (mType == eOffscreenCanvas) { return mValue.mOffscreenCanvas.Value(); } Uninit(); mType = eOffscreenCanvas; return mValue.mOffscreenCanvas.SetValue(); } inline bool IsOffscreenCanvas() const { return mType == eOffscreenCanvas; } inline NonNull& GetAsOffscreenCanvas() { MOZ_ASSERT(IsOffscreenCanvas(), "Wrong type!"); return mValue.mOffscreenCanvas.Value(); } inline mozilla::dom::OffscreenCanvas& GetAsOffscreenCanvas() const { MOZ_ASSERT(IsOffscreenCanvas(), "Wrong type!"); return mValue.mOffscreenCanvas.Value(); } inline void Uninit() { switch (mType) { case eUninitialized: { break; } case eHTMLCanvasElement: { DestroyHTMLCanvasElement(); break; } case eOffscreenCanvas: { DestroyOffscreenCanvas(); break; } } } bool ToJSVal(JSContext* cx, JS::Handle scopeObj, JS::MutableHandle rval) const; private: inline void DestroyHTMLCanvasElement() { MOZ_ASSERT(IsHTMLCanvasElement(), "Wrong type!"); mValue.mHTMLCanvasElement.Destroy(); mType = eUninitialized; } inline void DestroyOffscreenCanvas() { MOZ_ASSERT(IsOffscreenCanvas(), "Wrong type!"); mValue.mOffscreenCanvas.Destroy(); mType = eUninitialized; } }; class OwningHTMLCanvasElementOrOffscreenCanvas : public AllOwningUnionBase { friend void ImplCycleCollectionUnlink(OwningHTMLCanvasElementOrOffscreenCanvas& aUnion); enum Type { eUninitialized, eHTMLCanvasElement, eOffscreenCanvas }; union Value { UnionMember > mHTMLCanvasElement; UnionMember > mOffscreenCanvas; }; Type mType; Value mValue; public: explicit inline OwningHTMLCanvasElementOrOffscreenCanvas() : mType(eUninitialized) { } explicit inline OwningHTMLCanvasElementOrOffscreenCanvas(const OwningHTMLCanvasElementOrOffscreenCanvas& aOther) : mType(eUninitialized) { *this = aOther; } inline ~OwningHTMLCanvasElementOrOffscreenCanvas() { Uninit(); } OwningNonNull& RawSetAsHTMLCanvasElement(); OwningNonNull& SetAsHTMLCanvasElement(); bool TrySetToHTMLCanvasElement(JSContext* cx, JS::Handle value, bool& tryNext, bool passedToJSImpl = false); inline bool IsHTMLCanvasElement() const { return mType == eHTMLCanvasElement; } inline OwningNonNull& GetAsHTMLCanvasElement() { MOZ_ASSERT(IsHTMLCanvasElement(), "Wrong type!"); return mValue.mHTMLCanvasElement.Value(); } inline OwningNonNull const & GetAsHTMLCanvasElement() const { MOZ_ASSERT(IsHTMLCanvasElement(), "Wrong type!"); return mValue.mHTMLCanvasElement.Value(); } OwningNonNull& RawSetAsOffscreenCanvas(); OwningNonNull& SetAsOffscreenCanvas(); bool TrySetToOffscreenCanvas(JSContext* cx, JS::Handle value, bool& tryNext, bool passedToJSImpl = false); inline bool IsOffscreenCanvas() const { return mType == eOffscreenCanvas; } inline OwningNonNull& GetAsOffscreenCanvas() { MOZ_ASSERT(IsOffscreenCanvas(), "Wrong type!"); return mValue.mOffscreenCanvas.Value(); } inline OwningNonNull const & GetAsOffscreenCanvas() const { MOZ_ASSERT(IsOffscreenCanvas(), "Wrong type!"); return mValue.mOffscreenCanvas.Value(); } void Uninit(); bool ToJSVal(JSContext* cx, JS::Handle scopeObj, JS::MutableHandle rval) const; void TraceUnion(JSTracer* trc); void operator=(const OwningHTMLCanvasElementOrOffscreenCanvas& aOther); private: void DestroyHTMLCanvasElement(); void DestroyOffscreenCanvas(); }; class Int32ArrayOrLongSequence { friend class Int32ArrayOrLongSequenceArgument; enum Type { eUninitialized, eInt32Array, eLongSequence }; union Value { UnionMember > mInt32Array; UnionMember > mLongSequence; }; Type mType; Value mValue; Int32ArrayOrLongSequence(const Int32ArrayOrLongSequence&) = delete; void operator=(const Int32ArrayOrLongSequence&) = delete; public: explicit inline Int32ArrayOrLongSequence() : mType(eUninitialized) { } inline ~Int32ArrayOrLongSequence() { Uninit(); } inline RootedTypedArray& RawSetAsInt32Array(JSContext* cx) { if (mType == eInt32Array) { return mValue.mInt32Array.Value(); } MOZ_ASSERT(mType == eUninitialized); mType = eInt32Array; return mValue.mInt32Array.SetValue(cx); } inline RootedTypedArray& SetAsInt32Array(JSContext* cx) { if (mType == eInt32Array) { return mValue.mInt32Array.Value(); } Uninit(); mType = eInt32Array; return mValue.mInt32Array.SetValue(cx); } inline bool IsInt32Array() const { return mType == eInt32Array; } inline RootedTypedArray& GetAsInt32Array() { MOZ_ASSERT(IsInt32Array(), "Wrong type!"); return mValue.mInt32Array.Value(); } inline Int32Array const & GetAsInt32Array() const { MOZ_ASSERT(IsInt32Array(), "Wrong type!"); return mValue.mInt32Array.Value(); } inline binding_detail::AutoSequence& RawSetAsLongSequence() { if (mType == eLongSequence) { return mValue.mLongSequence.Value(); } MOZ_ASSERT(mType == eUninitialized); mType = eLongSequence; return mValue.mLongSequence.SetValue(); } inline binding_detail::AutoSequence& SetAsLongSequence() { if (mType == eLongSequence) { return mValue.mLongSequence.Value(); } Uninit(); mType = eLongSequence; return mValue.mLongSequence.SetValue(); } inline bool IsLongSequence() const { return mType == eLongSequence; } inline binding_detail::AutoSequence& GetAsLongSequence() { MOZ_ASSERT(IsLongSequence(), "Wrong type!"); return mValue.mLongSequence.Value(); } inline const Sequence& GetAsLongSequence() const { MOZ_ASSERT(IsLongSequence(), "Wrong type!"); return mValue.mLongSequence.Value(); } inline void Uninit() { switch (mType) { case eUninitialized: { break; } case eInt32Array: { DestroyInt32Array(); break; } case eLongSequence: { DestroyLongSequence(); break; } } } bool ToJSVal(JSContext* cx, JS::Handle scopeObj, JS::MutableHandle rval) const; private: inline void DestroyInt32Array() { MOZ_ASSERT(IsInt32Array(), "Wrong type!"); mValue.mInt32Array.Destroy(); mType = eUninitialized; } inline void DestroyLongSequence() { MOZ_ASSERT(IsLongSequence(), "Wrong type!"); mValue.mLongSequence.Destroy(); mType = eUninitialized; } }; class OwningInt32ArrayOrLongSequence : public AllOwningUnionBase { friend void ImplCycleCollectionUnlink(OwningInt32ArrayOrLongSequence& aUnion); enum Type { eUninitialized, eInt32Array, eLongSequence }; union Value { UnionMember mInt32Array; UnionMember > mLongSequence; }; Type mType; Value mValue; OwningInt32ArrayOrLongSequence(const OwningInt32ArrayOrLongSequence&) = delete; void operator=(const OwningInt32ArrayOrLongSequence&) = delete; public: explicit inline OwningInt32ArrayOrLongSequence() : mType(eUninitialized) { } inline ~OwningInt32ArrayOrLongSequence() { Uninit(); } Int32Array& RawSetAsInt32Array(); Int32Array& SetAsInt32Array(); bool TrySetToInt32Array(JSContext* cx, JS::Handle value, bool& tryNext, bool passedToJSImpl = false); inline bool IsInt32Array() const { return mType == eInt32Array; } inline Int32Array& GetAsInt32Array() { MOZ_ASSERT(IsInt32Array(), "Wrong type!"); return mValue.mInt32Array.Value(); } inline Int32Array const & GetAsInt32Array() const { MOZ_ASSERT(IsInt32Array(), "Wrong type!"); return mValue.mInt32Array.Value(); } Sequence& RawSetAsLongSequence(); Sequence& SetAsLongSequence(); bool TrySetToLongSequence(JSContext* cx, JS::Handle value, bool& tryNext, bool passedToJSImpl = false); inline bool IsLongSequence() const { return mType == eLongSequence; } inline Sequence& GetAsLongSequence() { MOZ_ASSERT(IsLongSequence(), "Wrong type!"); return mValue.mLongSequence.Value(); } inline Sequence const & GetAsLongSequence() const { MOZ_ASSERT(IsLongSequence(), "Wrong type!"); return mValue.mLongSequence.Value(); } void Uninit(); bool ToJSVal(JSContext* cx, JS::Handle scopeObj, JS::MutableHandle rval) const; void TraceUnion(JSTracer* trc); private: void DestroyInt32Array(); void DestroyLongSequence(); }; struct WebGLContextAttributes : public DictionaryBase { MOZ_INIT_OUTSIDE_CTOR Optional mAlpha; MOZ_INIT_OUTSIDE_CTOR bool mAntialias; MOZ_INIT_OUTSIDE_CTOR bool mDepth; MOZ_INIT_OUTSIDE_CTOR bool mFailIfMajorPerformanceCaveat; MOZ_INIT_OUTSIDE_CTOR bool mPremultipliedAlpha; MOZ_INIT_OUTSIDE_CTOR bool mPreserveDrawingBuffer; MOZ_INIT_OUTSIDE_CTOR bool mStencil; WebGLContextAttributes(); explicit inline WebGLContextAttributes(const FastDictionaryInitializer& ) { // Do nothing here; this is used by our "Fast" subclass } explicit inline WebGLContextAttributes(const WebGLContextAttributes& aOther) { *this = aOther; } bool Init(JSContext* cx, JS::Handle val, const char* sourceDescription = "Value", bool passedToJSImpl = false); bool Init(const nsAString& aJSON); bool ToObjectInternal(JSContext* cx, JS::MutableHandle rval) const; bool ToJSON(nsAString& aJSON) const; void TraceDictionary(JSTracer* trc); void operator=(const WebGLContextAttributes& aOther); private: static bool InitIds(JSContext* cx, WebGLContextAttributesAtoms* atomsCache); }; namespace binding_detail { struct FastWebGLContextAttributes : public WebGLContextAttributes { inline FastWebGLContextAttributes() : WebGLContextAttributes(FastDictionaryInitializer()) { // Doesn't matter what int we pass to the parent constructor } }; } // namespace binding_detail namespace ANGLE_instanced_arraysBinding { typedef mozilla::WebGLExtensionInstancedArrays NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionInstancedArrays* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace ANGLE_instanced_arraysBinding namespace EXT_blend_minmaxBinding { typedef mozilla::WebGLExtensionBlendMinMax NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionBlendMinMax* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace EXT_blend_minmaxBinding namespace EXT_color_buffer_half_floatBinding { typedef mozilla::WebGLExtensionColorBufferHalfFloat NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionColorBufferHalfFloat* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace EXT_color_buffer_half_floatBinding namespace EXT_disjoint_timer_queryBinding { typedef mozilla::WebGLExtensionDisjointTimerQuery NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionDisjointTimerQuery* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace EXT_disjoint_timer_queryBinding namespace EXT_frag_depthBinding { typedef mozilla::WebGLExtensionFragDepth NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionFragDepth* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace EXT_frag_depthBinding namespace EXT_sRGBBinding { typedef mozilla::WebGLExtensionSRGB NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionSRGB* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace EXT_sRGBBinding namespace EXT_shader_texture_lodBinding { typedef mozilla::WebGLExtensionShaderTextureLod NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionShaderTextureLod* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace EXT_shader_texture_lodBinding namespace EXT_texture_filter_anisotropicBinding { typedef mozilla::WebGLExtensionTextureFilterAnisotropic NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionTextureFilterAnisotropic* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace EXT_texture_filter_anisotropicBinding namespace OES_element_index_uintBinding { typedef mozilla::WebGLExtensionElementIndexUint NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionElementIndexUint* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace OES_element_index_uintBinding namespace OES_standard_derivativesBinding { typedef mozilla::WebGLExtensionStandardDerivatives NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionStandardDerivatives* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace OES_standard_derivativesBinding namespace OES_texture_floatBinding { typedef mozilla::WebGLExtensionTextureFloat NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionTextureFloat* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace OES_texture_floatBinding namespace OES_texture_float_linearBinding { typedef mozilla::WebGLExtensionTextureFloatLinear NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionTextureFloatLinear* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace OES_texture_float_linearBinding namespace OES_texture_half_floatBinding { typedef mozilla::WebGLExtensionTextureHalfFloat NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionTextureHalfFloat* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace OES_texture_half_floatBinding namespace OES_texture_half_float_linearBinding { typedef mozilla::WebGLExtensionTextureHalfFloatLinear NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionTextureHalfFloatLinear* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace OES_texture_half_float_linearBinding namespace OES_vertex_array_objectBinding { typedef mozilla::WebGLExtensionVertexArray NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionVertexArray* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace OES_vertex_array_objectBinding namespace WEBGL_color_buffer_floatBinding { typedef mozilla::WebGLExtensionColorBufferFloat NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionColorBufferFloat* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace WEBGL_color_buffer_floatBinding namespace WEBGL_compressed_texture_atcBinding { typedef mozilla::WebGLExtensionCompressedTextureATC NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionCompressedTextureATC* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace WEBGL_compressed_texture_atcBinding namespace WEBGL_compressed_texture_etcBinding { typedef mozilla::WebGLExtensionCompressedTextureES3 NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionCompressedTextureES3* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace WEBGL_compressed_texture_etcBinding namespace WEBGL_compressed_texture_etc1Binding { typedef mozilla::WebGLExtensionCompressedTextureETC1 NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionCompressedTextureETC1* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace WEBGL_compressed_texture_etc1Binding namespace WEBGL_compressed_texture_pvrtcBinding { typedef mozilla::WebGLExtensionCompressedTexturePVRTC NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionCompressedTexturePVRTC* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace WEBGL_compressed_texture_pvrtcBinding namespace WEBGL_compressed_texture_s3tcBinding { typedef mozilla::WebGLExtensionCompressedTextureS3TC NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionCompressedTextureS3TC* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace WEBGL_compressed_texture_s3tcBinding namespace WEBGL_debug_renderer_infoBinding { typedef mozilla::WebGLExtensionDebugRendererInfo NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionDebugRendererInfo* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace WEBGL_debug_renderer_infoBinding namespace WEBGL_debug_shadersBinding { typedef mozilla::WebGLExtensionDebugShaders NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionDebugShaders* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace WEBGL_debug_shadersBinding namespace WEBGL_depth_textureBinding { typedef mozilla::WebGLExtensionDepthTexture NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionDepthTexture* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace WEBGL_depth_textureBinding namespace WEBGL_draw_buffersBinding { typedef mozilla::WebGLExtensionDrawBuffers NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionDrawBuffers* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace WEBGL_draw_buffersBinding namespace WEBGL_lose_contextBinding { typedef mozilla::WebGLExtensionLoseContext NativeType; const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLExtensionLoseContext* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); } // namespace WEBGL_lose_contextBinding namespace WebGLActiveInfoBinding { typedef mozilla::WebGLActiveInfo NativeType; bool ConstructorEnabled(JSContext* aCx, JS::Handle aObj); JSObject* DefineDOMInterface(JSContext* aCx, JS::Handle aGlobal, JS::Handle id, bool aDefineOnGlobal); const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLActiveInfo* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); JS::Handle GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true); JSObject* GetConstructorObject(JSContext* aCx); } // namespace WebGLActiveInfoBinding namespace WebGLBufferBinding { typedef mozilla::WebGLBuffer NativeType; bool ConstructorEnabled(JSContext* aCx, JS::Handle aObj); JSObject* DefineDOMInterface(JSContext* aCx, JS::Handle aGlobal, JS::Handle id, bool aDefineOnGlobal); const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLBuffer* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); JS::Handle GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true); JSObject* GetConstructorObject(JSContext* aCx); } // namespace WebGLBufferBinding namespace WebGLFramebufferBinding { typedef mozilla::WebGLFramebuffer NativeType; bool ConstructorEnabled(JSContext* aCx, JS::Handle aObj); JSObject* DefineDOMInterface(JSContext* aCx, JS::Handle aGlobal, JS::Handle id, bool aDefineOnGlobal); const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLFramebuffer* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); JS::Handle GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true); JSObject* GetConstructorObject(JSContext* aCx); } // namespace WebGLFramebufferBinding namespace WebGLProgramBinding { typedef mozilla::WebGLProgram NativeType; bool ConstructorEnabled(JSContext* aCx, JS::Handle aObj); JSObject* DefineDOMInterface(JSContext* aCx, JS::Handle aGlobal, JS::Handle id, bool aDefineOnGlobal); const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLProgram* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); JS::Handle GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true); JSObject* GetConstructorObject(JSContext* aCx); } // namespace WebGLProgramBinding namespace WebGLQueryBinding { typedef mozilla::WebGLQuery NativeType; JSObject* DefineDOMInterface(JSContext* aCx, JS::Handle aGlobal, JS::Handle id, bool aDefineOnGlobal); const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLQuery* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); JS::Handle GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true); JSObject* GetConstructorObject(JSContext* aCx); } // namespace WebGLQueryBinding namespace WebGLRenderbufferBinding { typedef mozilla::WebGLRenderbuffer NativeType; bool ConstructorEnabled(JSContext* aCx, JS::Handle aObj); JSObject* DefineDOMInterface(JSContext* aCx, JS::Handle aGlobal, JS::Handle id, bool aDefineOnGlobal); const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLRenderbuffer* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); JS::Handle GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true); JSObject* GetConstructorObject(JSContext* aCx); } // namespace WebGLRenderbufferBinding namespace WebGLRenderingContextBinding { typedef mozilla::WebGLContext NativeType; bool ConstructorEnabled(JSContext* aCx, JS::Handle aObj); JSObject* DefineDOMInterface(JSContext* aCx, JS::Handle aGlobal, JS::Handle id, bool aDefineOnGlobal); const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLContext* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); JS::Handle GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true); JSObject* GetConstructorObject(JSContext* aCx); } // namespace WebGLRenderingContextBinding namespace WebGLShaderBinding { typedef mozilla::WebGLShader NativeType; bool ConstructorEnabled(JSContext* aCx, JS::Handle aObj); JSObject* DefineDOMInterface(JSContext* aCx, JS::Handle aGlobal, JS::Handle id, bool aDefineOnGlobal); const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLShader* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); JS::Handle GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true); JSObject* GetConstructorObject(JSContext* aCx); } // namespace WebGLShaderBinding namespace WebGLShaderPrecisionFormatBinding { typedef mozilla::WebGLShaderPrecisionFormat NativeType; bool ConstructorEnabled(JSContext* aCx, JS::Handle aObj); JSObject* DefineDOMInterface(JSContext* aCx, JS::Handle aGlobal, JS::Handle id, bool aDefineOnGlobal); const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLShaderPrecisionFormat* aObject, JS::Handle aGivenProto, JS::MutableHandle aReflector); // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); JS::Handle GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true); JSObject* GetConstructorObject(JSContext* aCx); } // namespace WebGLShaderPrecisionFormatBinding namespace WebGLTextureBinding { typedef mozilla::WebGLTexture NativeType; bool ConstructorEnabled(JSContext* aCx, JS::Handle aObj); JSObject* DefineDOMInterface(JSContext* aCx, JS::Handle aGlobal, JS::Handle id, bool aDefineOnGlobal); const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLTexture* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); JS::Handle GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true); JSObject* GetConstructorObject(JSContext* aCx); } // namespace WebGLTextureBinding namespace WebGLUniformLocationBinding { typedef mozilla::WebGLUniformLocation NativeType; bool ConstructorEnabled(JSContext* aCx, JS::Handle aObj); JSObject* DefineDOMInterface(JSContext* aCx, JS::Handle aGlobal, JS::Handle id, bool aDefineOnGlobal); const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLUniformLocation* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); JS::Handle GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true); JSObject* GetConstructorObject(JSContext* aCx); } // namespace WebGLUniformLocationBinding namespace WebGLVertexArrayObjectBinding { typedef mozilla::WebGLVertexArray NativeType; JSObject* DefineDOMInterface(JSContext* aCx, JS::Handle aGlobal, JS::Handle id, bool aDefineOnGlobal); const JSClass* GetJSClass(); bool Wrap(JSContext* aCx, mozilla::WebGLVertexArray* aObject, nsWrapperCache* aCache, JS::Handle aGivenProto, JS::MutableHandle aReflector); template inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle aGivenProto) { JS::Rooted reflector(aCx); return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; } // We declare this as an array so that retrieving a pointer to this // binding's property hooks only requires compile/link-time resolvable // address arithmetic. Declaring it as a pointer instead would require // doing a run-time load to fetch a pointer to this binding's property // hooks. And then structures which embedded a pointer to this structure // would require a run-time load for proper initialization, which would // then induce static constructors. Lots of static constructors. extern const NativePropertyHooks sNativePropertyHooks[]; void CreateInterfaceObjects(JSContext* aCx, JS::Handle aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal); JS::Handle GetProtoObjectHandle(JSContext* aCx); JS::Handle GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true); JSObject* GetConstructorObject(JSContext* aCx); } // namespace WebGLVertexArrayObjectBinding } // namespace dom } // namespace mozilla #endif // mozilla_dom_WebGLRenderingContextBinding_h