[WebIDL] Remove most of the custom bindings for the WebGL code
authorcommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 11 Jan 2017 01:02:34 +0000 (01:02 +0000)
committercommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 11 Jan 2017 01:02:34 +0000 (01:02 +0000)
https://bugs.webkit.org/show_bug.cgi?id=166834

Patch by Sam Weinig <sam@webkit.org> on 2017-01-10
Reviewed by Alex Christensen.

Source/JavaScriptCore:

* runtime/ArrayPrototype.h:
* runtime/ObjectPrototype.h:
Export the ClassInfo so it can be used from WebCore.

Source/WebCore:

Removes all but one custom getter (getExtension) from the WebGL code.

* Modules/indexeddb/IDBKeyRange.idl:
Replace use of non-standard type, with new OverrideIDLType extended attribute, allowing us
to stay more consistent with the IDL files spec's provide.

* WebCore.xcodeproj/project.pbxproj:
Move JSWebGL2RenderingContextCustom to the GC/Wrapping only group.

* bindings/IDLTypes.h:
Add IDLWebGLAny, and simplify IDLIDBKey to not be templatized.

* bindings/js/JSDOMConvert.h:
(WebCore::Converter<IDLLong>::convert):
(WebCore::Converter<IDLFloat>::convert):
(WebCore::Converter<IDLUnrestrictedFloat>::convert):
(WebCore::Converter<IDLDouble>::convert):
(WebCore::Converter<IDLUnrestrictedDouble>::convert):
Add overloads of convert that convert a double to the numeric type.

(WebCore::Detail::GenericSequenceConverter::convert):
Add optimized specialization for JSArrays that does not use the iterator protocol.

(WebCore::Detail::NumericSequenceConverter::convert):
Add an even more optimized specialization for numeric types, which checks to see
if the array's butterfly has an optimized shape, and extracts the numeric values
from that.

(WebCore::Detail::SequenceConverter::convert):
(WebCore::Detail::SequenceConverter<IDLLong>::convert):
(WebCore::Detail::SequenceConverter<IDLFloat>::convert):
(WebCore::Detail::SequenceConverter<IDLUnrestrictedFloat>::convert):
(WebCore::Detail::SequenceConverter<IDLDouble>::convert):
(WebCore::Detail::SequenceConverter<IDLUnrestrictedDouble>::convert):
Select the right specialization based on type.

(WebCore::Converter<IDLSequence<T>>::convert):
(WebCore::Converter<IDLFrozenArray<T>>::convert):
Rename converter to be more accurate.

(WebCore::JSConverter<IDLWebGLAny>::convert):
Added. Calls through to converter in WebGLAny.h. We should replace this with a
call to the IDLUnion JSConverter when feasible.

* bindings/js/JSWebGL2RenderingContextCustom.cpp:
(WebCore::JSWebGL2RenderingContext::getInternalformatParameter): Deleted.
(WebCore::JSWebGL2RenderingContext::getQueryParameter): Deleted.
(WebCore::JSWebGL2RenderingContext::getSamplerParameter): Deleted.
(WebCore::JSWebGL2RenderingContext::getSyncParameter): Deleted.
(WebCore::JSWebGL2RenderingContext::getIndexedParameter): Deleted.
(WebCore::JSWebGL2RenderingContext::getActiveUniformBlockParameter): Deleted.
(WebCore::JSWebGL2RenderingContext::getActiveUniformBlockName): Deleted.
Remove unnecessary custom functions.

* bindings/js/JSWebGLRenderingContextBaseCustom.cpp:
(WebCore::objectParameter): Deleted.
(WebCore::JSWebGLRenderingContextBase::getAttachedShaders): Deleted.
(WebCore::JSWebGLRenderingContextBase::getBufferParameter): Deleted.
(WebCore::JSWebGLRenderingContextBase::getFramebufferAttachmentParameter): Deleted.
(WebCore::JSWebGLRenderingContextBase::getParameter): Deleted.
(WebCore::JSWebGLRenderingContextBase::getProgramParameter): Deleted.
(WebCore::JSWebGLRenderingContextBase::getRenderbufferParameter): Deleted.
(WebCore::JSWebGLRenderingContextBase::getShaderParameter): Deleted.
(WebCore::JSWebGLRenderingContextBase::getSupportedExtensions): Deleted.
(WebCore::JSWebGLRenderingContextBase::getTexParameter): Deleted.
(WebCore::JSWebGLRenderingContextBase::getUniform): Deleted.
(WebCore::JSWebGLRenderingContextBase::getVertexAttrib): Deleted.
(WebCore::toNumberVector): Deleted.
(WebCore::functionForUniform): Deleted.
(WebCore::dataFunctionf): Deleted.
(WebCore::dataFunctioni): Deleted.
(WebCore::dataFunctionMatrix): Deleted.
(WebCore::JSWebGLRenderingContextBase::uniform1fv): Deleted.
(WebCore::JSWebGLRenderingContextBase::uniform1iv): Deleted.
(WebCore::JSWebGLRenderingContextBase::uniform2fv): Deleted.
(WebCore::JSWebGLRenderingContextBase::uniform2iv): Deleted.
(WebCore::JSWebGLRenderingContextBase::uniform3fv): Deleted.
(WebCore::JSWebGLRenderingContextBase::uniform3iv): Deleted.
(WebCore::JSWebGLRenderingContextBase::uniform4fv): Deleted.
(WebCore::JSWebGLRenderingContextBase::uniform4iv): Deleted.
(WebCore::JSWebGLRenderingContextBase::uniformMatrix2fv): Deleted.
(WebCore::JSWebGLRenderingContextBase::uniformMatrix3fv): Deleted.
(WebCore::JSWebGLRenderingContextBase::uniformMatrix4fv): Deleted.
(WebCore::JSWebGLRenderingContextBase::vertexAttrib1fv): Deleted.
(WebCore::JSWebGLRenderingContextBase::vertexAttrib2fv): Deleted.
(WebCore::JSWebGLRenderingContextBase::vertexAttrib3fv): Deleted.
(WebCore::JSWebGLRenderingContextBase::vertexAttrib4fv): Deleted.
Remove unnecessary custom functions.

* bindings/scripts/CodeGenerator.pm:
(IsBuiltinType):
Remove specialization of IDBKey.

* bindings/scripts/CodeGeneratorJS.pm:
(GetBaseIDLType):
(GetIDLType):
(NativeToJSValueDOMConvertNeedsState):
(NativeToJSValueDOMConvertNeedsGlobalObject):
(NativeToJSValue):
Allow IDL files to override the type of signature using a new OverrideIDLType
extended attribute. Currently this only works conversion to JS, but could be
extended to support more.

* bindings/scripts/IDLAttributes.txt:
Add OverrideIDLType.

* html/canvas/WebGL2RenderingContext.idl:
Add OverrideIDLType=IDLWebGLAny annotations to remove the need for custom functions.

* html/canvas/WebGLAny.cpp:
(WebCore::convertToJSValue):
(WebCore::toJS): Deleted.
* html/canvas/WebGLAny.h:
Rename the toJS function to convertToJSValue to avoid a template specialization issue.

* html/canvas/WebGLRenderingContextBase.cpp:
(WebCore::WebGLRenderingContextBase::getAttachedShaders):
Update signature to match IDL, replacing bool return value plus out parameter with an
optional return value. Modernize the code a bit.

(WebCore::WebGLRenderingContextBase::uniform2f):
(WebCore::WebGLRenderingContextBase::uniform3f):
(WebCore::WebGLRenderingContextBase::uniform4f):
(WebCore::WebGLRenderingContextBase::uniform1i):
(WebCore::WebGLRenderingContextBase::uniform3i):
(WebCore::WebGLRenderingContextBase::uniform4i):
(WebCore::WebGLRenderingContextBase::uniform1fv):
(WebCore::WebGLRenderingContextBase::uniform2fv):
(WebCore::WebGLRenderingContextBase::uniform3fv):
(WebCore::WebGLRenderingContextBase::uniform4fv):
(WebCore::WebGLRenderingContextBase::uniform1iv):
(WebCore::WebGLRenderingContextBase::uniform2iv):
(WebCore::WebGLRenderingContextBase::uniform3iv):
(WebCore::WebGLRenderingContextBase::uniform4iv):
(WebCore::WebGLRenderingContextBase::uniformMatrix2fv):
(WebCore::WebGLRenderingContextBase::uniformMatrix3fv):
(WebCore::WebGLRenderingContextBase::uniformMatrix4fv):
(WebCore::WebGLRenderingContextBase::vertexAttrib4f):
(WebCore::WebGLRenderingContextBase::vertexAttrib1fv):
(WebCore::WebGLRenderingContextBase::vertexAttrib2fv):
(WebCore::WebGLRenderingContextBase::vertexAttrib3fv):
(WebCore::WebGLRenderingContextBase::vertexAttrib4fv):
(WebCore::WebGLRenderingContextBase::validateUniformParameters):
(WebCore::WebGLRenderingContextBase::validateUniformMatrixParameters):
(WebCore::WebGLRenderingContextBase::vertexAttribfvImpl):
* html/canvas/WebGLRenderingContextBase.h:
(WebCore::WebGLRenderingContextBase::TypedList::TypedList):
(WebCore::WebGLRenderingContextBase::TypedList::data):
(WebCore::WebGLRenderingContextBase::TypedList::length):
Re-order/group to match order in the IDL file. Remove overloads taking a pointer and
length, and replace it by having the main function take a specialized TypedList. TypedList
allows the bindings to pass the correct Variant type, but then the code to only think in
terms of the data() and length() functions.

* html/canvas/WebGLRenderingContextBase.idl:
Remove [Custom] annotations and re-order/group to match the spec. Update types of uniform*fv/iv
functions to take typedef'd unions.

LayoutTests:

* fast/canvas/webgl/gl-object-get-calls-expected.txt:
Update result for better error message.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@210567 268f45cc-cd09-0410-ab3c-d52691b4dbfc

26 files changed:
LayoutTests/ChangeLog
LayoutTests/fast/canvas/webgl/gl-object-get-calls-expected.txt
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/runtime/ArrayPrototype.h
Source/JavaScriptCore/runtime/ObjectPrototype.h
Source/WebCore/ChangeLog
Source/WebCore/ForwardingHeaders/runtime/JSGlobalObjectInlines.h [new file with mode: 0644]
Source/WebCore/Modules/indexeddb/IDBKeyRange.idl
Source/WebCore/WebCore.xcodeproj/project.pbxproj
Source/WebCore/bindings/IDLTypes.h
Source/WebCore/bindings/js/JSDOMConvert.h
Source/WebCore/bindings/js/JSWebGL2RenderingContextCustom.cpp
Source/WebCore/bindings/js/JSWebGLRenderingContextBaseCustom.cpp
Source/WebCore/bindings/scripts/CodeGenerator.pm
Source/WebCore/bindings/scripts/CodeGeneratorJS.pm
Source/WebCore/bindings/scripts/IDLAttributes.txt
Source/WebCore/html/canvas/WebGL2RenderingContext.cpp
Source/WebCore/html/canvas/WebGL2RenderingContext.h
Source/WebCore/html/canvas/WebGL2RenderingContext.idl
Source/WebCore/html/canvas/WebGLAny.cpp
Source/WebCore/html/canvas/WebGLAny.h
Source/WebCore/html/canvas/WebGLRenderingContext.cpp
Source/WebCore/html/canvas/WebGLRenderingContext.h
Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp
Source/WebCore/html/canvas/WebGLRenderingContextBase.h
Source/WebCore/html/canvas/WebGLRenderingContextBase.idl

index 0b482f7..625599e 100644 (file)
@@ -1,3 +1,13 @@
+2017-01-10  Sam Weinig  <sam@webkit.org>
+
+        [WebIDL] Remove most of the custom bindings for the WebGL code
+        https://bugs.webkit.org/show_bug.cgi?id=166834
+
+        Reviewed by Alex Christensen.
+
+        * fast/canvas/webgl/gl-object-get-calls-expected.txt:
+        Update result for better error message.
+
 2017-01-10  Ryosuke Niwa  <rniwa@webkit.org>
 
         :active and :hover states may not be updated across slots
index c899480..3920ccf 100644 (file)
@@ -7,7 +7,7 @@ PASS shaders[0] == standardVert && shaders[1] == standardFrag || shaders[1] == s
 PASS getError was expected value: NO_ERROR : 
 PASS gl.getAttachedShaders(null) is null
 PASS getError was expected value: INVALID_VALUE : 
-PASS gl.getAttachedShaders(standardVert) threw exception TypeError: Type error.
+PASS gl.getAttachedShaders(standardVert) threw exception TypeError: Argument 1 ('program') to WebGLRenderingContextBase.getAttachedShaders must be an instance of WebGLProgram.
 PASS getError was expected value: NO_ERROR : 
 PASS gl.getBufferParameter(gl.ARRAY_BUFFER, gl.BUFFER_SIZE) is 16
 PASS gl.getBufferParameter(gl.ARRAY_BUFFER, gl.BUFFER_USAGE) is gl.DYNAMIC_DRAW
index 27af8cd..2f44813 100644 (file)
@@ -1,3 +1,14 @@
+2017-01-10  Sam Weinig  <sam@webkit.org>
+
+        [WebIDL] Remove most of the custom bindings for the WebGL code
+        https://bugs.webkit.org/show_bug.cgi?id=166834
+
+        Reviewed by Alex Christensen.
+
+        * runtime/ArrayPrototype.h:
+        * runtime/ObjectPrototype.h:
+        Export the ClassInfo so it can be used from WebCore.
+
 2017-01-09  Filip Pizlo  <fpizlo@apple.com>
 
         Streamline the GC barrier slowpath
index f7b8432..0f3f9fd 100644 (file)
@@ -42,7 +42,7 @@ public:
 
     static ArrayPrototype* create(VM&, JSGlobalObject*, Structure*);
         
-    DECLARE_INFO;
+    DECLARE_EXPORT_INFO;
 
     static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
     {
index ec10462..c1c6e46 100644 (file)
@@ -31,7 +31,7 @@ public:
 
     static ObjectPrototype* create(VM&, JSGlobalObject*, Structure*);
 
-    DECLARE_INFO;
+    DECLARE_EXPORT_INFO;
 
     static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
     {
index 6b4581e..b49c268 100644 (file)
@@ -1,3 +1,168 @@
+2017-01-10  Sam Weinig  <sam@webkit.org>
+
+        [WebIDL] Remove most of the custom bindings for the WebGL code
+        https://bugs.webkit.org/show_bug.cgi?id=166834
+
+        Reviewed by Alex Christensen.
+
+        Removes all but one custom getter (getExtension) from the WebGL code.
+
+        * Modules/indexeddb/IDBKeyRange.idl:
+        Replace use of non-standard type, with new OverrideIDLType extended attribute, allowing us
+        to stay more consistent with the IDL files spec's provide.
+
+        * WebCore.xcodeproj/project.pbxproj:
+        Move JSWebGL2RenderingContextCustom to the GC/Wrapping only group.
+
+        * bindings/IDLTypes.h:
+        Add IDLWebGLAny, and simplify IDLIDBKey to not be templatized.
+
+        * bindings/js/JSDOMConvert.h:
+        (WebCore::Converter<IDLLong>::convert):
+        (WebCore::Converter<IDLFloat>::convert):
+        (WebCore::Converter<IDLUnrestrictedFloat>::convert):
+        (WebCore::Converter<IDLDouble>::convert):
+        (WebCore::Converter<IDLUnrestrictedDouble>::convert):
+        Add overloads of convert that convert a double to the numeric type.
+
+        (WebCore::Detail::GenericSequenceConverter::convert):
+        Add optimized specialization for JSArrays that does not use the iterator protocol.
+
+        (WebCore::Detail::NumericSequenceConverter::convert):
+        Add an even more optimized specialization for numeric types, which checks to see
+        if the array's butterfly has an optimized shape, and extracts the numeric values
+        from that.
+
+        (WebCore::Detail::SequenceConverter::convert):
+        (WebCore::Detail::SequenceConverter<IDLLong>::convert):
+        (WebCore::Detail::SequenceConverter<IDLFloat>::convert):
+        (WebCore::Detail::SequenceConverter<IDLUnrestrictedFloat>::convert):
+        (WebCore::Detail::SequenceConverter<IDLDouble>::convert):
+        (WebCore::Detail::SequenceConverter<IDLUnrestrictedDouble>::convert):
+        Select the right specialization based on type.
+
+        (WebCore::Converter<IDLSequence<T>>::convert):
+        (WebCore::Converter<IDLFrozenArray<T>>::convert):
+        Rename converter to be more accurate.
+
+        (WebCore::JSConverter<IDLWebGLAny>::convert):
+        Added. Calls through to converter in WebGLAny.h. We should replace this with a
+        call to the IDLUnion JSConverter when feasible.
+
+        * bindings/js/JSWebGL2RenderingContextCustom.cpp:
+        (WebCore::JSWebGL2RenderingContext::getInternalformatParameter): Deleted.
+        (WebCore::JSWebGL2RenderingContext::getQueryParameter): Deleted.
+        (WebCore::JSWebGL2RenderingContext::getSamplerParameter): Deleted.
+        (WebCore::JSWebGL2RenderingContext::getSyncParameter): Deleted.
+        (WebCore::JSWebGL2RenderingContext::getIndexedParameter): Deleted.
+        (WebCore::JSWebGL2RenderingContext::getActiveUniformBlockParameter): Deleted.
+        (WebCore::JSWebGL2RenderingContext::getActiveUniformBlockName): Deleted.
+        Remove unnecessary custom functions.
+
+        * bindings/js/JSWebGLRenderingContextBaseCustom.cpp:
+        (WebCore::objectParameter): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::getAttachedShaders): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::getBufferParameter): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::getFramebufferAttachmentParameter): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::getParameter): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::getProgramParameter): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::getRenderbufferParameter): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::getShaderParameter): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::getSupportedExtensions): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::getTexParameter): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::getUniform): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::getVertexAttrib): Deleted.
+        (WebCore::toNumberVector): Deleted.
+        (WebCore::functionForUniform): Deleted.
+        (WebCore::dataFunctionf): Deleted.
+        (WebCore::dataFunctioni): Deleted.
+        (WebCore::dataFunctionMatrix): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::uniform1fv): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::uniform1iv): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::uniform2fv): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::uniform2iv): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::uniform3fv): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::uniform3iv): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::uniform4fv): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::uniform4iv): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::uniformMatrix2fv): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::uniformMatrix3fv): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::uniformMatrix4fv): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::vertexAttrib1fv): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::vertexAttrib2fv): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::vertexAttrib3fv): Deleted.
+        (WebCore::JSWebGLRenderingContextBase::vertexAttrib4fv): Deleted.
+        Remove unnecessary custom functions.
+
+        * bindings/scripts/CodeGenerator.pm:
+        (IsBuiltinType):
+        Remove specialization of IDBKey.
+
+        * bindings/scripts/CodeGeneratorJS.pm:
+        (GetBaseIDLType):
+        (GetIDLType):
+        (NativeToJSValueDOMConvertNeedsState):
+        (NativeToJSValueDOMConvertNeedsGlobalObject):
+        (NativeToJSValue):
+        Allow IDL files to override the type of signature using a new OverrideIDLType
+        extended attribute. Currently this only works conversion to JS, but could be
+        extended to support more.
+
+        * bindings/scripts/IDLAttributes.txt:
+        Add OverrideIDLType.
+
+        * html/canvas/WebGL2RenderingContext.idl:
+        Add OverrideIDLType=IDLWebGLAny annotations to remove the need for custom functions.
+
+        * html/canvas/WebGLAny.cpp:
+        (WebCore::convertToJSValue):
+        (WebCore::toJS): Deleted.
+        * html/canvas/WebGLAny.h:
+        Rename the toJS function to convertToJSValue to avoid a template specialization issue.
+
+        * html/canvas/WebGLRenderingContextBase.cpp:
+        (WebCore::WebGLRenderingContextBase::getAttachedShaders):
+        Update signature to match IDL, replacing bool return value plus out parameter with an
+        optional return value. Modernize the code a bit.
+
+        (WebCore::WebGLRenderingContextBase::uniform2f):
+        (WebCore::WebGLRenderingContextBase::uniform3f):
+        (WebCore::WebGLRenderingContextBase::uniform4f):
+        (WebCore::WebGLRenderingContextBase::uniform1i):
+        (WebCore::WebGLRenderingContextBase::uniform3i):
+        (WebCore::WebGLRenderingContextBase::uniform4i):
+        (WebCore::WebGLRenderingContextBase::uniform1fv):
+        (WebCore::WebGLRenderingContextBase::uniform2fv):
+        (WebCore::WebGLRenderingContextBase::uniform3fv):
+        (WebCore::WebGLRenderingContextBase::uniform4fv):
+        (WebCore::WebGLRenderingContextBase::uniform1iv):
+        (WebCore::WebGLRenderingContextBase::uniform2iv):
+        (WebCore::WebGLRenderingContextBase::uniform3iv):
+        (WebCore::WebGLRenderingContextBase::uniform4iv):
+        (WebCore::WebGLRenderingContextBase::uniformMatrix2fv):
+        (WebCore::WebGLRenderingContextBase::uniformMatrix3fv):
+        (WebCore::WebGLRenderingContextBase::uniformMatrix4fv):
+        (WebCore::WebGLRenderingContextBase::vertexAttrib4f):
+        (WebCore::WebGLRenderingContextBase::vertexAttrib1fv):
+        (WebCore::WebGLRenderingContextBase::vertexAttrib2fv):
+        (WebCore::WebGLRenderingContextBase::vertexAttrib3fv):
+        (WebCore::WebGLRenderingContextBase::vertexAttrib4fv):
+        (WebCore::WebGLRenderingContextBase::validateUniformParameters):
+        (WebCore::WebGLRenderingContextBase::validateUniformMatrixParameters):
+        (WebCore::WebGLRenderingContextBase::vertexAttribfvImpl):
+        * html/canvas/WebGLRenderingContextBase.h:
+        (WebCore::WebGLRenderingContextBase::TypedList::TypedList):
+        (WebCore::WebGLRenderingContextBase::TypedList::data):
+        (WebCore::WebGLRenderingContextBase::TypedList::length):
+        Re-order/group to match order in the IDL file. Remove overloads taking a pointer and 
+        length, and replace it by having the main function take a specialized TypedList. TypedList
+        allows the bindings to pass the correct Variant type, but then the code to only think in
+        terms of the data() and length() functions.
+
+        * html/canvas/WebGLRenderingContextBase.idl:
+        Remove [Custom] annotations and re-order/group to match the spec. Update types of uniform*fv/iv
+        functions to take typedef'd unions.
+
 2017-01-10  Ryosuke Niwa  <rniwa@webkit.org>
 
         :active and :hover states may not be updated across slots
diff --git a/Source/WebCore/ForwardingHeaders/runtime/JSGlobalObjectInlines.h b/Source/WebCore/ForwardingHeaders/runtime/JSGlobalObjectInlines.h
new file mode 100644 (file)
index 0000000..1658fb2
--- /dev/null
@@ -0,0 +1,2 @@
+#pragma once
+#include <JavaScriptCore/JSGlobalObjectInlines.h>
index 3ccc1a0..d72a418 100644 (file)
     ImplementationLacksVTable,
     EnabledAtRuntime=IndexedDB,
 ] interface IDBKeyRange {
-    // NOTE: The 'lower' and 'upper' attributes are specified to be of type 'any'
-    // but we use the extension type IDBKey, to allow code generator to know our
-    // which conversion to use based on our actual implementation type.
-    readonly attribute IDBKey lower;
-    readonly attribute IDBKey upper;
+    [OverrideIDLType=IDLIDBKey] readonly attribute any lower;
+    [OverrideIDLType=IDLIDBKey] readonly attribute any upper;
     readonly attribute boolean lowerOpen;
     readonly attribute boolean upperOpen;
 
index bb93ab3..bcbc656 100644 (file)
                6E3FAE8F14733FDB00E42306 /* WebGLCompressedTextureS3TC.h in Headers */ = {isa = PBXBuildFile; fileRef = 6E3FAE8D14733FDB00E42306 /* WebGLCompressedTextureS3TC.h */; };
                6E3FAE8F14733FDB00E42307 /* WebGLDepthTexture.h in Headers */ = {isa = PBXBuildFile; fileRef = 6E3FAE8D14733FDB00E42307 /* WebGLDepthTexture.h */; };
                6E47E66010B7944B00B186C8 /* WebGLAny.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6E47E65E10B7944B00B186C8 /* WebGLAny.cpp */; };
-               6E47E66110B7944B00B186C8 /* WebGLAny.h in Headers */ = {isa = PBXBuildFile; fileRef = 6E47E65F10B7944B00B186C8 /* WebGLAny.h */; };
+               6E47E66110B7944B00B186C8 /* WebGLAny.h in Headers */ = {isa = PBXBuildFile; fileRef = 6E47E65F10B7944B00B186C8 /* WebGLAny.h */; settings = {ATTRIBUTES = (Private, ); }; };
                6E4ABCD4138EA0B70071D291 /* JSHTMLUnknownElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6E4ABCD2138EA0B70071D291 /* JSHTMLUnknownElement.cpp */; };
                6E4ABCD5138EA0B70071D291 /* JSHTMLUnknownElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 6E4ABCD3138EA0B70071D291 /* JSHTMLUnknownElement.h */; };
                6E4E91AF10F7FB3100A2779C /* WebGLContextAttributes.h in Headers */ = {isa = PBXBuildFile; fileRef = 6E4E91AA10F7FB3100A2779C /* WebGLContextAttributes.h */; settings = {ATTRIBUTES = (Private, ); }; };
                                07846384145B1B8E00A58DF1 /* JSTrackCustom.h */,
                                516BB7920CE91E6800512F79 /* JSTreeWalkerCustom.cpp */,
                                BE6DF70A171CA2C500DD52B8 /* JSVideoTrackListCustom.cpp */,
+                               D3F3D3591A69A3B00059FC2B /* JSWebGL2RenderingContextCustom.cpp */,
                                49EED14C1051971A00099FAB /* JSWebGLRenderingContextCustom.cpp */,
                                83A4A9F81CE7FD7E00709B00 /* JSXMLDocumentCustom.cpp */,
                                836C14421CDEAFCA0073493F /* JSXPathNSResolverCustom.cpp */,
                                07E116B01489C9A100EC5ACE /* JSTextTrackCustom.cpp */,
                                7C73FB17191EF808007DE061 /* JSUserMessageHandlersNamespaceCustom.cpp */,
                                BE6DF708171CA2C500DD52B8 /* JSVideoTrackCustom.cpp */,
-                               D3F3D3591A69A3B00059FC2B /* JSWebGL2RenderingContextCustom.cpp */,
                                D3F3D35A1A69A3B00059FC2B /* JSWebGLRenderingContextBaseCustom.cpp */,
                                E1FF8F661807460800132674 /* JSWebKitSubtleCryptoCustom.cpp */,
                                E1CA5CBB0E8CDCAF00E8EF90 /* JSWorkerCustom.cpp */,
index fe29074..07bf19f 100644 (file)
 #include <wtf/StdLibExtras.h>
 #include <wtf/text/WTFString.h>
 
+#if ENABLE(WEBGL)
+#include "WebGLAny.h"
+#endif
+
 namespace JSC {
 class ArrayBuffer;
 class ArrayBufferView;
@@ -41,6 +45,7 @@ template<typename> class Strong;
 
 namespace WebCore {
 
+class IDBKey;
 template<typename> class DOMPromise;
 
 template<typename T>
@@ -83,13 +88,11 @@ struct IDLUnsignedLong : IDLInteger<uint32_t> { };
 struct IDLLongLong : IDLInteger<int64_t> { };
 struct IDLUnsignedLongLong : IDLInteger<uint64_t> { };
 
-template<typename FloatingPointType, bool unrestricted = false> struct IDLFloatingPoint : IDLNumber<FloatingPointType> {
-    static constexpr bool isUnrestricted = unrestricted;
-};
+template<typename FloatingPointType> struct IDLFloatingPoint : IDLNumber<FloatingPointType> { };
 struct IDLFloat : IDLFloatingPoint<float> { };
-struct IDLUnrestrictedFloat : IDLFloatingPoint<float, true> { };
+struct IDLUnrestrictedFloat : IDLFloatingPoint<float> { };
 struct IDLDouble : IDLFloatingPoint<double> { };
-struct IDLUnrestrictedDouble : IDLFloatingPoint<double, true> { };
+struct IDLUnrestrictedDouble : IDLFloatingPoint<double> { };
 
 struct IDLString : IDLType<String> {
     using ParameterType = const String&;
@@ -190,7 +193,12 @@ struct IDLJSON : IDLType<String> {
 template<typename T> struct IDLSerializedScriptValue : IDLWrapper<T> { };
 template<typename T> struct IDLEventListener : IDLWrapper<T> { };
 template<typename T> struct IDLXPathNSResolver : IDLWrapper<T> { };
-template<typename T> struct IDLIDBKey : IDLWrapper<T> { };
+
+struct IDLIDBKey : IDLWrapper<IDBKey> { };
+
+#if ENABLE(WEBGL)
+struct IDLWebGLAny : IDLType<WebGLAny> { };
+#endif
 
 // Non-WebIDL convenience type aliases
 
@@ -223,4 +231,7 @@ struct IsIDLNumber : public std::integral_constant<bool, WTF::IsBaseOfTemplate<I
 template<typename T>
 struct IsIDLInteger : public std::integral_constant<bool, WTF::IsBaseOfTemplate<IDLInteger, T>::value> { };
 
+template<typename T>
+struct IsIDLFloatingPoint : public std::integral_constant<bool, WTF::IsBaseOfTemplate<IDLFloatingPoint, T>::value> { };
+
 } // namespace WebCore
index f90f96a..2307e57 100644 (file)
@@ -29,6 +29,7 @@
 #include "IDBBindingUtilities.h"
 #include "IDLTypes.h"
 #include "JSDOMBinding.h"
+#include <runtime/JSGlobalObjectInlines.h>
 #include <runtime/JSONObject.h>
 
 namespace WebCore {
@@ -583,6 +584,11 @@ template<> struct JSConverter<IDLUnsignedShort> {
 };
 
 template<> struct Converter<IDLLong> : DefaultConverter<IDLLong> {
+    static inline int32_t convert(JSC::ExecState&, JSC::ThrowScope&, double number)
+    {
+        return JSC::toInt32(number);
+    }
+
     static int32_t convert(JSC::ExecState& state, JSC::JSValue value, IntegerConversionConfiguration configuration = IntegerConversionConfiguration::Normal)
     {
         switch (configuration) {
@@ -700,6 +706,14 @@ template<> struct JSConverter<IDLUnsignedLongLong> {
 // MARK: Floating point types
 
 template<> struct Converter<IDLFloat> : DefaultConverter<IDLFloat> {
+
+    static inline float convert(JSC::ExecState& state, JSC::ThrowScope& scope, double number)
+    {
+        if (UNLIKELY(!std::isfinite(number)))
+            throwNonFiniteTypeError(state, scope);
+        return static_cast<float>(number);
+    }
+
     static float convert(JSC::ExecState& state, JSC::JSValue value)
     {
         JSC::VM& vm = state.vm();
@@ -724,6 +738,11 @@ template<> struct JSConverter<IDLFloat> {
 };
 
 template<> struct Converter<IDLUnrestrictedFloat> : DefaultConverter<IDLUnrestrictedFloat> {
+    static inline float convert(JSC::ExecState&, JSC::ThrowScope&, double number)
+    {
+        return static_cast<float>(number);
+    }
+
     static float convert(JSC::ExecState& state, JSC::JSValue value)
     {
         return static_cast<float>(value.toNumber(&state));
@@ -743,6 +762,13 @@ template<> struct JSConverter<IDLUnrestrictedFloat> {
 };
 
 template<> struct Converter<IDLDouble> : DefaultConverter<IDLDouble> {
+    static inline double convert(JSC::ExecState& state, JSC::ThrowScope& scope, double number)
+    {
+        if (UNLIKELY(!std::isfinite(number)))
+            throwNonFiniteTypeError(state, scope);
+        return number;
+    }
+
     static double convert(JSC::ExecState& state, JSC::JSValue value)
     {
         JSC::VM& vm = state.vm();
@@ -767,6 +793,11 @@ template<> struct JSConverter<IDLDouble> {
 };
 
 template<> struct Converter<IDLUnrestrictedDouble> : DefaultConverter<IDLUnrestrictedDouble> {
+    static inline double convert(JSC::ExecState&, JSC::ThrowScope&, double number)
+    {
+        return number;
+    }
+
     static double convert(JSC::ExecState& state, JSC::JSValue value)
     {
         return value.toNumber(&state);
@@ -875,21 +906,125 @@ template<> struct Converter<IDLObject> : DefaultConverter<IDLObject> {
 
 namespace Detail {
     template<typename IDLType>
-    struct ArrayConverterBase;
-
-    template<typename IDLType> 
-    struct ArrayConverterBase {
+    struct GenericSequenceConverter {
         using ReturnType = Vector<typename IDLType::ImplementationType>;
+
+        static ReturnType convert(JSC::ExecState& state, JSC::JSObject* jsObject)
+        {
+            ReturnType result;
+            forEachInIterable(&state, jsObject, [&result](JSC::VM& vm, JSC::ExecState* state, JSC::JSValue jsValue) {
+                auto scope = DECLARE_THROW_SCOPE(vm);
+
+                auto convertedValue = Converter<IDLType>::convert(*state, jsValue);
+                if (UNLIKELY(scope.exception()))
+                    return;
+                result.append(WTFMove(convertedValue));
+            });
+            return result;
+        }
     };
 
-    template<typename T>
-    struct ArrayConverterBase<IDLInterface<T>> {
-        using ReturnType = Vector<RefPtr<T>>;
+    // Specialization for numeric types
+    // FIXME: This is only implemented for the IDLFloatingPointTypes and IDLLong. To add
+    // support for more numeric types, add an overload of Converter<IDLType>::convert that
+    // takes an ExecState, ThrowScope, double as its arguments.
+    template<typename IDLType>
+    struct NumericSequenceConverter {
+        using GenericConverter = GenericSequenceConverter<IDLType>;
+        using ReturnType = typename GenericConverter::ReturnType;
+
+        static ReturnType convert(JSC::ExecState& state, JSC::JSValue value)
+        {
+            auto& vm = state.vm();
+            auto scope = DECLARE_THROW_SCOPE(vm);
+
+            if (!value.isObject()) {
+                throwSequenceTypeError(state, scope);
+                return { };
+            }
+
+            JSC::JSObject* object = JSC::asObject(value);
+            if (!JSC::isJSArray(object))
+                return GenericConverter::convert(state, object);
+
+            JSC::JSArray* array = JSC::asArray(object);
+            if (!array->globalObject()->isArrayIteratorProtocolFastAndNonObservable())
+                return GenericConverter::convert(state, object);
+
+            unsigned length = array->length();
+
+            ReturnType result;
+            if (!result.tryReserveCapacity(length)) {
+                // FIXME: Is the right exception to throw?
+                throwTypeError(&state, scope);
+                return { };
+            }
+
+            JSC::IndexingType indexingType = array->indexingType() & JSC::IndexingShapeMask;
+
+            if (indexingType == JSC::ContiguousShape) {
+                for (unsigned i = 0; i < length; i++) {
+                    auto indexValue = array->butterfly()->contiguous()[i].get();
+                    if (!indexValue)
+                        result.uncheckedAppend(0);
+                    else {
+                        auto convertedValue = Converter<IDLType>::convert(state, indexValue);
+                        RETURN_IF_EXCEPTION(scope, { });
+
+                        result.uncheckedAppend(convertedValue);
+                    }
+                }
+                return result;
+            }
+            
+            if (indexingType == JSC::Int32Shape) {
+                for (unsigned i = 0; i < length; i++) {
+                    auto indexValue = array->butterfly()->contiguousInt32()[i].get();
+                    ASSERT(!indexValue || indexValue.isInt32());
+                    if (!indexValue)
+                        result.uncheckedAppend(0);
+                    else
+                        result.uncheckedAppend(indexValue.asInt32());
+                }
+                return result;
+            }
+
+            if (indexingType == JSC::DoubleShape) {
+                for (unsigned i = 0; i < length; i++) {
+                    auto doubleValue = array->butterfly()->contiguousDouble()[i];
+                    if (std::isnan(doubleValue))
+                        result.uncheckedAppend(0);
+                    else {
+                        auto convertedValue = Converter<IDLType>::convert(state, scope, doubleValue);
+                        RETURN_IF_EXCEPTION(scope, { });
+
+                        result.uncheckedAppend(convertedValue);
+                    }
+                }
+                return result;
+            }
+
+            for (unsigned i = 0; i < length; i++) {
+                auto indexValue = array->getDirectIndex(&state, i);
+                RETURN_IF_EXCEPTION(scope, { });
+                
+                if (!indexValue)
+                    result.uncheckedAppend(0);
+                else {
+                    auto convertedValue = Converter<IDLType>::convert(state, indexValue);
+                    RETURN_IF_EXCEPTION(scope, { });
+                    
+                    result.uncheckedAppend(convertedValue);
+                }
+            }
+            return result;
+        }
     };
 
     template<typename IDLType>
-    struct ArrayConverter : ArrayConverterBase<IDLType> {
-        using ReturnType = typename ArrayConverterBase<IDLType>::ReturnType;
+    struct SequenceConverter {
+        using GenericConverter = GenericSequenceConverter<IDLType>;
+        using ReturnType = typename GenericConverter::ReturnType;
 
         static ReturnType convert(JSC::ExecState& state, JSC::JSValue value)
         {
@@ -901,26 +1036,112 @@ namespace Detail {
                 return { };
             }
 
+            JSC::JSObject* object = JSC::asObject(value);
+            if (!JSC::isJSArray(object))
+                return GenericConverter::convert(state, object);
+
+            JSC::JSArray* array = JSC::asArray(object);
+            if (!array->globalObject()->isArrayIteratorProtocolFastAndNonObservable())
+                return GenericConverter::convert(state, object);
+
+            unsigned length = array->length();
+
             ReturnType result;
-            forEachInIterable(&state, value, [&result](JSC::VM& vm, JSC::ExecState* state, JSC::JSValue jsValue) {
-                auto scope = DECLARE_THROW_SCOPE(vm);
+            if (!result.tryReserveCapacity(length)) {
+                // FIXME: Is the right exception to throw?
+                throwTypeError(&state, scope);
+                return { };
+            }
 
-                auto convertedValue = Converter<IDLType>::convert(*state, jsValue);
-                if (UNLIKELY(scope.exception()))
-                    return;
-                result.append(WTFMove(convertedValue));
-            });
+            JSC::IndexingType indexingType = array->indexingType() & JSC::IndexingShapeMask;
+
+            if (indexingType == JSC::ContiguousShape) {
+                for (unsigned i = 0; i < length; i++) {
+                    auto indexValue = array->butterfly()->contiguous()[i].get();
+                    if (!indexValue)
+                        indexValue = JSC::jsUndefined();
+
+                    auto convertedValue = Converter<IDLType>::convert(state, indexValue);
+                    RETURN_IF_EXCEPTION(scope, { });
+
+                    result.uncheckedAppend(convertedValue);
+                }
+                return result;
+            }
+
+            for (unsigned i = 0; i < length; i++) {
+                auto indexValue = array->getDirectIndex(&state, i);
+                RETURN_IF_EXCEPTION(scope, { });
+
+                if (!indexValue)
+                    indexValue = JSC::jsUndefined();
+
+                auto convertedValue = Converter<IDLType>::convert(state, indexValue);
+                RETURN_IF_EXCEPTION(scope, { });
+                
+                result.uncheckedAppend(convertedValue);
+            }
             return result;
         }
     };
+
+    template<>
+    struct SequenceConverter<IDLLong> {
+        using ReturnType = typename GenericSequenceConverter<IDLLong>::ReturnType;
+
+        static ReturnType convert(JSC::ExecState& state, JSC::JSValue value)
+        {
+            return NumericSequenceConverter<IDLLong>::convert(state, value);
+        }
+    };
+
+    template<>
+    struct SequenceConverter<IDLFloat> {
+        using ReturnType = typename GenericSequenceConverter<IDLFloat>::ReturnType;
+
+        static ReturnType convert(JSC::ExecState& state, JSC::JSValue value)
+        {
+            return NumericSequenceConverter<IDLFloat>::convert(state, value);
+        }
+    };
+
+    template<>
+    struct SequenceConverter<IDLUnrestrictedFloat> {
+        using ReturnType = typename GenericSequenceConverter<IDLUnrestrictedFloat>::ReturnType;
+
+        static ReturnType convert(JSC::ExecState& state, JSC::JSValue value)
+        {
+            return NumericSequenceConverter<IDLUnrestrictedFloat>::convert(state, value);
+        }
+    };
+
+    template<>
+    struct SequenceConverter<IDLDouble> {
+        using ReturnType = typename GenericSequenceConverter<IDLDouble>::ReturnType;
+
+        static ReturnType convert(JSC::ExecState& state, JSC::JSValue value)
+        {
+            return NumericSequenceConverter<IDLDouble>::convert(state, value);
+        }
+    };
+
+    template<>
+    struct SequenceConverter<IDLUnrestrictedDouble> {
+        using ReturnType = typename GenericSequenceConverter<IDLUnrestrictedDouble>::ReturnType;
+
+        static ReturnType convert(JSC::ExecState& state, JSC::JSValue value)
+        {
+            return NumericSequenceConverter<IDLUnrestrictedDouble>::convert(state, value);
+        }
+    };
 }
 
 template<typename T> struct Converter<IDLSequence<T>> : DefaultConverter<IDLSequence<T>> {
-    using ReturnType = typename Detail::ArrayConverter<T>::ReturnType;
+    using ReturnType = typename Detail::SequenceConverter<T>::ReturnType;
 
     static ReturnType convert(JSC::ExecState& state, JSC::JSValue value)
     {
-        return Detail::ArrayConverter<T>::convert(state, value);
+        return Detail::SequenceConverter<T>::convert(state, value);
     }
 };
 
@@ -939,11 +1160,11 @@ template<typename T> struct JSConverter<IDLSequence<T>> {
 };
 
 template<typename T> struct Converter<IDLFrozenArray<T>> : DefaultConverter<IDLFrozenArray<T>> {
-    using ReturnType = typename Detail::ArrayConverter<T>::ReturnType;
+    using ReturnType = typename Detail::SequenceConverter<T>::ReturnType;
 
     static ReturnType convert(JSC::ExecState& state, JSC::JSValue value)
     {
-        return Detail::ArrayConverter<T>::convert(state, value);
+        return Detail::SequenceConverter<T>::convert(state, value);
     }
 };
 
@@ -1577,7 +1798,7 @@ template<typename T> struct JSConverter<IDLXPathNSResolver<T>> {
 // MARK: -
 // MARK: IDLIDBKey type
 
-template<typename T> struct JSConverter<IDLIDBKey<T>> {
+template<> struct JSConverter<IDLIDBKey> {
     static constexpr bool needsState = true;
     static constexpr bool needsGlobalObject = true;
 
@@ -1588,6 +1809,23 @@ template<typename T> struct JSConverter<IDLIDBKey<T>> {
     }
 };
 
+#if ENABLE(WEBGL)
+
+// MARK: -
+// MARK: IDLWebGLAny type
+
+template<> struct JSConverter<IDLWebGLAny> {
+    static constexpr bool needsState = true;
+    static constexpr bool needsGlobalObject = true;
+
+    static JSC::JSValue convert(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const WebGLAny& value)
+    {
+        return convertToJSValue(state, globalObject, value);
+    }
+};
+
+#endif
+
 // MARK: -
 // MARK: Support for variadic tail convertions
 
index 4c50ccf..9cefb0e 100644 (file)
@@ -28,9 +28,7 @@
 #if ENABLE(WEBGL) && ENABLE(WEBGL2)
 
 #include "JSWebGL2RenderingContext.h"
-#include "NotImplemented.h"
 #include <heap/HeapInlines.h>
-#include <runtime/Error.h>
 
 using namespace JSC;
 
@@ -41,51 +39,6 @@ void JSWebGL2RenderingContext::visitAdditionalChildren(SlotVisitor& visitor)
     visitor.addOpaqueRoot(&wrapped());
 }
 
-JSValue JSWebGL2RenderingContext::getInternalformatParameter(ExecState&)
-{
-    return jsUndefined();
-}
-
-JSValue JSWebGL2RenderingContext::getQueryParameter(ExecState&)
-{
-    return jsUndefined();
-}
-
-JSValue JSWebGL2RenderingContext::getSamplerParameter(ExecState&)
-{
-    return jsUndefined();
-}
-
-JSValue JSWebGL2RenderingContext::getSyncParameter(ExecState&)
-{
-    return jsUndefined();
-}
-
-JSValue JSWebGL2RenderingContext::getIndexedParameter(ExecState& state)
-{
-    VM& vm = state.vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    if (state.argumentCount() < 2)
-        return throwException(&state, scope, createNotEnoughArgumentsError(&state));
-
-    unsigned pname = state.uncheckedArgument(0).toInt32(&state);
-    RETURN_IF_EXCEPTION(scope, JSValue());
-    unsigned index = state.uncheckedArgument(1).toInt32(&state);
-    RETURN_IF_EXCEPTION(scope, JSValue());
-    return toJS(state, *globalObject(), wrapped().getIndexedParameter(pname, index));
-}
-
-JSValue JSWebGL2RenderingContext::getActiveUniformBlockParameter(ExecState&)
-{
-    return jsUndefined();
-}
-
-JSValue JSWebGL2RenderingContext::getActiveUniformBlockName(ExecState&)
-{
-    return jsUndefined();
-}
-
 } // namespace WebCore
 
 #endif // ENABLE(WEBGL)
index 1ebfba5..66d7ebd 100644 (file)
@@ -123,21 +123,6 @@ JSValue toJS(ExecState* state, JSDOMGlobalObject* globalObject, WebGLRenderingCo
     return wrap(state, globalObject, object);
 }
     
-static JSValue objectParameter(JSWebGLRenderingContextBase& context, ExecState& state, WebGLAny (WebGLRenderingContextBase::*getter)(GC3Denum target, GC3Denum pname))
-{
-    VM& vm = state.vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    if (state.argumentCount() != 2)
-        return throwException(&state, scope, createNotEnoughArgumentsError(&state));
-    
-    auto target = state.uncheckedArgument(0).toInt32(&state);
-    RETURN_IF_EXCEPTION(scope, { });
-    auto pname = state.uncheckedArgument(1).toInt32(&state);
-    RETURN_IF_EXCEPTION(scope, { });
-    return toJS(state, *context.globalObject(), (context.wrapped().*getter)(target, pname));
-}
-
 static JSValue toJS(ExecState& state, JSDOMGlobalObject& globalObject, WebGLExtension* extension)
 {
     if (!extension)
@@ -203,26 +188,6 @@ void JSWebGLRenderingContextBase::visitAdditionalChildren(SlotVisitor& visitor)
     visitor.addOpaqueRoot(root(wrapped().canvas()));
 }
 
-JSValue JSWebGLRenderingContextBase::getAttachedShaders(ExecState& state)
-{
-    VM& vm = state.vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    if (state.argumentCount() < 1)
-        return throwException(&state, scope, createNotEnoughArgumentsError(&state));
-    auto& context = wrapped();
-    auto* program = JSWebGLProgram::toWrapped(state.uncheckedArgument(0));
-    if (!program && !state.uncheckedArgument(0).isUndefinedOrNull())
-        return throwTypeError(&state, scope);
-    Vector<RefPtr<WebGLShader>> shaders;
-    if (!context.getAttachedShaders(program, shaders))
-        return jsNull();
-    MarkedArgumentBuffer list;
-    for (auto& shader : shaders)
-        list.append(toJS(&state, globalObject(), shader.get()));
-    return constructArray(&state, 0, globalObject(), list);
-}
-
 JSValue JSWebGLRenderingContextBase::getExtension(ExecState& state)
 {
     VM& vm = state.vm();
@@ -236,423 +201,6 @@ JSValue JSWebGLRenderingContextBase::getExtension(ExecState& state)
     return toJS(state, *globalObject(), wrapped().getExtension(name));
 }
 
-JSValue JSWebGLRenderingContextBase::getBufferParameter(ExecState& state)
-{
-    return objectParameter(*this, state, &WebGLRenderingContextBase::getBufferParameter);
-}
-
-JSValue JSWebGLRenderingContextBase::getFramebufferAttachmentParameter(ExecState& state)
-{
-    VM& vm = state.vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    if (state.argumentCount() != 3)
-        return throwException(&state, scope, createNotEnoughArgumentsError(&state));
-    
-    auto target = state.uncheckedArgument(0).toInt32(&state);
-    RETURN_IF_EXCEPTION(scope, { });
-    auto attachment = state.uncheckedArgument(1).toInt32(&state);
-    RETURN_IF_EXCEPTION(scope, { });
-    auto pname = state.uncheckedArgument(2).toInt32(&state);
-    RETURN_IF_EXCEPTION(scope, { });
-    return toJS(state, *globalObject(), wrapped().getFramebufferAttachmentParameter(target, attachment, pname));
-}
-
-JSValue JSWebGLRenderingContextBase::getParameter(ExecState& state)
-{
-    VM& vm = state.vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    if (state.argumentCount() != 1)
-        return throwException(&state, scope, createNotEnoughArgumentsError(&state));
-    
-    auto pname = state.uncheckedArgument(0).toInt32(&state);
-    RETURN_IF_EXCEPTION(scope, { });
-    return toJS(state, *globalObject(), wrapped().getParameter(pname));
-}
-
-JSValue JSWebGLRenderingContextBase::getProgramParameter(ExecState& state)
-{
-    VM& vm = state.vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    if (state.argumentCount() != 2)
-        return throwException(&state, scope, createNotEnoughArgumentsError(&state));
-    
-    auto* program = JSWebGLProgram::toWrapped(state.uncheckedArgument(0));
-    if (!program && !state.uncheckedArgument(0).isUndefinedOrNull())
-        return throwTypeError(&state, scope);
-    auto pname = state.uncheckedArgument(1).toInt32(&state);
-    RETURN_IF_EXCEPTION(scope, { });
-    return toJS(state, *globalObject(), wrapped().getProgramParameter(program, pname));
-}
-
-JSValue JSWebGLRenderingContextBase::getRenderbufferParameter(ExecState& state)
-{
-    return objectParameter(*this, state, &WebGLRenderingContextBase::getRenderbufferParameter);
-}
-
-JSValue JSWebGLRenderingContextBase::getShaderParameter(ExecState& state)
-{
-    VM& vm = state.vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    if (state.argumentCount() != 2)
-        return throwException(&state, scope, createNotEnoughArgumentsError(&state));
-    
-    if (!state.uncheckedArgument(0).isUndefinedOrNull() && !state.uncheckedArgument(0).inherits(JSWebGLShader::info()))
-        return throwTypeError(&state, scope);
-    WebGLShader* shader = JSWebGLShader::toWrapped(state.uncheckedArgument(0));
-    unsigned pname = state.uncheckedArgument(1).toInt32(&state);
-    RETURN_IF_EXCEPTION(scope, { });
-    return toJS(state, *globalObject(), wrapped().getShaderParameter(shader, pname));
-}
-
-JSValue JSWebGLRenderingContextBase::getSupportedExtensions(ExecState& state)
-{
-    WebGLRenderingContextBase& context = wrapped();
-    if (context.isContextLost())
-        return jsNull();
-    MarkedArgumentBuffer list;
-    for (auto& extension : context.getSupportedExtensions())
-        list.append(jsStringWithCache(&state, extension));
-    return constructArray(&state, 0, globalObject(), list);
-}
-
-JSValue JSWebGLRenderingContextBase::getTexParameter(ExecState& state)
-{
-    return objectParameter(*this, state, &WebGLRenderingContextBase::getTexParameter);
-}
-
-JSValue JSWebGLRenderingContextBase::getUniform(ExecState& state)
-{
-    VM& vm = state.vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    if (state.argumentCount() != 2)
-        return throwException(&state, scope, createNotEnoughArgumentsError(&state));
-    
-    WebGLProgram* program = JSWebGLProgram::toWrapped(state.uncheckedArgument(0));
-    if (!program && !state.uncheckedArgument(0).isUndefinedOrNull())
-        return throwTypeError(&state, scope);
-    WebGLUniformLocation* location = JSWebGLUniformLocation::toWrapped(state.uncheckedArgument(1));
-    if (!location && !state.uncheckedArgument(1).isUndefinedOrNull())
-        return throwTypeError(&state, scope);
-    return toJS(state, *globalObject(), wrapped().getUniform(program, location));
-}
-
-JSValue JSWebGLRenderingContextBase::getVertexAttrib(ExecState& state)
-{
-    return objectParameter(*this, state, &WebGLRenderingContextBase::getVertexAttrib);
-}
-
-template<typename VectorType> bool toNumberVector(ExecState& state, JSValue value, VectorType& vector)
-{
-    VM& vm = state.vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    if (!value.isObject())
-        return false;
-
-    auto& object = *asObject(value);
-    int32_t length = object.get(&state, state.vm().propertyNames->length).toInt32(&state);
-
-    if (!vector.tryReserveCapacity(length))
-        return false;
-
-    for (int32_t i = 0; i < length; ++i) {
-        auto value = object.get(&state, i);
-        RETURN_IF_EXCEPTION(scope, false);
-        vector.uncheckedAppend(value.toNumber(&state));
-        RETURN_IF_EXCEPTION(scope, false);
-    }
-
-    return true;
-}
-
-enum DataFunctionToCall {
-    f_uniform1v, f_uniform2v, f_uniform3v, f_uniform4v,
-    f_vertexAttrib1v, f_vertexAttrib2v, f_vertexAttrib3v, f_vertexAttrib4v
-};
-
-enum DataFunctionMatrixToCall {
-    f_uniformMatrix2fv, f_uniformMatrix3fv, f_uniformMatrix4fv
-};
-
-static inline bool functionForUniform(DataFunctionToCall f)
-{
-    switch (f) {
-    case f_uniform1v:
-    case f_uniform2v:
-    case f_uniform3v:
-    case f_uniform4v:
-        return true;
-    default:
-        return false;
-    }
-}
-
-static JSValue dataFunctionf(DataFunctionToCall f, ExecState& state, WebGLRenderingContextBase& context)
-{
-    VM& vm = state.vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    if (state.argumentCount() != 2)
-        return throwException(&state, scope, createNotEnoughArgumentsError(&state));
-    
-    WebGLUniformLocation* location = nullptr;
-    GLuint index = -1;
-
-    if (functionForUniform(f)) {
-        location = JSWebGLUniformLocation::toWrapped(state.uncheckedArgument(0));
-        if (!location && !state.uncheckedArgument(0).isUndefinedOrNull())
-            return throwTypeError(&state, scope);
-    } else {
-        index = state.uncheckedArgument(0).toInt32(&state);
-        RETURN_IF_EXCEPTION(scope, { });
-    }
-
-    if (auto webGLArray = toUnsharedFloat32Array(state.uncheckedArgument(1))) {
-        switch (f) {
-        case f_uniform1v:
-            context.uniform1fv(location, *webGLArray);
-            break;
-        case f_uniform2v:
-            context.uniform2fv(location, *webGLArray);
-            break;
-        case f_uniform3v:
-            context.uniform3fv(location, *webGLArray);
-            break;
-        case f_uniform4v:
-            context.uniform4fv(location, *webGLArray);
-            break;
-        case f_vertexAttrib1v:
-            context.vertexAttrib1fv(index, *webGLArray);
-            break;
-        case f_vertexAttrib2v:
-            context.vertexAttrib2fv(index, *webGLArray);
-            break;
-        case f_vertexAttrib3v:
-            context.vertexAttrib3fv(index, *webGLArray);
-            break;
-        case f_vertexAttrib4v:
-            context.vertexAttrib4fv(index, *webGLArray);
-            break;
-        }
-        return jsUndefined();
-    }
-
-    Vector<float, 64> array;
-    if (!toNumberVector(state, state.uncheckedArgument(1), array))
-        return throwTypeError(&state, scope);
-
-    switch (f) {
-    case f_uniform1v:
-        context.uniform1fv(location, array.data(), array.size());
-        break;
-    case f_uniform2v:
-        context.uniform2fv(location, array.data(), array.size());
-        break;
-    case f_uniform3v:
-        context.uniform3fv(location, array.data(), array.size());
-        break;
-    case f_uniform4v:
-        context.uniform4fv(location, array.data(), array.size());
-        break;
-    case f_vertexAttrib1v:
-        context.vertexAttrib1fv(index, array.data(), array.size());
-        break;
-    case f_vertexAttrib2v:
-        context.vertexAttrib2fv(index, array.data(), array.size());
-        break;
-    case f_vertexAttrib3v:
-        context.vertexAttrib3fv(index, array.data(), array.size());
-        break;
-    case f_vertexAttrib4v:
-        context.vertexAttrib4fv(index, array.data(), array.size());
-        break;
-    }
-    return jsUndefined();
-}
-
-static JSValue dataFunctioni(DataFunctionToCall f, ExecState& state, WebGLRenderingContextBase& context)
-{
-    VM& vm = state.vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    if (state.argumentCount() != 2)
-        return throwException(&state, scope, createNotEnoughArgumentsError(&state));
-
-    auto* location = JSWebGLUniformLocation::toWrapped(state.uncheckedArgument(0));
-    if (!location && !state.uncheckedArgument(0).isUndefinedOrNull())
-        return throwTypeError(&state, scope);
-
-    if (auto webGLArray = toUnsharedInt32Array(state.uncheckedArgument(1))) {
-        switch (f) {
-        case f_uniform1v:
-            context.uniform1iv(location, *webGLArray);
-            break;
-        case f_uniform2v:
-            context.uniform2iv(location, *webGLArray);
-            break;
-        case f_uniform3v:
-            context.uniform3iv(location, *webGLArray);
-            break;
-        case f_uniform4v:
-            context.uniform4iv(location, *webGLArray);
-            break;
-        default:
-            break;
-        }
-        return jsUndefined();
-    }
-
-    Vector<int, 64> array;
-    if (!toNumberVector(state, state.uncheckedArgument(1), array))
-        return throwTypeError(&state, scope);
-
-    switch (f) {
-    case f_uniform1v:
-        context.uniform1iv(location, array.data(), array.size());
-        break;
-    case f_uniform2v:
-        context.uniform2iv(location, array.data(), array.size());
-        break;
-    case f_uniform3v:
-        context.uniform3iv(location, array.data(), array.size());
-        break;
-    case f_uniform4v:
-        context.uniform4iv(location, array.data(), array.size());
-        break;
-    default:
-        break;
-    }
-    return jsUndefined();
-}
-
-static JSValue dataFunctionMatrix(DataFunctionMatrixToCall f, ExecState& state, WebGLRenderingContextBase& context)
-{
-    VM& vm = state.vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    if (state.argumentCount() != 3)
-        return throwException(&state, scope, createNotEnoughArgumentsError(&state));
-
-    auto* location = JSWebGLUniformLocation::toWrapped(state.uncheckedArgument(0));
-    if (!location && !state.uncheckedArgument(0).isUndefinedOrNull())
-        return throwTypeError(&state, scope);
-
-    bool transpose = state.uncheckedArgument(1).toBoolean(&state);
-    RETURN_IF_EXCEPTION(scope, { });
-
-    if (auto webGLArray = toUnsharedFloat32Array(state.uncheckedArgument(2))) {
-        switch (f) {
-        case f_uniformMatrix2fv:
-            context.uniformMatrix2fv(location, transpose, *webGLArray);
-            break;
-        case f_uniformMatrix3fv:
-            context.uniformMatrix3fv(location, transpose, *webGLArray);
-            break;
-        case f_uniformMatrix4fv:
-            context.uniformMatrix4fv(location, transpose, *webGLArray);
-            break;
-        }
-        return jsUndefined();
-    }
-
-    Vector<float, 64> array;
-    if (!toNumberVector(state, state.uncheckedArgument(2), array))
-        return throwTypeError(&state, scope);
-
-    switch (f) {
-    case f_uniformMatrix2fv:
-        context.uniformMatrix2fv(location, transpose, array.data(), array.size());
-        break;
-    case f_uniformMatrix3fv:
-        context.uniformMatrix3fv(location, transpose, array.data(), array.size());
-        break;
-    case f_uniformMatrix4fv:
-        context.uniformMatrix4fv(location, transpose, array.data(), array.size());
-        break;
-    }
-    return jsUndefined();
-}
-
-JSValue JSWebGLRenderingContextBase::uniform1fv(ExecState& state)
-{
-    return dataFunctionf(f_uniform1v, state, wrapped());
-}
-
-JSValue JSWebGLRenderingContextBase::uniform1iv(ExecState& state)
-{
-    return dataFunctioni(f_uniform1v, state, wrapped());
-}
-
-JSValue JSWebGLRenderingContextBase::uniform2fv(ExecState& state)
-{
-    return dataFunctionf(f_uniform2v, state, wrapped());
-}
-
-JSValue JSWebGLRenderingContextBase::uniform2iv(ExecState& state)
-{
-    return dataFunctioni(f_uniform2v, state, wrapped());
-}
-
-JSValue JSWebGLRenderingContextBase::uniform3fv(ExecState& state)
-{
-    return dataFunctionf(f_uniform3v, state, wrapped());
-}
-
-JSValue JSWebGLRenderingContextBase::uniform3iv(ExecState& state)
-{
-    return dataFunctioni(f_uniform3v, state, wrapped());
-}
-
-JSValue JSWebGLRenderingContextBase::uniform4fv(ExecState& state)
-{
-    return dataFunctionf(f_uniform4v, state, wrapped());
-}
-
-JSValue JSWebGLRenderingContextBase::uniform4iv(ExecState& state)
-{
-    return dataFunctioni(f_uniform4v, state, wrapped());
-}
-
-JSValue JSWebGLRenderingContextBase::uniformMatrix2fv(ExecState& state)
-{
-    return dataFunctionMatrix(f_uniformMatrix2fv, state, wrapped());
-}
-
-JSValue JSWebGLRenderingContextBase::uniformMatrix3fv(ExecState& state)
-{
-    return dataFunctionMatrix(f_uniformMatrix3fv, state, wrapped());
-}
-
-JSValue JSWebGLRenderingContextBase::uniformMatrix4fv(ExecState& state)
-{
-    return dataFunctionMatrix(f_uniformMatrix4fv, state, wrapped());
-}
-
-JSValue JSWebGLRenderingContextBase::vertexAttrib1fv(ExecState& state)
-{
-    return dataFunctionf(f_vertexAttrib1v, state, wrapped());
-}
-
-JSValue JSWebGLRenderingContextBase::vertexAttrib2fv(ExecState& state)
-{
-    return dataFunctionf(f_vertexAttrib2v, state, wrapped());
-}
-
-JSValue JSWebGLRenderingContextBase::vertexAttrib3fv(ExecState& state)
-{
-    return dataFunctionf(f_vertexAttrib3v, state, wrapped());
-}
-
-JSValue JSWebGLRenderingContextBase::vertexAttrib4fv(ExecState& state)
-{
-    return dataFunctionf(f_vertexAttrib4v, state, wrapped());
-}
-
 } // namespace WebCore
 
 #endif // ENABLE(WEBGL)
index c302d0a..ed47356 100644 (file)
@@ -878,7 +878,6 @@ sub IsBuiltinType
     return 1 if $type->isUnion;
     return 1 if $type->name eq "BufferSource";
     return 1 if $type->name eq "EventListener";
-    return 1 if $type->name eq "IDBKey";
     return 1 if $type->name eq "JSON";
     return 1 if $type->name eq "Promise";
     return 1 if $type->name eq "SerializedScriptValue";
index ad656ca..222f97e 100644 (file)
@@ -5083,7 +5083,11 @@ sub GetIDLUnionMemberTypes
 
 sub GetBaseIDLType
 {
-    my ($interface, $type) = @_;
+    my ($interface, $type, $context) = @_;
+
+    if ($context && $context->extendedAttributes->{OverrideIDLType}) {
+        return $context->extendedAttributes->{OverrideIDLType};
+    }
 
     my %IDLTypes = (
         "any" => "IDLAny",
@@ -5108,7 +5112,6 @@ sub GetBaseIDLType
         # Non-WebIDL extensions
         "Date" => "IDLDate",
         "EventListener" => "IDLEventListener<JSEventListener>",
-        "IDBKey" => "IDLIDBKey<IDBKey>",
         "JSON" => "IDLJSON",
         "SerializedScriptValue" => "IDLSerializedScriptValue<SerializedScriptValue>",
         "XPathNSResolver" => "IDLXPathNSResolver<XPathNSResolver>",
@@ -5133,9 +5136,9 @@ sub GetBaseIDLType
 
 sub GetIDLType
 {
-    my ($interface, $type) = @_;
+    my ($interface, $type, $context) = @_;
 
-    my $baseIDLType = GetBaseIDLType($interface, $type);
+    my $baseIDLType = GetBaseIDLType($interface, $type, $context);
     return "IDLNullable<" . $baseIDLType . ">" if $type->isNullable;
     return $baseIDLType;
 }
@@ -5322,8 +5325,19 @@ sub UnsafeToNative
 
 sub NativeToJSValueDOMConvertNeedsState
 {
-    my ($type) = @_;
-    
+    my ($type, $context) = @_;
+
+    # FIXME: We need a more robost way to specify this requirement so as not
+    # to require specializing each type. Perhaps just requiring all override
+    # types to take both state and the global object would work?
+    if ($context->extendedAttributes->{OverrideIDLType}) {
+        my $overrideTypeName = $context->extendedAttributes->{OverrideIDLType};
+        return 1 if $overrideTypeName eq "IDLIDBKey";
+        return 1 if $overrideTypeName eq "IDLWebGLAny";
+
+        return 0;
+    }
+
     # FIXME: This should actually check if all the sub-objects of the union need the state.
     return 1 if $type->isUnion;
     return 1 if $codeGenerator->IsSequenceOrFrozenArrayType($type);
@@ -5334,7 +5348,6 @@ sub NativeToJSValueDOMConvertNeedsState
     return 1 if $codeGenerator->IsInterfaceType($type);
     return 1 if $codeGenerator->IsTypedArrayType($type);
     return 1 if $type->name eq "Date";
-    return 1 if $type->name eq "IDBKey";
     return 1 if $type->name eq "JSON";
     return 1 if $type->name eq "SerializedScriptValue";
     return 1 if $type->name eq "XPathNSResolver";
@@ -5344,8 +5357,19 @@ sub NativeToJSValueDOMConvertNeedsState
 
 sub NativeToJSValueDOMConvertNeedsGlobalObject
 {
-    my ($type) = @_;
+    my ($type, $context) = @_;
     
+    # FIXME: We need a more robost way to specify this requirement so as not
+    # to require specializing each type. Perhaps just requiring all override
+    # types to take both state and the global object would work?
+    if ($context->extendedAttributes->{OverrideIDLType}) {
+        my $overrideTypeName = $context->extendedAttributes->{OverrideIDLType};
+        return 1 if $overrideTypeName eq "IDLIDBKey";
+        return 1 if $overrideTypeName eq "IDLWebGLAny";
+
+        return 0;
+    }
+
     # FIXME: This should actually check if all the sub-objects of the union need the global object.
     return 1 if $type->isUnion;
     return 1 if $codeGenerator->IsSequenceOrFrozenArrayType($type);
@@ -5353,7 +5377,6 @@ sub NativeToJSValueDOMConvertNeedsGlobalObject
     return 1 if $codeGenerator->IsDictionaryType($type);
     return 1 if $codeGenerator->IsInterfaceType($type);
     return 1 if $codeGenerator->IsTypedArrayType($type);
-    return 1 if $type->name eq "IDBKey";
     return 1 if $type->name eq "SerializedScriptValue";
     return 1 if $type->name eq "XPathNSResolver";
 
@@ -5410,11 +5433,11 @@ sub NativeToJSValue
 
     $value = "BindingSecurity::checkSecurityForNode($stateReference, $value)" if $context->extendedAttributes->{CheckSecurityForNode};
 
-    my $IDLType = GetIDLType($interface, $type);
+    my $IDLType = GetIDLType($interface, $type, $context);
 
     my @conversionArguments = ();
-    push(@conversionArguments, $stateReference) if NativeToJSValueDOMConvertNeedsState($type) || $mayThrowException;
-    push(@conversionArguments, $globalObjectReference) if NativeToJSValueDOMConvertNeedsGlobalObject($type);
+    push(@conversionArguments, $stateReference) if NativeToJSValueDOMConvertNeedsState($type, $context) || $mayThrowException;
+    push(@conversionArguments, $globalObjectReference) if NativeToJSValueDOMConvertNeedsGlobalObject($type, $context);
     push(@conversionArguments, "throwScope") if $mayThrowException;
     push(@conversionArguments, $value);
 
index 717617c..ad0e494 100644 (file)
@@ -99,6 +99,7 @@ NewObject
 NoInterfaceObject
 NotEnumerable
 OverrideBuiltins
+OverrideIDLType=*
 PassContext
 PrimaryGlobal
 PrivateIdentifier
index 79c13c2..9cfb4f0 100644 (file)
@@ -1087,8 +1087,11 @@ WebGLExtension* WebGL2RenderingContext::getExtension(const String& name)
     return nullptr;
 }
 
-Vector<String> WebGL2RenderingContext::getSupportedExtensions()
+std::optional<Vector<String>> WebGL2RenderingContext::getSupportedExtensions()
 {
+    if (isContextLost())
+        return std::nullopt;
+
     Vector<String> result;
     
     if (m_isPendingPolicyResolution)
index b4803af..720b132 100644 (file)
@@ -173,7 +173,7 @@ private:
 
     // Extensions
     WebGLExtension* getExtension(const String&) final;
-    Vector<String> getSupportedExtensions() final;
+    std::optional<Vector<String>> getSupportedExtensions() final;
     WebGLAny getParameter(GC3Denum pname) final;
 
     void renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height) final;
index 59774c8..15c2f4e 100644 (file)
@@ -354,7 +354,7 @@ typedef (ImageData or HTMLImageElement or HTMLCanvasElement or HTMLVideoElement)
     /* Framebuffer objects */
     void blitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
     void framebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    [Custom] any getInternalformatParameter(GLenum target, GLenum internalformat, GLenum pname);
+    [OverrideIDLType=IDLWebGLAny] any getInternalformatParameter(GLenum target, GLenum internalformat, GLenum pname);
     void invalidateFramebuffer(GLenum target, sequence<GLenum> attachments);
     void invalidateSubFramebuffer(GLenum target, sequence<GLenum> attachments, GLint x, GLint y, GLsizei width, GLsizei height);
     void readBuffer(GLenum src);
@@ -418,7 +418,7 @@ typedef (ImageData or HTMLImageElement or HTMLCanvasElement or HTMLVideoElement)
     void beginQuery(GLenum target, WebGLQuery? query);
     void endQuery(GLenum target);
     WebGLQuery getQuery(GLenum target, GLenum pname);
-    [Custom] any getQueryParameter(WebGLQuery? query, GLenum pname);
+    [OverrideIDLType=IDLWebGLAny] any getQueryParameter(WebGLQuery? query, GLenum pname);
 
     /* Sampler Objects */
     WebGLSampler createSampler();
@@ -427,7 +427,7 @@ typedef (ImageData or HTMLImageElement or HTMLCanvasElement or HTMLVideoElement)
     void bindSampler(GLuint unit, WebGLSampler? sampler);
     void samplerParameteri(WebGLSampler? sampler, GLenum pname, GLint param);
     void samplerParameterf(WebGLSampler? sampler, GLenum pname, GLfloat param);
-    [Custom] any getSamplerParameter(WebGLSampler? sampler, GLenum pname);
+    [OverrideIDLType=IDLWebGLAny] any getSamplerParameter(WebGLSampler? sampler, GLenum pname);
 
     /* Sync objects */
     WebGLSync fenceSync(GLenum condition, GLbitfield flags);
@@ -435,7 +435,7 @@ typedef (ImageData or HTMLImageElement or HTMLCanvasElement or HTMLVideoElement)
     void deleteSync(WebGLSync? sync);
     GLenum clientWaitSync(WebGLSync? sync, GLbitfield flags, GLuint64 timeout);
     void waitSync(WebGLSync? sync, GLbitfield flags, GLuint64 timeout);
-    [Custom] any getSyncParameter(WebGLSync? sync, GLenum pname);
+    [OverrideIDLType=IDLWebGLAny] any getSyncParameter(WebGLSync? sync, GLenum pname);
 
     /* Transform Feedback */
     WebGLTransformFeedback createTransformFeedback();
@@ -452,12 +452,12 @@ typedef (ImageData or HTMLImageElement or HTMLCanvasElement or HTMLVideoElement)
     /* Uniform Buffer Objects and Transform Feedback Buffers */
     void bindBufferBase(GLenum target, GLuint index, WebGLBuffer? buffer);
     void bindBufferRange(GLenum target, GLuint index, WebGLBuffer? buffer, GLintptr offset, GLsizeiptr size);
-    [Custom] any getIndexedParameter(GLenum target, GLuint index);
+    [OverrideIDLType=IDLWebGLAny] any getIndexedParameter(GLenum target, GLuint index);
     Uint32Array getUniformIndices(WebGLProgram? program, sequence<DOMString> uniformNames);
     Int32Array getActiveUniforms(WebGLProgram? program, Uint32Array? uniformIndices, GLenum pname);
     GLuint getUniformBlockIndex(WebGLProgram? program, DOMString uniformBlockName);
-    [Custom] any getActiveUniformBlockParameter(WebGLProgram? program, GLuint uniformBlockIndex, GLenum pname);
-    [Custom] any getActiveUniformBlockName(WebGLProgram? program, GLuint uniformBlockIndex);
+    [OverrideIDLType=IDLWebGLAny] any getActiveUniformBlockParameter(WebGLProgram? program, GLuint uniformBlockIndex, GLenum pname);
+    [OverrideIDLType=IDLWebGLAny] any getActiveUniformBlockName(WebGLProgram? program, GLuint uniformBlockIndex);
     void uniformBlockBinding(WebGLProgram? program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
 
     /* Vertex Array Objects */
index e7e4f56..e95b25b 100644 (file)
@@ -45,8 +45,8 @@ namespace WebCore {
 
 using namespace JSC;
 
-// FIXME: This likely can be autogenerated with a bit of work.
-JSValue toJS(ExecState& state, JSDOMGlobalObject& globalObject, const WebGLAny& any)
+// FIXME: This should use the IDLUnion JSConverter.
+JSValue convertToJSValue(ExecState& state, JSDOMGlobalObject& globalObject, const WebGLAny& any)
 {
     return WTF::switchOn(any,
         [] (std::nullptr_t) {
index cc7bb7f..c773b08 100644 (file)
 
 #if ENABLE(WEBGL)
 
-#include "WebGLBuffer.h"
-#include "WebGLFramebuffer.h"
-#include "WebGLProgram.h"
-#include "WebGLRenderbuffer.h"
-#include "WebGLTexture.h"
-#include "WebGLVertexArrayObjectOES.h"
 #include <runtime/Float32Array.h>
 #include <runtime/Int32Array.h>
 #include <runtime/Uint32Array.h>
 #include <runtime/Uint8Array.h>
 
-#if ENABLE(WEBGL2)
-#include "WebGLVertexArrayObject.h"
-#endif
-
 namespace JSC {
 class ExecState;
 class JSValue;
@@ -50,8 +40,23 @@ class JSValue;
 namespace WebCore {
 
 class JSDOMGlobalObject;
+class WebGLBuffer;
+class WebGLFramebuffer;
+class WebGLProgram;
+class WebGLRenderbuffer;
+class WebGLTexture;
+class WebGLVertexArrayObject;
+class WebGLVertexArrayObjectOES;
 
-using WebGLAny = Variant<std::nullptr_t, bool, int, unsigned, long long, float, String, Vector<bool>,
+using WebGLAny = Variant<
+    std::nullptr_t,
+    bool,
+    int,
+    unsigned,
+    long long,
+    float,
+    String,
+    Vector<bool>,
     RefPtr<Float32Array>,
     RefPtr<Int32Array>,
     RefPtr<Uint32Array>,
@@ -67,7 +72,7 @@ using WebGLAny = Variant<std::nullptr_t, bool, int, unsigned, long long, float,
 #endif
 >;
 
-JSC::JSValue toJS(JSC::ExecState&, JSDOMGlobalObject&, const WebGLAny&);
+JSC::JSValue convertToJSValue(JSC::ExecState&, JSDOMGlobalObject&, const WebGLAny&);
 
 } // namespace WebCore
 
index 7dffc35..8447cc5 100644 (file)
@@ -249,8 +249,11 @@ WebGLExtension* WebGLRenderingContext::getExtension(const String& name)
     return nullptr;
 }
 
-Vector<String> WebGLRenderingContext::getSupportedExtensions()
+std::optional<Vector<String>> WebGLRenderingContext::getSupportedExtensions()
 {
+    if (isContextLost())
+        return std::nullopt;
+
     Vector<String> result;
     
     if (m_isPendingPolicyResolution)
index 0c61dd6..5f4e5d0 100644 (file)
@@ -39,7 +39,7 @@ private:
 
     WebGLExtension* getExtension(const String&) final;
     WebGLAny getParameter(GC3Denum pname) final;
-    Vector<String> getSupportedExtensions() final;
+    std::optional<Vector<String>> getSupportedExtensions() final;
 
     WebGLAny getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname) final;
     void renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height) final;
index 9845b3e..41c7ac2 100644 (file)
@@ -2135,22 +2135,22 @@ RefPtr<WebGLActiveInfo> WebGLRenderingContextBase::getActiveUniform(WebGLProgram
     return WebGLActiveInfo::create(info.name, info.type, info.size);
 }
 
-bool WebGLRenderingContextBase::getAttachedShaders(WebGLProgram* program, Vector<RefPtr<WebGLShader>>& shaderObjects)
+std::optional<Vector<RefPtr<WebGLShader>>> WebGLRenderingContextBase::getAttachedShaders(WebGLProgram* program)
 {
-    shaderObjects.clear();
     if (isContextLostOrPending() || !validateWebGLObject("getAttachedShaders", program))
-        return false;
+        return std::nullopt;
 
-    const GC3Denum shaderType[] = {
+    const GC3Denum shaderTypes[] = {
         GraphicsContext3D::VERTEX_SHADER,
         GraphicsContext3D::FRAGMENT_SHADER
     };
-    for (unsigned i = 0; i < sizeof(shaderType) / sizeof(GC3Denum); ++i) {
-        WebGLShader* shader = program->getAttachedShader(shaderType[i]);
+    Vector<RefPtr<WebGLShader>> shaderObjects;
+    for (auto shaderType : shaderTypes) {
+        WebGLShader* shader = program->getAttachedShader(shaderType);
         if (shader)
             shaderObjects.append(shader);
     }
-    return true;
+    return shaderObjects;
 }
 
 GC3Dint WebGLRenderingContextBase::getAttribLocation(WebGLProgram* program, const String& name)
@@ -4173,100 +4173,61 @@ void WebGLRenderingContextBase::uniform1f(const WebGLUniformLocation* location,
     m_context->uniform1f(location->location(), x);
 }
 
-void WebGLRenderingContextBase::uniform1fv(const WebGLUniformLocation* location, Float32Array& v)
+void WebGLRenderingContextBase::uniform2f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y)
 {
-    if (isContextLostOrPending() || !validateUniformParameters("uniform1fv", location, v, 1))
+    if (isContextLostOrPending() || !location)
         return;
 
-    m_context->uniform1fv(location->location(), v.length(), v.data());
-}
-
-void WebGLRenderingContextBase::uniform1fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size)
-{
-    if (isContextLostOrPending() || !validateUniformParameters("uniform1fv", location, v, size, 1))
+    if (location->program() != m_currentProgram) {
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform2f", "location not for current program");
         return;
+    }
 
-    m_context->uniform1fv(location->location(), size, v);
+    m_context->uniform2f(location->location(), x, y);
 }
 
-void WebGLRenderingContextBase::uniform1i(const WebGLUniformLocation* location, GC3Dint x)
+void WebGLRenderingContextBase::uniform3f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z)
 {
     if (isContextLostOrPending() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
-        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform1i", "location not for current program");
-        return;
-    }
-
-    if ((location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE) && x >= (int)m_textureUnits.size()) {
-        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1i", "invalid texture unit");
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform3f", "location not for current program");
         return;
     }
 
-    m_context->uniform1i(location->location(), x);
+    m_context->uniform3f(location->location(), x, y, z);
 }
 
-void WebGLRenderingContextBase::uniform1iv(const WebGLUniformLocation* location, Int32Array& v)
+void WebGLRenderingContextBase::uniform4f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w)
 {
-    if (isContextLostOrPending() || !validateUniformParameters("uniform1iv", location, v, 1))
+    if (isContextLostOrPending() || !location)
         return;
 
-    if (location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE)
-        for (unsigned i = 0; i < v.length(); ++i) {
-            if (v.data()[i] >= static_cast<int>(m_textureUnits.size())) {
-                LOG(WebGL, "Texture unit size=%zu, v[%d]=%d. Location type = %04X.", m_textureUnits.size(), i, v.data()[i], location->type());
-                synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1iv", "invalid texture unit");
-                return;
-            }
-        }
-
-    m_context->uniform1iv(location->location(), v.length(), v.data());
-}
-
-void WebGLRenderingContextBase::uniform1iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size)
-{
-    if (isContextLostOrPending() || !validateUniformParameters("uniform1iv", location, v, size, 1))
+    if (location->program() != m_currentProgram) {
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform4f", "location not for current program");
         return;
+    }
 
-    if (location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE)
-        for (unsigned i = 0; i < static_cast<unsigned>(size); ++i) {
-            if (((GC3Dint*)v)[i] >= static_cast<int>(m_textureUnits.size())) {
-                synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1iv", "invalid texture unit");
-                return;
-            }
-        }
-
-    m_context->uniform1iv(location->location(), size, v);
+    m_context->uniform4f(location->location(), x, y, z, w);
 }
 
-void WebGLRenderingContextBase::uniform2f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y)
+void WebGLRenderingContextBase::uniform1i(const WebGLUniformLocation* location, GC3Dint x)
 {
     if (isContextLostOrPending() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
-        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform2f", "location not for current program");
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform1i", "location not for current program");
         return;
     }
 
-    m_context->uniform2f(location->location(), x, y);
-}
-
-void WebGLRenderingContextBase::uniform2fv(const WebGLUniformLocation* location, Float32Array& v)
-{
-    if (isContextLostOrPending() || !validateUniformParameters("uniform2fv", location, v, 2))
-        return;
-
-    m_context->uniform2fv(location->location(), v.length() / 2, v.data());
-}
-
-void WebGLRenderingContextBase::uniform2fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size)
-{
-    if (isContextLostOrPending() || !validateUniformParameters("uniform2fv", location, v, size, 2))
+    if ((location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE) && x >= (int)m_textureUnits.size()) {
+        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1i", "invalid texture unit");
         return;
+    }
 
-    m_context->uniform2fv(location->location(), size / 2, v);
+    m_context->uniform1i(location->location(), x);
 }
 
 void WebGLRenderingContextBase::uniform2i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y)
@@ -4282,94 +4243,57 @@ void WebGLRenderingContextBase::uniform2i(const WebGLUniformLocation* location,
     m_context->uniform2i(location->location(), x, y);
 }
 
-void WebGLRenderingContextBase::uniform2iv(const WebGLUniformLocation* location, Int32Array& v)
-{
-    if (isContextLostOrPending() || !validateUniformParameters("uniform2iv", location, v, 2))
-        return;
-
-    m_context->uniform2iv(location->location(), v.length() / 2, v.data());
-}
-
-void WebGLRenderingContextBase::uniform2iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size)
-{
-    if (isContextLostOrPending() || !validateUniformParameters("uniform2iv", location, v, size, 2))
-        return;
-
-    m_context->uniform2iv(location->location(), size / 2, v);
-}
-
-void WebGLRenderingContextBase::uniform3f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z)
+void WebGLRenderingContextBase::uniform3i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z)
 {
     if (isContextLostOrPending() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
-        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform3f", "location not for current program");
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform3i", "location not for current program");
         return;
     }
 
-    m_context->uniform3f(location->location(), x, y, z);
-}
-
-void WebGLRenderingContextBase::uniform3fv(const WebGLUniformLocation* location, Float32Array& v)
-{
-    if (isContextLostOrPending() || !validateUniformParameters("uniform3fv", location, v, 3))
-        return;
-
-    m_context->uniform3fv(location->location(), v.length() / 3, v.data());
-}
-
-void WebGLRenderingContextBase::uniform3fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size)
-{
-    if (isContextLostOrPending() || !validateUniformParameters("uniform3fv", location, v, size, 3))
-        return;
-
-    m_context->uniform3fv(location->location(), size / 3, v);
+    m_context->uniform3i(location->location(), x, y, z);
 }
 
-void WebGLRenderingContextBase::uniform3i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z)
+void WebGLRenderingContextBase::uniform4i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w)
 {
     if (isContextLostOrPending() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
-        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform3i", "location not for current program");
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform4i", "location not for current program");
         return;
     }
 
-    m_context->uniform3i(location->location(), x, y, z);
+    m_context->uniform4i(location->location(), x, y, z, w);
 }
 
-void WebGLRenderingContextBase::uniform3iv(const WebGLUniformLocation* location, Int32Array& v)
+void WebGLRenderingContextBase::uniform1fv(const WebGLUniformLocation* location, Float32List&& v)
 {
-    if (isContextLostOrPending() || !validateUniformParameters("uniform3iv", location, v, 3))
+    if (isContextLostOrPending() || !validateUniformParameters("uniform1fv", location, v, 1))
         return;
 
-    m_context->uniform3iv(location->location(), v.length() / 3, v.data());
+    m_context->uniform1fv(location->location(), v.length(), v.data());
 }
 
-void WebGLRenderingContextBase::uniform3iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size)
+void WebGLRenderingContextBase::uniform2fv(const WebGLUniformLocation* location, Float32List&& v)
 {
-    if (isContextLostOrPending() || !validateUniformParameters("uniform3iv", location, v, size, 3))
+    if (isContextLostOrPending() || !validateUniformParameters("uniform2fv", location, v, 2))
         return;
 
-    m_context->uniform3iv(location->location(), size / 3, v);
+    m_context->uniform2fv(location->location(), v.length() / 2, v.data());
 }
 
-void WebGLRenderingContextBase::uniform4f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w)
+void WebGLRenderingContextBase::uniform3fv(const WebGLUniformLocation* location, Float32List&& v)
 {
-    if (isContextLostOrPending() || !location)
-        return;
-
-    if (location->program() != m_currentProgram) {
-        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform4f", "location not for current program");
+    if (isContextLostOrPending() || !validateUniformParameters("uniform3fv", location, v, 3))
         return;
-    }
 
-    m_context->uniform4f(location->location(), x, y, z, w);
+    m_context->uniform3fv(location->location(), v.length() / 3, v.data());
 }
 
-void WebGLRenderingContextBase::uniform4fv(const WebGLUniformLocation* location, Float32Array& v)
+void WebGLRenderingContextBase::uniform4fv(const WebGLUniformLocation* location, Float32List&& v)
 {
     if (isContextLostOrPending() || !validateUniformParameters("uniform4fv", location, v, 4))
         return;
@@ -4377,85 +4301,72 @@ void WebGLRenderingContextBase::uniform4fv(const WebGLUniformLocation* location,
     m_context->uniform4fv(location->location(), v.length() / 4, v.data());
 }
 
-void WebGLRenderingContextBase::uniform4fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size)
+void WebGLRenderingContextBase::uniform1iv(const WebGLUniformLocation* location, Int32List&& v)
 {
-    if (isContextLostOrPending() || !validateUniformParameters("uniform4fv", location, v, size, 4))
+    if (isContextLostOrPending() || !validateUniformParameters("uniform1iv", location, v, 1))
         return;
 
-    m_context->uniform4fv(location->location(), size / 4, v);
-}
-
-void WebGLRenderingContextBase::uniform4i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w)
-{
-    if (isContextLostOrPending() || !location)
-        return;
+    auto data = v.data();
+    auto length = v.length();
 
-    if (location->program() != m_currentProgram) {
-        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform4i", "location not for current program");
-        return;
+    if (location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE) {
+        for (auto i = 0; i < length; ++i) {
+            if (data[i] >= static_cast<int>(m_textureUnits.size())) {
+                LOG(WebGL, "Texture unit size=%zu, v[%d]=%d. Location type = %04X.", m_textureUnits.size(), i, data[i], location->type());
+                synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1iv", "invalid texture unit");
+                return;
+            }
+        }
     }
 
-    m_context->uniform4i(location->location(), x, y, z, w);
+    m_context->uniform1iv(location->location(), length, data);
 }
 
-void WebGLRenderingContextBase::uniform4iv(const WebGLUniformLocation* location, Int32Array& v)
+void WebGLRenderingContextBase::uniform2iv(const WebGLUniformLocation* location, Int32List&& v)
 {
-    if (isContextLostOrPending() || !validateUniformParameters("uniform4iv", location, v, 4))
+    if (isContextLostOrPending() || !validateUniformParameters("uniform2iv", location, v, 2))
         return;
 
-    m_context->uniform4iv(location->location(), v.length() / 4, v.data());
+    m_context->uniform2iv(location->location(), v.length() / 2, v.data());
 }
 
-void WebGLRenderingContextBase::uniform4iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size)
+void WebGLRenderingContextBase::uniform3iv(const WebGLUniformLocation* location, Int32List&& v)
 {
-    if (isContextLostOrPending() || !validateUniformParameters("uniform4iv", location, v, size, 4))
+    if (isContextLostOrPending() || !validateUniformParameters("uniform3iv", location, v, 3))
         return;
 
-    m_context->uniform4iv(location->location(), size / 4, v);
+    m_context->uniform3iv(location->location(), v.length() / 3, v.data());
 }
 
-void WebGLRenderingContextBase::uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array& v)
+void WebGLRenderingContextBase::uniform4iv(const WebGLUniformLocation* location, Int32List&& v)
 {
-    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v, 4))
+    if (isContextLostOrPending() || !validateUniformParameters("uniform4iv", location, v, 4))
         return;
-    m_context->uniformMatrix2fv(location->location(), v.length() / 4, transpose, v.data());
+
+    m_context->uniform4iv(location->location(), v.length() / 4, v.data());
 }
 
-void WebGLRenderingContextBase::uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* v, GC3Dsizei size)
+void WebGLRenderingContextBase::uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32List&& v)
 {
-    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v, size, 4))
+    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v, 4))
         return;
-    m_context->uniformMatrix2fv(location->location(), size / 4, transpose, v);
+    m_context->uniformMatrix2fv(location->location(), v.length() / 4, transpose, v.data());
 }
 
-void WebGLRenderingContextBase::uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array& v)
+void WebGLRenderingContextBase::uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32List&& v)
 {
     if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose, v, 9))
         return;
     m_context->uniformMatrix3fv(location->location(), v.length() / 9, transpose, v.data());
 }
 
-void WebGLRenderingContextBase::uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* v, GC3Dsizei size)
-{
-    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose, v, size, 9))
-        return;
-    m_context->uniformMatrix3fv(location->location(), size / 9, transpose, v);
-}
-
-void WebGLRenderingContextBase::uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array& v)
+void WebGLRenderingContextBase::uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32List&& v)
 {
     if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v, 16))
         return;
     m_context->uniformMatrix4fv(location->location(), v.length() / 16, transpose, v.data());
 }
 
-void WebGLRenderingContextBase::uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* v, GC3Dsizei size)
-{
-    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v, size, 16))
-        return;
-    m_context->uniformMatrix4fv(location->location(), size / 16, transpose, v);
-}
-
 void WebGLRenderingContextBase::useProgram(WebGLProgram* program)
 {
     bool deleted;
@@ -4489,59 +4400,39 @@ void WebGLRenderingContextBase::vertexAttrib1f(GC3Duint index, GC3Dfloat v0)
     vertexAttribfImpl("vertexAttrib1f", index, 1, v0, 0.0f, 0.0f, 1.0f);
 }
 
-void WebGLRenderingContextBase::vertexAttrib1fv(GC3Duint index, Float32Array& v)
-{
-    vertexAttribfvImpl("vertexAttrib1fv", index, v, 1);
-}
-
-void WebGLRenderingContextBase::vertexAttrib1fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)
-{
-    vertexAttribfvImpl("vertexAttrib1fv", index, v, size, 1);
-}
-
 void WebGLRenderingContextBase::vertexAttrib2f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1)
 {
     vertexAttribfImpl("vertexAttrib2f", index, 2, v0, v1, 0.0f, 1.0f);
 }
 
-void WebGLRenderingContextBase::vertexAttrib2fv(GC3Duint index, Float32Array& v)
-{
-    vertexAttribfvImpl("vertexAttrib2fv", index, v, 2);
-}
-
-void WebGLRenderingContextBase::vertexAttrib2fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)
-{
-    vertexAttribfvImpl("vertexAttrib2fv", index, v, size, 2);
-}
-
 void WebGLRenderingContextBase::vertexAttrib3f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2)
 {
     vertexAttribfImpl("vertexAttrib3f", index, 3, v0, v1, v2, 1.0f);
 }
 
-void WebGLRenderingContextBase::vertexAttrib3fv(GC3Duint index, Float32Array& v)
+void WebGLRenderingContextBase::vertexAttrib4f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2, GC3Dfloat v3)
 {
-    vertexAttribfvImpl("vertexAttrib3fv", index, v, 3);
+    vertexAttribfImpl("vertexAttrib4f", index, 4, v0, v1, v2, v3);
 }
 
-void WebGLRenderingContextBase::vertexAttrib3fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)
+void WebGLRenderingContextBase::vertexAttrib1fv(GC3Duint index, Float32List&& v)
 {
-    vertexAttribfvImpl("vertexAttrib3fv", index, v, size, 3);
+    vertexAttribfvImpl("vertexAttrib1fv", index, WTFMove(v), 1);
 }
 
-void WebGLRenderingContextBase::vertexAttrib4f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2, GC3Dfloat v3)
+void WebGLRenderingContextBase::vertexAttrib2fv(GC3Duint index, Float32List&& v)
 {
-    vertexAttribfImpl("vertexAttrib4f", index, 4, v0, v1, v2, v3);
+    vertexAttribfvImpl("vertexAttrib2fv", index, WTFMove(v), 2);
 }
 
-void WebGLRenderingContextBase::vertexAttrib4fv(GC3Duint index, Float32Array& v)
+void WebGLRenderingContextBase::vertexAttrib3fv(GC3Duint index, Float32List&& v)
 {
-    vertexAttribfvImpl("vertexAttrib4fv", index, v, 4);
+    vertexAttribfvImpl("vertexAttrib3fv", index, WTFMove(v), 3);
 }
 
-void WebGLRenderingContextBase::vertexAttrib4fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)
+void WebGLRenderingContextBase::vertexAttrib4fv(GC3Duint index, Float32List&& v)
 {
-    vertexAttribfvImpl("vertexAttrib4fv", index, v, size, 4);
+    vertexAttribfvImpl("vertexAttrib4fv", index, WTFMove(v), 4);
 }
 
 void WebGLRenderingContextBase::vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized, GC3Dsizei stride, long long offset)
@@ -5265,12 +5156,12 @@ bool WebGLRenderingContextBase::validateBlendFuncFactors(const char* functionNam
     return true;
 }
 
-bool WebGLRenderingContextBase::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, Float32Array& v, GC3Dsizei requiredMinSize)
+bool WebGLRenderingContextBase::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, const Float32List& v, GC3Dsizei requiredMinSize)
 {
     return validateUniformMatrixParameters(functionName, location, false, v.data(), v.length(), requiredMinSize);
 }
 
-bool WebGLRenderingContextBase::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, Int32Array& v, GC3Dsizei requiredMinSize)
+bool WebGLRenderingContextBase::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, const Int32List& v, GC3Dsizei requiredMinSize)
 {
     return validateUniformMatrixParameters(functionName, location, false, v.data(), v.length(), requiredMinSize);
 }
@@ -5280,7 +5171,7 @@ bool WebGLRenderingContextBase::validateUniformParameters(const char* functionNa
     return validateUniformMatrixParameters(functionName, location, false, v, size, requiredMinSize);
 }
 
-bool WebGLRenderingContextBase::validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array& v, GC3Dsizei requiredMinSize)
+bool WebGLRenderingContextBase::validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation* location, GC3Dboolean transpose, const Float32List& v, GC3Dsizei requiredMinSize)
 {
     return validateUniformMatrixParameters(functionName, location, transpose, v.data(), v.length(), requiredMinSize);
 }
@@ -5430,21 +5321,18 @@ void WebGLRenderingContextBase::vertexAttribfImpl(const char* functionName, GC3D
     attribValue.value[3] = v3;
 }
 
-void WebGLRenderingContextBase::vertexAttribfvImpl(const char* functionName, GC3Duint index, Float32Array& v, GC3Dsizei expectedSize)
+void WebGLRenderingContextBase::vertexAttribfvImpl(const char* functionName, GC3Duint index, Float32List&& list, GC3Dsizei expectedSize)
 {
     if (isContextLostOrPending())
         return;
-    vertexAttribfvImpl(functionName, index, v.data(), v.length(), expectedSize);
-}
-
-void WebGLRenderingContextBase::vertexAttribfvImpl(const char* functionName, GC3Duint index, GC3Dfloat* v, GC3Dsizei size, GC3Dsizei expectedSize)
-{
-    if (isContextLostOrPending())
-        return;
-    if (!v) {
+    
+    auto data = list.data();
+    if (!data) {
         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");
         return;
     }
+    
+    int size = list.length();
     if (size < expectedSize) {
         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "invalid size");
         return;
@@ -5457,23 +5345,23 @@ void WebGLRenderingContextBase::vertexAttribfvImpl(const char* functionName, GC3
     if (index || isGLES2Compliant()) {
         switch (expectedSize) {
         case 1:
-            m_context->vertexAttrib1fv(index, v);
+            m_context->vertexAttrib1fv(index, data);
             break;
         case 2:
-            m_context->vertexAttrib2fv(index, v);
+            m_context->vertexAttrib2fv(index, data);
             break;
         case 3:
-            m_context->vertexAttrib3fv(index, v);
+            m_context->vertexAttrib3fv(index, data);
             break;
         case 4:
-            m_context->vertexAttrib4fv(index, v);
+            m_context->vertexAttrib4fv(index, data);
             break;
         }
     }
     VertexAttribValue& attribValue = m_vertexAttribValue[index];
     attribValue.initValue();
     for (int ii = 0; ii < expectedSize; ++ii)
-        attribValue.value[ii] = v[ii];
+        attribValue.value[ii] = data[ii];
 }
 
 void WebGLRenderingContextBase::initVertexAttrib0()
index 9f9e8b6..404170a 100644 (file)
 #include "ImageBuffer.h"
 #include "Timer.h"
 #include "WebGLAny.h"
+#include "WebGLBuffer.h"
 #include "WebGLContextAttributes.h"
+#include "WebGLFramebuffer.h"
+#include "WebGLProgram.h"
+#include "WebGLRenderbuffer.h"
 #include "WebGLTexture.h"
+#include "WebGLVertexArrayObjectOES.h"
 #include <memory>
 
+#if ENABLE(WEBGL2)
+#include "WebGLVertexArrayObject.h"
+#endif
+
 namespace WebCore {
 
 class ANGLEInstancedArrays;
@@ -55,7 +64,6 @@ class OESTextureHalfFloatLinear;
 class OESVertexArrayObject;
 class OESElementIndexUint;
 class WebGLActiveInfo;
-class WebGLBuffer;
 class WebGLContextGroup;
 class WebGLContextObject;
 class WebGLCompressedTextureATC;
@@ -66,16 +74,12 @@ class WebGLDebugShaders;
 class WebGLDepthTexture;
 class WebGLDrawBuffers;
 class WebGLExtension;
-class WebGLFramebuffer;
 class WebGLLoseContext;
 class WebGLObject;
-class WebGLProgram;
-class WebGLRenderbuffer;
 class WebGLShader;
 class WebGLSharedObject;
 class WebGLShaderPrecisionFormat;
 class WebGLUniformLocation;
-class WebGLVertexArrayObjectOES;
 
 inline void clip1D(GC3Dint start, GC3Dsizei range, GC3Dsizei sourceRange, GC3Dint* clippedStart, GC3Dsizei* clippedRange)
 {
@@ -185,7 +189,7 @@ public:
 
     RefPtr<WebGLActiveInfo> getActiveAttrib(WebGLProgram*, GC3Duint index);
     RefPtr<WebGLActiveInfo> getActiveUniform(WebGLProgram*, GC3Duint index);
-    bool getAttachedShaders(WebGLProgram*, Vector<RefPtr<WebGLShader>>&);
+    std::optional<Vector<RefPtr<WebGLShader>>> getAttachedShaders(WebGLProgram*);
     GC3Dint getAttribLocation(WebGLProgram*, const String& name);
     WebGLAny getBufferParameter(GC3Denum target, GC3Denum pname);
     std::optional<WebGLContextAttributes> getContextAttributes();
@@ -200,7 +204,7 @@ public:
     String getShaderInfoLog(WebGLShader*);
     RefPtr<WebGLShaderPrecisionFormat> getShaderPrecisionFormat(GC3Denum shaderType, GC3Denum precisionType);
     String getShaderSource(WebGLShader*);
-    virtual Vector<String> getSupportedExtensions() = 0;
+    virtual std::optional<Vector<String>> getSupportedExtensions() = 0;
     WebGLAny getTexParameter(GC3Denum target, GC3Denum pname);
     WebGLAny getUniform(WebGLProgram*, const WebGLUniformLocation*);
     RefPtr<WebGLUniformLocation> getUniformLocation(WebGLProgram*, const String&);
@@ -245,52 +249,76 @@ public:
     void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&&);
     ExceptionOr<void> texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, std::optional<TexImageSource>&&);
 
+    template <class TypedArray, class DataType>
+    class TypedList {
+    public:
+        using VariantType = Variant<RefPtr<TypedArray>, Vector<DataType>>;
+
+        TypedList(VariantType&& variant)
+            : m_variant(WTFMove(variant))
+        {
+        }
+
+        DataType* data() const
+        {
+            return WTF::switchOn(m_variant,
+                [] (const RefPtr<TypedArray>& typedArray) -> DataType* { return typedArray->data(); },
+                [] (const Vector<DataType>& vector) -> DataType* { return const_cast<Vector<DataType>&>(vector).data(); }
+            );
+        }
+
+        GC3Dsizei length() const
+        {
+            return WTF::switchOn(m_variant,
+                [] (const RefPtr<TypedArray>& typedArray) -> GC3Dsizei { return typedArray->length(); },
+                [] (const Vector<DataType>& vector) -> GC3Dsizei { return vector.size(); }
+            );
+        }
+
+    private:
+        VariantType m_variant;
+    };
+
+    using Float32List = TypedList<Float32Array, float>;
+    using Int32List = TypedList<Int32Array, int>;
+
     void uniform1f(const WebGLUniformLocation*, GC3Dfloat x);
-    void uniform1fv(const WebGLUniformLocation*, Float32Array& v);
-    void uniform1fv(const WebGLUniformLocation*, GC3Dfloat* v, GC3Dsizei);
-    void uniform1i(const WebGLUniformLocation*, GC3Dint x);
-    void uniform1iv(const WebGLUniformLocation*, Int32Array& v);
-    void uniform1iv(const WebGLUniformLocation*, GC3Dint* v, GC3Dsizei);
     void uniform2f(const WebGLUniformLocation*, GC3Dfloat x, GC3Dfloat y);
-    void uniform2fv(const WebGLUniformLocation*, Float32Array& v);
-    void uniform2fv(const WebGLUniformLocation*, GC3Dfloat* v, GC3Dsizei);
-    void uniform2i(const WebGLUniformLocation*, GC3Dint x, GC3Dint y);
-    void uniform2iv(const WebGLUniformLocation*, Int32Array& v);
-    void uniform2iv(const WebGLUniformLocation*, GC3Dint* v, GC3Dsizei);
     void uniform3f(const WebGLUniformLocation*, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z);
-    void uniform3fv(const WebGLUniformLocation*, Float32Array& v);
-    void uniform3fv(const WebGLUniformLocation*, GC3Dfloat* v, GC3Dsizei);
-    void uniform3i(const WebGLUniformLocation*, GC3Dint x, GC3Dint y, GC3Dint z);
-    void uniform3iv(const WebGLUniformLocation*, Int32Array& v);
-    void uniform3iv(const WebGLUniformLocation*, GC3Dint* v, GC3Dsizei);
     void uniform4f(const WebGLUniformLocation*, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w);
-    void uniform4fv(const WebGLUniformLocation*, Float32Array& v);
-    void uniform4fv(const WebGLUniformLocation*, GC3Dfloat* v, GC3Dsizei);
+
+    void uniform1i(const WebGLUniformLocation*, GC3Dint x);
+    void uniform2i(const WebGLUniformLocation*, GC3Dint x, GC3Dint y);
+    void uniform3i(const WebGLUniformLocation*, GC3Dint x, GC3Dint y, GC3Dint z);
     void uniform4i(const WebGLUniformLocation*, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w);
-    void uniform4iv(const WebGLUniformLocation*, Int32Array& v);
-    void uniform4iv(const WebGLUniformLocation*, GC3Dint* v, GC3Dsizei);
-    void uniformMatrix2fv(const WebGLUniformLocation*, GC3Dboolean transpose, Float32Array& value);
-    void uniformMatrix2fv(const WebGLUniformLocation*, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei);
-    void uniformMatrix3fv(const WebGLUniformLocation*, GC3Dboolean transpose, Float32Array& value);
-    void uniformMatrix3fv(const WebGLUniformLocation*, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei);
-    void uniformMatrix4fv(const WebGLUniformLocation*, GC3Dboolean transpose, Float32Array& value);
-    void uniformMatrix4fv(const WebGLUniformLocation*, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei);
+
+    void uniform1fv(const WebGLUniformLocation*, Float32List&&);
+    void uniform2fv(const WebGLUniformLocation*, Float32List&&);
+    void uniform3fv(const WebGLUniformLocation*, Float32List&&);
+    void uniform4fv(const WebGLUniformLocation*, Float32List&&);
+
+    void uniform1iv(const WebGLUniformLocation*, Int32List&&);
+    void uniform2iv(const WebGLUniformLocation*, Int32List&&);
+    void uniform3iv(const WebGLUniformLocation*, Int32List&&);
+    void uniform4iv(const WebGLUniformLocation*, Int32List&&);
+
+    void uniformMatrix2fv(const WebGLUniformLocation*, GC3Dboolean transpose, Float32List&&);
+    void uniformMatrix3fv(const WebGLUniformLocation*, GC3Dboolean transpose, Float32List&&);
+    void uniformMatrix4fv(const WebGLUniformLocation*, GC3Dboolean transpose, Float32List&&);
 
     void useProgram(WebGLProgram*);
     void validateProgram(WebGLProgram*);
 
     void vertexAttrib1f(GC3Duint index, GC3Dfloat x);
-    void vertexAttrib1fv(GC3Duint index, Float32Array& values);
-    void vertexAttrib1fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);
     void vertexAttrib2f(GC3Duint index, GC3Dfloat x, GC3Dfloat y);
-    void vertexAttrib2fv(GC3Duint index, Float32Array& values);
-    void vertexAttrib2fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);
     void vertexAttrib3f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z);
-    void vertexAttrib3fv(GC3Duint index, Float32Array& values);
-    void vertexAttrib3fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);
     void vertexAttrib4f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w);
-    void vertexAttrib4fv(GC3Duint index, Float32Array& values);
-    void vertexAttrib4fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);
+
+    void vertexAttrib1fv(GC3Duint index, Float32List&&);
+    void vertexAttrib2fv(GC3Duint index, Float32List&&);
+    void vertexAttrib3fv(GC3Duint index, Float32List&&);
+    void vertexAttrib4fv(GC3Duint index, Float32List&&);
+
     void vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized,
         GC3Dsizei stride, long long offset);
 
@@ -729,10 +757,10 @@ protected:
     virtual bool validateCapability(const char* functionName, GC3Denum) = 0;
 
     // Helper function to validate input parameters for uniform functions.
-    bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, Float32Array&, GC3Dsizei mod);
-    bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, Int32Array&, GC3Dsizei mod);
+    bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, const Float32List&, GC3Dsizei mod);
+    bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, const Int32List&, GC3Dsizei mod);
     bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, void*, GC3Dsizei, GC3Dsizei mod);
-    bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GC3Dboolean transpose, Float32Array&, GC3Dsizei mod);
+    bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GC3Dboolean transpose, const Float32List&, GC3Dsizei mod);
     bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GC3Dboolean transpose, void*, GC3Dsizei, GC3Dsizei mod);
 
     // Helper function to validate parameters for bufferData.
@@ -748,8 +776,7 @@ protected:
 
     // Helper functions for vertexAttribNf{v}.
     void vertexAttribfImpl(const char* functionName, GC3Duint index, GC3Dsizei expectedSize, GC3Dfloat, GC3Dfloat, GC3Dfloat, GC3Dfloat);
-    void vertexAttribfvImpl(const char* functionName, GC3Duint index, Float32Array&, GC3Dsizei expectedSize);
-    void vertexAttribfvImpl(const char* functionName, GC3Duint index, GC3Dfloat*, GC3Dsizei, GC3Dsizei expectedSize);
+    void vertexAttribfvImpl(const char* functionName, GC3Duint index, Float32List&&, GC3Dsizei expectedSize);
 
     // Helper function for delete* (deleteBuffer, deleteProgram, etc) functions.
     // Return false if caller should return without further processing.
index b14bc4c..63b64cd 100644 (file)
@@ -38,6 +38,8 @@ typedef unsigned long GLuint;
 typedef unrestricted float GLfloat;
 typedef unrestricted float GLclampf;
 typedef (ArrayBuffer or ArrayBufferView) BufferDataSource;
+typedef (Float32Array or sequence<GLfloat>) Float32List;
+typedef (Int32Array or sequence<GLint>) Int32List;
 
 // FIXME: Should allow ImageBitmap too.
 typedef (ImageData or HTMLImageElement or HTMLCanvasElement or HTMLVideoElement) TexImageSource;
@@ -545,25 +547,26 @@ typedef (ImageData or HTMLImageElement or HTMLCanvasElement or HTMLVideoElement)
     WebGLActiveInfo getActiveAttrib(WebGLProgram? program, GLuint index);
     WebGLActiveInfo getActiveUniform(WebGLProgram? program, GLuint index);
 
-    [Custom] void getAttachedShaders(WebGLProgram? program);
+    // FIXME: The spec says this should not take a nullable WebGLProgram.
+    sequence<WebGLShader>? getAttachedShaders(WebGLProgram? program);
 
     GLint getAttribLocation(WebGLProgram? program, DOMString name);
 
-    [Custom] any getBufferParameter(GLenum target, GLenum pname);
+    [OverrideIDLType=IDLWebGLAny] any getBufferParameter(GLenum target, GLenum pname);
 
     WebGLContextAttributes? getContextAttributes();
 
     GLenum getError();
 
-    // object getExtension(DOMString name);
-    [Custom] any getExtension(DOMString name);
+    sequence<DOMString>? getSupportedExtensions();
+    [Custom] object? getExtension(DOMString name);
 
-    [Custom] any getFramebufferAttachmentParameter(GLenum target, GLenum attachment, GLenum pname);
-    [Custom] any getParameter(GLenum pname);
-    [Custom] any getProgramParameter(WebGLProgram? program, GLenum pname);
+    [OverrideIDLType=IDLWebGLAny] any getFramebufferAttachmentParameter(GLenum target, GLenum attachment, GLenum pname);
+    [OverrideIDLType=IDLWebGLAny] any getParameter(GLenum pname);
+    [OverrideIDLType=IDLWebGLAny] any getProgramParameter(WebGLProgram? program, GLenum pname);
     DOMString? getProgramInfoLog(WebGLProgram? program);
-    [Custom] any getRenderbufferParameter(GLenum target, GLenum pname);
-    [Custom] any getShaderParameter(WebGLShader? shader, GLenum pname);
+    [OverrideIDLType=IDLWebGLAny] any getRenderbufferParameter(GLenum target, GLenum pname);
+    [OverrideIDLType=IDLWebGLAny] any getShaderParameter(WebGLShader? shader, GLenum pname);
 
     DOMString? getShaderInfoLog(WebGLShader? shader);
 
@@ -571,15 +574,13 @@ typedef (ImageData or HTMLImageElement or HTMLCanvasElement or HTMLVideoElement)
 
     DOMString? getShaderSource(WebGLShader? shader);
 
-    [Custom] sequence<DOMString> getSupportedExtensions();
+    [OverrideIDLType=IDLWebGLAny] any getTexParameter(GLenum target, GLenum pname);
 
-    [Custom] any getTexParameter(GLenum target, GLenum pname);
-
-    [Custom] any getUniform(WebGLProgram? program, WebGLUniformLocation? location);
+    [OverrideIDLType=IDLWebGLAny] any getUniform(WebGLProgram? program, WebGLUniformLocation? location);
 
     WebGLUniformLocation getUniformLocation(WebGLProgram? program, DOMString name);
 
-    [Custom] any getVertexAttrib(GLuint index, GLenum pname);
+    [OverrideIDLType=IDLWebGLAny] any getVertexAttrib(GLuint index, GLenum pname);
 
     GLsizeiptr getVertexAttribOffset(GLuint index, GLenum pname);
 
@@ -622,37 +623,42 @@ typedef (ImageData or HTMLImageElement or HTMLCanvasElement or HTMLVideoElement)
     [MayThrowException] void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLenum format, GLenum type, TexImageSource? source);
 
     void uniform1f(WebGLUniformLocation? location, GLfloat x);
-    [Custom] void uniform1fv(WebGLUniformLocation? location, Float32Array v);
-    void uniform1i(WebGLUniformLocation? location, GLint x);
-    [Custom] void uniform1iv(WebGLUniformLocation? location, Int32Array v);
     void uniform2f(WebGLUniformLocation? location, GLfloat x, GLfloat y);
-    [Custom] void uniform2fv(WebGLUniformLocation? location, Float32Array v);
-    void uniform2i(WebGLUniformLocation? location, GLint x, GLint y);
-    [Custom] void uniform2iv(WebGLUniformLocation? location, Int32Array v);
     void uniform3f(WebGLUniformLocation? location, GLfloat x, GLfloat y, GLfloat z);
-    [Custom] void uniform3fv(WebGLUniformLocation? location, Float32Array v);
-    void uniform3i(WebGLUniformLocation? location, GLint x, GLint y, GLint z);
-    [Custom] void uniform3iv(WebGLUniformLocation? location, Int32Array v);
     void uniform4f(WebGLUniformLocation? location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    [Custom] void uniform4fv(WebGLUniformLocation? location, Float32Array v);
+
+    void uniform1i(WebGLUniformLocation? location, GLint x);
+    void uniform2i(WebGLUniformLocation? location, GLint x, GLint y);
+    void uniform3i(WebGLUniformLocation? location, GLint x, GLint y, GLint z);
     void uniform4i(WebGLUniformLocation? location, GLint x, GLint y, GLint z, GLint w);
-    [Custom] void uniform4iv(WebGLUniformLocation? location, Int32Array v);
 
-    [Custom] void uniformMatrix2fv(WebGLUniformLocation? location, GLboolean transpose, Float32Array array);
-    [Custom] void uniformMatrix3fv(WebGLUniformLocation? location, GLboolean transpose, Float32Array array);
-    [Custom] void uniformMatrix4fv(WebGLUniformLocation? location, GLboolean transpose, Float32Array array);
+    void uniform1fv(WebGLUniformLocation? location, Float32List v);
+    void uniform2fv(WebGLUniformLocation? location, Float32List v);
+    void uniform3fv(WebGLUniformLocation? location, Float32List v);
+    void uniform4fv(WebGLUniformLocation? location, Float32List v);
+
+    void uniform1iv(WebGLUniformLocation? location, Int32List v);
+    void uniform2iv(WebGLUniformLocation? location, Int32List v);
+    void uniform3iv(WebGLUniformLocation? location, Int32List v);
+    void uniform4iv(WebGLUniformLocation? location, Int32List v);
+
+    void uniformMatrix2fv(WebGLUniformLocation? location, GLboolean transpose, Float32List array);
+    void uniformMatrix3fv(WebGLUniformLocation? location, GLboolean transpose, Float32List array);
+    void uniformMatrix4fv(WebGLUniformLocation? location, GLboolean transpose, Float32List array);
 
     void useProgram(WebGLProgram? program);
     void validateProgram(WebGLProgram? program);
 
-    void vertexAttrib1f(GLuint indx, GLfloat x);
-    [Custom] void vertexAttrib1fv(GLuint indx, Float32Array values);
-    void vertexAttrib2f(GLuint indx, GLfloat x, GLfloat y);
-    [Custom] void vertexAttrib2fv(GLuint indx, Float32Array values);
-    void vertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z);
-    [Custom] void vertexAttrib3fv(GLuint indx, Float32Array values);
-    void vertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    [Custom] void vertexAttrib4fv(GLuint indx, Float32Array values);
+    void vertexAttrib1f(GLuint index, GLfloat x);
+    void vertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
+    void vertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+    void vertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+
+    void vertexAttrib1fv(GLuint index, Float32List values);
+    void vertexAttrib2fv(GLuint index, Float32List values);
+    void vertexAttrib3fv(GLuint index, Float32List values);
+    void vertexAttrib4fv(GLuint index, Float32List values);
+
     void vertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset);
 
     void viewport(GLint x, GLint y, GLsizei width, GLsizei height);