WebGLRenderingContext should implement WebGLRenderingContextBase
authordino@apple.com <dino@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 11 May 2017 21:39:40 +0000 (21:39 +0000)
committerdino@apple.com <dino@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 11 May 2017 21:39:40 +0000 (21:39 +0000)
https://bugs.webkit.org/show_bug.cgi?id=171961
<rdar://problem/32124920>

Reviewed by Sam Weinig.

Source/WebCore:

WebGLRenderingContext and WebGL2RenderingContext are both
defined to "implement" WebGLRenderingContextBase. However, we
were doing it via inheritance, which meant that some things
were not visible on the WebGLRenderingContext prototype.

Test: fast/canvas/webgl/constants-on-interface.html

* WebCore.xcodeproj/project.pbxproj: Move the Custom.cpp files
out of the GC-only area now they have real content.

* bindings/js/JSDocumentCustom.cpp: Handle the fact that we
don't use the base class from the bindings, so we need to
translate WebGL1 and WebGL2 contexts into the right JS classes.
(WebCore::JSDocument::getCSSCanvasContext):
* bindings/js/JSHTMLCanvasElementCustom.cpp:
(WebCore::JSHTMLCanvasElement::getContext):

* bindings/js/JSWebGL2RenderingContextCustom.cpp: Implement the
custom methods. In this case, we don't yet expose any
extensions for WebGL 2.
(WebCore::toJS):
(WebCore::JSWebGL2RenderingContext::getExtension):

* bindings/js/JSWebGLRenderingContextBaseCustom.cpp: Removed.

* bindings/js/JSWebGLRenderingContextCustom.cpp:
(WebCore::toJS):
(WebCore::JSWebGLRenderingContext::getExtension):

* html/canvas/WebGL2RenderingContext.h: Make some things public.
* html/canvas/WebGLRenderingContext.h: Ditto.

* html/canvas/WebGL2RenderingContext.idl: Use implements.
* html/canvas/WebGLRenderingContext.idl: Ditto.

* testing/Internals.cpp: This now takes a WebGLRenderingContext.
(WebCore::Internals::simulateWebGLContextChanged):
* testing/Internals.h:
* testing/Internals.idl:

LayoutTests:

New test to make sure constants from WebGLRenderingContextBase are
visible on the WebGLRenderingContext prototype.

Also, fix up some existing tests that were expecting to see
instances of WebGLRenderingContextBase.

* fast/canvas/webgl/constants-on-interface-expected.txt: Added.
* fast/canvas/webgl/constants-on-interface.html: Added.
* fast/canvas/webgl/gl-object-get-calls-expected.txt:
* fast/canvas/webgl/null-object-behaviour-expected.txt:
* fast/canvas/webgl/texImageTest-expected.txt:

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

21 files changed:
LayoutTests/ChangeLog
LayoutTests/fast/canvas/webgl/constants-on-interface-expected.txt [new file with mode: 0644]
LayoutTests/fast/canvas/webgl/constants-on-interface.html [new file with mode: 0644]
LayoutTests/fast/canvas/webgl/gl-object-get-calls-expected.txt
LayoutTests/fast/canvas/webgl/null-object-behaviour-expected.txt
LayoutTests/fast/canvas/webgl/texImageTest-expected.txt
Source/WebCore/CMakeLists.txt
Source/WebCore/ChangeLog
Source/WebCore/WebCore.xcodeproj/project.pbxproj
Source/WebCore/bindings/js/JSDocumentCustom.cpp
Source/WebCore/bindings/js/JSHTMLCanvasElementCustom.cpp
Source/WebCore/bindings/js/JSWebGL2RenderingContextCustom.cpp
Source/WebCore/bindings/js/JSWebGLRenderingContextBaseCustom.cpp [deleted file]
Source/WebCore/bindings/js/JSWebGLRenderingContextCustom.cpp
Source/WebCore/html/canvas/WebGL2RenderingContext.h
Source/WebCore/html/canvas/WebGL2RenderingContext.idl
Source/WebCore/html/canvas/WebGLRenderingContext.h
Source/WebCore/html/canvas/WebGLRenderingContext.idl
Source/WebCore/testing/Internals.cpp
Source/WebCore/testing/Internals.h
Source/WebCore/testing/Internals.idl

index ee5caed..caef9e3 100644 (file)
@@ -1,3 +1,23 @@
+2017-05-11  Dean Jackson  <dino@apple.com>
+
+        WebGLRenderingContext should implement WebGLRenderingContextBase
+        https://bugs.webkit.org/show_bug.cgi?id=171961
+        <rdar://problem/32124920>
+
+        Reviewed by Sam Weinig.
+
+        New test to make sure constants from WebGLRenderingContextBase are
+        visible on the WebGLRenderingContext prototype.
+
+        Also, fix up some existing tests that were expecting to see
+        instances of WebGLRenderingContextBase.
+
+        * fast/canvas/webgl/constants-on-interface-expected.txt: Added.
+        * fast/canvas/webgl/constants-on-interface.html: Added.
+        * fast/canvas/webgl/gl-object-get-calls-expected.txt:
+        * fast/canvas/webgl/null-object-behaviour-expected.txt:
+        * fast/canvas/webgl/texImageTest-expected.txt:
+
 2017-05-11  Matt Lewis  <jlewis3@apple.com>
 
         Fixed typo errors in TestExpectations.
diff --git a/LayoutTests/fast/canvas/webgl/constants-on-interface-expected.txt b/LayoutTests/fast/canvas/webgl/constants-on-interface-expected.txt
new file mode 100644 (file)
index 0000000..04e778f
--- /dev/null
@@ -0,0 +1,298 @@
+WebGLRenderingContext.ACTIVE_ATTRIBUTES == 35721
+WebGLRenderingContext.ACTIVE_TEXTURE == 34016
+WebGLRenderingContext.ACTIVE_UNIFORMS == 35718
+WebGLRenderingContext.ALIASED_LINE_WIDTH_RANGE == 33902
+WebGLRenderingContext.ALIASED_POINT_SIZE_RANGE == 33901
+WebGLRenderingContext.ALPHA == 6406
+WebGLRenderingContext.ALPHA_BITS == 3413
+WebGLRenderingContext.ALWAYS == 519
+WebGLRenderingContext.ARRAY_BUFFER == 34962
+WebGLRenderingContext.ARRAY_BUFFER_BINDING == 34964
+WebGLRenderingContext.ATTACHED_SHADERS == 35717
+WebGLRenderingContext.BACK == 1029
+WebGLRenderingContext.BLEND == 3042
+WebGLRenderingContext.BLEND_COLOR == 32773
+WebGLRenderingContext.BLEND_DST_ALPHA == 32970
+WebGLRenderingContext.BLEND_DST_RGB == 32968
+WebGLRenderingContext.BLEND_EQUATION == 32777
+WebGLRenderingContext.BLEND_EQUATION_ALPHA == 34877
+WebGLRenderingContext.BLEND_EQUATION_RGB == 32777
+WebGLRenderingContext.BLEND_SRC_ALPHA == 32971
+WebGLRenderingContext.BLEND_SRC_RGB == 32969
+WebGLRenderingContext.BLUE_BITS == 3412
+WebGLRenderingContext.BOOL == 35670
+WebGLRenderingContext.BOOL_VEC2 == 35671
+WebGLRenderingContext.BOOL_VEC3 == 35672
+WebGLRenderingContext.BOOL_VEC4 == 35673
+WebGLRenderingContext.BROWSER_DEFAULT_WEBGL == 37444
+WebGLRenderingContext.BUFFER_SIZE == 34660
+WebGLRenderingContext.BUFFER_USAGE == 34661
+WebGLRenderingContext.BYTE == 5120
+WebGLRenderingContext.CCW == 2305
+WebGLRenderingContext.CLAMP_TO_EDGE == 33071
+WebGLRenderingContext.COLOR_ATTACHMENT0 == 36064
+WebGLRenderingContext.COLOR_BUFFER_BIT == 16384
+WebGLRenderingContext.COLOR_CLEAR_VALUE == 3106
+WebGLRenderingContext.COLOR_WRITEMASK == 3107
+WebGLRenderingContext.COMPILE_STATUS == 35713
+WebGLRenderingContext.COMPRESSED_TEXTURE_FORMATS == 34467
+WebGLRenderingContext.CONSTANT_ALPHA == 32771
+WebGLRenderingContext.CONSTANT_COLOR == 32769
+WebGLRenderingContext.CONTEXT_LOST_WEBGL == 37442
+WebGLRenderingContext.CULL_FACE == 2884
+WebGLRenderingContext.CULL_FACE_MODE == 2885
+WebGLRenderingContext.CURRENT_PROGRAM == 35725
+WebGLRenderingContext.CURRENT_VERTEX_ATTRIB == 34342
+WebGLRenderingContext.CW == 2304
+WebGLRenderingContext.DECR == 7683
+WebGLRenderingContext.DECR_WRAP == 34056
+WebGLRenderingContext.DELETE_STATUS == 35712
+WebGLRenderingContext.DEPTH_ATTACHMENT == 36096
+WebGLRenderingContext.DEPTH_BITS == 3414
+WebGLRenderingContext.DEPTH_BUFFER_BIT == 256
+WebGLRenderingContext.DEPTH_CLEAR_VALUE == 2931
+WebGLRenderingContext.DEPTH_COMPONENT == 6402
+WebGLRenderingContext.DEPTH_COMPONENT16 == 33189
+WebGLRenderingContext.DEPTH_FUNC == 2932
+WebGLRenderingContext.DEPTH_RANGE == 2928
+WebGLRenderingContext.DEPTH_STENCIL == 34041
+WebGLRenderingContext.DEPTH_STENCIL_ATTACHMENT == 33306
+WebGLRenderingContext.DEPTH_TEST == 2929
+WebGLRenderingContext.DEPTH_WRITEMASK == 2930
+WebGLRenderingContext.DITHER == 3024
+WebGLRenderingContext.DONT_CARE == 4352
+WebGLRenderingContext.DST_ALPHA == 772
+WebGLRenderingContext.DST_COLOR == 774
+WebGLRenderingContext.DYNAMIC_DRAW == 35048
+WebGLRenderingContext.ELEMENT_ARRAY_BUFFER == 34963
+WebGLRenderingContext.ELEMENT_ARRAY_BUFFER_BINDING == 34965
+WebGLRenderingContext.EQUAL == 514
+WebGLRenderingContext.FASTEST == 4353
+WebGLRenderingContext.FLOAT == 5126
+WebGLRenderingContext.FLOAT_MAT2 == 35674
+WebGLRenderingContext.FLOAT_MAT3 == 35675
+WebGLRenderingContext.FLOAT_MAT4 == 35676
+WebGLRenderingContext.FLOAT_VEC2 == 35664
+WebGLRenderingContext.FLOAT_VEC3 == 35665
+WebGLRenderingContext.FLOAT_VEC4 == 35666
+WebGLRenderingContext.FRAGMENT_SHADER == 35632
+WebGLRenderingContext.FRAMEBUFFER == 36160
+WebGLRenderingContext.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME == 36049
+WebGLRenderingContext.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE == 36048
+WebGLRenderingContext.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE == 36051
+WebGLRenderingContext.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL == 36050
+WebGLRenderingContext.FRAMEBUFFER_BINDING == 36006
+WebGLRenderingContext.FRAMEBUFFER_COMPLETE == 36053
+WebGLRenderingContext.FRAMEBUFFER_INCOMPLETE_ATTACHMENT == 36054
+WebGLRenderingContext.FRAMEBUFFER_INCOMPLETE_DIMENSIONS == 36057
+WebGLRenderingContext.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT == 36055
+WebGLRenderingContext.FRAMEBUFFER_UNSUPPORTED == 36061
+WebGLRenderingContext.FRONT == 1028
+WebGLRenderingContext.FRONT_AND_BACK == 1032
+WebGLRenderingContext.FRONT_FACE == 2886
+WebGLRenderingContext.FUNC_ADD == 32774
+WebGLRenderingContext.FUNC_REVERSE_SUBTRACT == 32779
+WebGLRenderingContext.FUNC_SUBTRACT == 32778
+WebGLRenderingContext.GENERATE_MIPMAP_HINT == 33170
+WebGLRenderingContext.GEQUAL == 518
+WebGLRenderingContext.GREATER == 516
+WebGLRenderingContext.GREEN_BITS == 3411
+WebGLRenderingContext.HIGH_FLOAT == 36338
+WebGLRenderingContext.HIGH_INT == 36341
+WebGLRenderingContext.IMPLEMENTATION_COLOR_READ_FORMAT == 35739
+WebGLRenderingContext.IMPLEMENTATION_COLOR_READ_TYPE == 35738
+WebGLRenderingContext.INCR == 7682
+WebGLRenderingContext.INCR_WRAP == 34055
+WebGLRenderingContext.INT == 5124
+WebGLRenderingContext.INT_VEC2 == 35667
+WebGLRenderingContext.INT_VEC3 == 35668
+WebGLRenderingContext.INT_VEC4 == 35669
+WebGLRenderingContext.INVALID_ENUM == 1280
+WebGLRenderingContext.INVALID_FRAMEBUFFER_OPERATION == 1286
+WebGLRenderingContext.INVALID_OPERATION == 1282
+WebGLRenderingContext.INVALID_VALUE == 1281
+WebGLRenderingContext.INVERT == 5386
+WebGLRenderingContext.KEEP == 7680
+WebGLRenderingContext.LEQUAL == 515
+WebGLRenderingContext.LESS == 513
+WebGLRenderingContext.LINEAR == 9729
+WebGLRenderingContext.LINEAR_MIPMAP_LINEAR == 9987
+WebGLRenderingContext.LINEAR_MIPMAP_NEAREST == 9985
+WebGLRenderingContext.LINES == 1
+WebGLRenderingContext.LINE_LOOP == 2
+WebGLRenderingContext.LINE_STRIP == 3
+WebGLRenderingContext.LINE_WIDTH == 2849
+WebGLRenderingContext.LINK_STATUS == 35714
+WebGLRenderingContext.LOW_FLOAT == 36336
+WebGLRenderingContext.LOW_INT == 36339
+WebGLRenderingContext.LUMINANCE == 6409
+WebGLRenderingContext.LUMINANCE_ALPHA == 6410
+WebGLRenderingContext.MAX_COMBINED_TEXTURE_IMAGE_UNITS == 35661
+WebGLRenderingContext.MAX_CUBE_MAP_TEXTURE_SIZE == 34076
+WebGLRenderingContext.MAX_FRAGMENT_UNIFORM_VECTORS == 36349
+WebGLRenderingContext.MAX_RENDERBUFFER_SIZE == 34024
+WebGLRenderingContext.MAX_TEXTURE_IMAGE_UNITS == 34930
+WebGLRenderingContext.MAX_TEXTURE_SIZE == 3379
+WebGLRenderingContext.MAX_VARYING_VECTORS == 36348
+WebGLRenderingContext.MAX_VERTEX_ATTRIBS == 34921
+WebGLRenderingContext.MAX_VERTEX_TEXTURE_IMAGE_UNITS == 35660
+WebGLRenderingContext.MAX_VERTEX_UNIFORM_VECTORS == 36347
+WebGLRenderingContext.MAX_VIEWPORT_DIMS == 3386
+WebGLRenderingContext.MEDIUM_FLOAT == 36337
+WebGLRenderingContext.MEDIUM_INT == 36340
+WebGLRenderingContext.MIRRORED_REPEAT == 33648
+WebGLRenderingContext.NEAREST == 9728
+WebGLRenderingContext.NEAREST_MIPMAP_LINEAR == 9986
+WebGLRenderingContext.NEAREST_MIPMAP_NEAREST == 9984
+WebGLRenderingContext.NEVER == 512
+WebGLRenderingContext.NICEST == 4354
+WebGLRenderingContext.NONE == 0
+WebGLRenderingContext.NOTEQUAL == 517
+WebGLRenderingContext.NO_ERROR == 0
+WebGLRenderingContext.ONE == 1
+WebGLRenderingContext.ONE_MINUS_CONSTANT_ALPHA == 32772
+WebGLRenderingContext.ONE_MINUS_CONSTANT_COLOR == 32770
+WebGLRenderingContext.ONE_MINUS_DST_ALPHA == 773
+WebGLRenderingContext.ONE_MINUS_DST_COLOR == 775
+WebGLRenderingContext.ONE_MINUS_SRC_ALPHA == 771
+WebGLRenderingContext.ONE_MINUS_SRC_COLOR == 769
+WebGLRenderingContext.OUT_OF_MEMORY == 1285
+WebGLRenderingContext.PACK_ALIGNMENT == 3333
+WebGLRenderingContext.POINTS == 0
+WebGLRenderingContext.POLYGON_OFFSET_FACTOR == 32824
+WebGLRenderingContext.POLYGON_OFFSET_FILL == 32823
+WebGLRenderingContext.POLYGON_OFFSET_UNITS == 10752
+WebGLRenderingContext.RED_BITS == 3410
+WebGLRenderingContext.RENDERBUFFER == 36161
+WebGLRenderingContext.RENDERBUFFER_ALPHA_SIZE == 36179
+WebGLRenderingContext.RENDERBUFFER_BINDING == 36007
+WebGLRenderingContext.RENDERBUFFER_BLUE_SIZE == 36178
+WebGLRenderingContext.RENDERBUFFER_DEPTH_SIZE == 36180
+WebGLRenderingContext.RENDERBUFFER_GREEN_SIZE == 36177
+WebGLRenderingContext.RENDERBUFFER_HEIGHT == 36163
+WebGLRenderingContext.RENDERBUFFER_INTERNAL_FORMAT == 36164
+WebGLRenderingContext.RENDERBUFFER_RED_SIZE == 36176
+WebGLRenderingContext.RENDERBUFFER_STENCIL_SIZE == 36181
+WebGLRenderingContext.RENDERBUFFER_WIDTH == 36162
+WebGLRenderingContext.RENDERER == 7937
+WebGLRenderingContext.REPEAT == 10497
+WebGLRenderingContext.REPLACE == 7681
+WebGLRenderingContext.RGB == 6407
+WebGLRenderingContext.RGB565 == 36194
+WebGLRenderingContext.RGB5_A1 == 32855
+WebGLRenderingContext.RGBA == 6408
+WebGLRenderingContext.RGBA4 == 32854
+WebGLRenderingContext.SAMPLER_2D == 35678
+WebGLRenderingContext.SAMPLER_CUBE == 35680
+WebGLRenderingContext.SAMPLES == 32937
+WebGLRenderingContext.SAMPLE_ALPHA_TO_COVERAGE == 32926
+WebGLRenderingContext.SAMPLE_BUFFERS == 32936
+WebGLRenderingContext.SAMPLE_COVERAGE == 32928
+WebGLRenderingContext.SAMPLE_COVERAGE_INVERT == 32939
+WebGLRenderingContext.SAMPLE_COVERAGE_VALUE == 32938
+WebGLRenderingContext.SCISSOR_BOX == 3088
+WebGLRenderingContext.SCISSOR_TEST == 3089
+WebGLRenderingContext.SHADER_TYPE == 35663
+WebGLRenderingContext.SHADING_LANGUAGE_VERSION == 35724
+WebGLRenderingContext.SHORT == 5122
+WebGLRenderingContext.SRC_ALPHA == 770
+WebGLRenderingContext.SRC_ALPHA_SATURATE == 776
+WebGLRenderingContext.SRC_COLOR == 768
+WebGLRenderingContext.STATIC_DRAW == 35044
+WebGLRenderingContext.STENCIL_ATTACHMENT == 36128
+WebGLRenderingContext.STENCIL_BACK_FAIL == 34817
+WebGLRenderingContext.STENCIL_BACK_FUNC == 34816
+WebGLRenderingContext.STENCIL_BACK_PASS_DEPTH_FAIL == 34818
+WebGLRenderingContext.STENCIL_BACK_PASS_DEPTH_PASS == 34819
+WebGLRenderingContext.STENCIL_BACK_REF == 36003
+WebGLRenderingContext.STENCIL_BACK_VALUE_MASK == 36004
+WebGLRenderingContext.STENCIL_BACK_WRITEMASK == 36005
+WebGLRenderingContext.STENCIL_BITS == 3415
+WebGLRenderingContext.STENCIL_BUFFER_BIT == 1024
+WebGLRenderingContext.STENCIL_CLEAR_VALUE == 2961
+WebGLRenderingContext.STENCIL_FAIL == 2964
+WebGLRenderingContext.STENCIL_FUNC == 2962
+WebGLRenderingContext.STENCIL_INDEX == 6401
+WebGLRenderingContext.STENCIL_INDEX8 == 36168
+WebGLRenderingContext.STENCIL_PASS_DEPTH_FAIL == 2965
+WebGLRenderingContext.STENCIL_PASS_DEPTH_PASS == 2966
+WebGLRenderingContext.STENCIL_REF == 2967
+WebGLRenderingContext.STENCIL_TEST == 2960
+WebGLRenderingContext.STENCIL_VALUE_MASK == 2963
+WebGLRenderingContext.STENCIL_WRITEMASK == 2968
+WebGLRenderingContext.STREAM_DRAW == 35040
+WebGLRenderingContext.SUBPIXEL_BITS == 3408
+WebGLRenderingContext.TEXTURE == 5890
+WebGLRenderingContext.TEXTURE0 == 33984
+WebGLRenderingContext.TEXTURE1 == 33985
+WebGLRenderingContext.TEXTURE10 == 33994
+WebGLRenderingContext.TEXTURE11 == 33995
+WebGLRenderingContext.TEXTURE12 == 33996
+WebGLRenderingContext.TEXTURE13 == 33997
+WebGLRenderingContext.TEXTURE14 == 33998
+WebGLRenderingContext.TEXTURE15 == 33999
+WebGLRenderingContext.TEXTURE16 == 34000
+WebGLRenderingContext.TEXTURE17 == 34001
+WebGLRenderingContext.TEXTURE18 == 34002
+WebGLRenderingContext.TEXTURE19 == 34003
+WebGLRenderingContext.TEXTURE2 == 33986
+WebGLRenderingContext.TEXTURE20 == 34004
+WebGLRenderingContext.TEXTURE21 == 34005
+WebGLRenderingContext.TEXTURE22 == 34006
+WebGLRenderingContext.TEXTURE23 == 34007
+WebGLRenderingContext.TEXTURE24 == 34008
+WebGLRenderingContext.TEXTURE25 == 34009
+WebGLRenderingContext.TEXTURE26 == 34010
+WebGLRenderingContext.TEXTURE27 == 34011
+WebGLRenderingContext.TEXTURE28 == 34012
+WebGLRenderingContext.TEXTURE29 == 34013
+WebGLRenderingContext.TEXTURE3 == 33987
+WebGLRenderingContext.TEXTURE30 == 34014
+WebGLRenderingContext.TEXTURE31 == 34015
+WebGLRenderingContext.TEXTURE4 == 33988
+WebGLRenderingContext.TEXTURE5 == 33989
+WebGLRenderingContext.TEXTURE6 == 33990
+WebGLRenderingContext.TEXTURE7 == 33991
+WebGLRenderingContext.TEXTURE8 == 33992
+WebGLRenderingContext.TEXTURE9 == 33993
+WebGLRenderingContext.TEXTURE_2D == 3553
+WebGLRenderingContext.TEXTURE_BINDING_2D == 32873
+WebGLRenderingContext.TEXTURE_BINDING_CUBE_MAP == 34068
+WebGLRenderingContext.TEXTURE_CUBE_MAP == 34067
+WebGLRenderingContext.TEXTURE_CUBE_MAP_NEGATIVE_X == 34070
+WebGLRenderingContext.TEXTURE_CUBE_MAP_NEGATIVE_Y == 34072
+WebGLRenderingContext.TEXTURE_CUBE_MAP_NEGATIVE_Z == 34074
+WebGLRenderingContext.TEXTURE_CUBE_MAP_POSITIVE_X == 34069
+WebGLRenderingContext.TEXTURE_CUBE_MAP_POSITIVE_Y == 34071
+WebGLRenderingContext.TEXTURE_CUBE_MAP_POSITIVE_Z == 34073
+WebGLRenderingContext.TEXTURE_MAG_FILTER == 10240
+WebGLRenderingContext.TEXTURE_MIN_FILTER == 10241
+WebGLRenderingContext.TEXTURE_WRAP_S == 10242
+WebGLRenderingContext.TEXTURE_WRAP_T == 10243
+WebGLRenderingContext.TRIANGLES == 4
+WebGLRenderingContext.TRIANGLE_FAN == 6
+WebGLRenderingContext.TRIANGLE_STRIP == 5
+WebGLRenderingContext.UNPACK_ALIGNMENT == 3317
+WebGLRenderingContext.UNPACK_COLORSPACE_CONVERSION_WEBGL == 37443
+WebGLRenderingContext.UNPACK_FLIP_Y_WEBGL == 37440
+WebGLRenderingContext.UNPACK_PREMULTIPLY_ALPHA_WEBGL == 37441
+WebGLRenderingContext.UNSIGNED_BYTE == 5121
+WebGLRenderingContext.UNSIGNED_INT == 5125
+WebGLRenderingContext.UNSIGNED_SHORT == 5123
+WebGLRenderingContext.UNSIGNED_SHORT_4_4_4_4 == 32819
+WebGLRenderingContext.UNSIGNED_SHORT_5_5_5_1 == 32820
+WebGLRenderingContext.UNSIGNED_SHORT_5_6_5 == 33635
+WebGLRenderingContext.VALIDATE_STATUS == 35715
+WebGLRenderingContext.VENDOR == 7936
+WebGLRenderingContext.VERSION == 7938
+WebGLRenderingContext.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING == 34975
+WebGLRenderingContext.VERTEX_ATTRIB_ARRAY_ENABLED == 34338
+WebGLRenderingContext.VERTEX_ATTRIB_ARRAY_NORMALIZED == 34922
+WebGLRenderingContext.VERTEX_ATTRIB_ARRAY_POINTER == 34373
+WebGLRenderingContext.VERTEX_ATTRIB_ARRAY_SIZE == 34339
+WebGLRenderingContext.VERTEX_ATTRIB_ARRAY_STRIDE == 34340
+WebGLRenderingContext.VERTEX_ATTRIB_ARRAY_TYPE == 34341
+WebGLRenderingContext.VERTEX_SHADER == 35633
+WebGLRenderingContext.VIEWPORT == 2978
+WebGLRenderingContext.ZERO == 0
+
diff --git a/LayoutTests/fast/canvas/webgl/constants-on-interface.html b/LayoutTests/fast/canvas/webgl/constants-on-interface.html
new file mode 100644 (file)
index 0000000..1f90dda
--- /dev/null
@@ -0,0 +1,323 @@
+<script>
+if (window.testRunner)
+    window.testRunner.dumpAsText();
+
+const WebGLEnums = new Map([
+    ["ACTIVE_ATTRIBUTES", 0x8B89],
+    ["ACTIVE_TEXTURE", 0x84E0],
+    ["ACTIVE_UNIFORMS", 0x8B86],
+    ["ALIASED_LINE_WIDTH_RANGE", 0x846E],
+    ["ALIASED_POINT_SIZE_RANGE", 0x846D],
+    ["ALPHA", 0x1906],
+    ["ALPHA_BITS", 0x0D55],
+    ["ALWAYS", 0x0207],
+    ["ARRAY_BUFFER", 0x8892],
+    ["ARRAY_BUFFER_BINDING", 0x8894],
+    ["ATTACHED_SHADERS", 0x8B85],
+    ["BACK", 0x0405],
+    ["BLEND", 0x0BE2],
+    ["BLEND_COLOR", 0x8005],
+    ["BLEND_DST_ALPHA", 0x80CA],
+    ["BLEND_DST_RGB", 0x80C8],
+    ["BLEND_EQUATION", 0x8009],
+    ["BLEND_EQUATION_ALPHA", 0x883D],
+    ["BLEND_EQUATION_RGB", 0x8009],
+    ["BLEND_SRC_ALPHA", 0x80CB],
+    ["BLEND_SRC_RGB", 0x80C9],
+    ["BLUE_BITS", 0x0D54],
+    ["BOOL", 0x8B56],
+    ["BOOL_VEC2", 0x8B57],
+    ["BOOL_VEC3", 0x8B58],
+    ["BOOL_VEC4", 0x8B59],
+    ["BROWSER_DEFAULT_WEBGL", 0x9244],
+    ["BUFFER_SIZE", 0x8764],
+    ["BUFFER_USAGE", 0x8765],
+    ["BYTE", 0x1400],
+    ["CCW", 0x0901],
+    ["CLAMP_TO_EDGE", 0x812F],
+    ["COLOR_ATTACHMENT0", 0x8CE0],
+    ["COLOR_BUFFER_BIT", 0x00004000],
+    ["COLOR_CLEAR_VALUE", 0x0C22],
+    ["COLOR_WRITEMASK", 0x0C23],
+    ["COMPILE_STATUS", 0x8B81],
+    ["COMPRESSED_TEXTURE_FORMATS", 0x86A3],
+    ["CONSTANT_ALPHA", 0x8003],
+    ["CONSTANT_COLOR", 0x8001],
+    ["CONTEXT_LOST_WEBGL", 0x9242],
+    ["CULL_FACE", 0x0B44],
+    ["CULL_FACE_MODE", 0x0B45],
+    ["CURRENT_PROGRAM", 0x8B8D],
+    ["CURRENT_VERTEX_ATTRIB", 0x8626],
+    ["CW", 0x0900],
+    ["DECR", 0x1E03],
+    ["DECR_WRAP", 0x8508],
+    ["DELETE_STATUS", 0x8B80],
+    ["DEPTH_ATTACHMENT", 0x8D00],
+    ["DEPTH_BITS", 0x0D56],
+    ["DEPTH_BUFFER_BIT", 0x00000100],
+    ["DEPTH_CLEAR_VALUE", 0x0B73],
+    ["DEPTH_COMPONENT", 0x1902],
+    ["DEPTH_COMPONENT16", 0x81A5],
+    ["DEPTH_FUNC", 0x0B74],
+    ["DEPTH_RANGE", 0x0B70],
+    ["DEPTH_STENCIL", 0x84F9],
+    ["DEPTH_STENCIL_ATTACHMENT", 0x821A],
+    ["DEPTH_TEST", 0x0B71],
+    ["DEPTH_WRITEMASK", 0x0B72],
+    ["DITHER", 0x0BD0],
+    ["DONT_CARE", 0x1100],
+    ["DST_ALPHA", 0x0304],
+    ["DST_COLOR", 0x0306],
+    ["DYNAMIC_DRAW", 0x88E8],
+    ["ELEMENT_ARRAY_BUFFER", 0x8893],
+    ["ELEMENT_ARRAY_BUFFER_BINDING", 0x8895],
+    ["EQUAL", 0x0202],
+    ["FASTEST", 0x1101],
+    ["FLOAT", 0x1406],
+    ["FLOAT_MAT2", 0x8B5A],
+    ["FLOAT_MAT3", 0x8B5B],
+    ["FLOAT_MAT4", 0x8B5C],
+    ["FLOAT_VEC2", 0x8B50],
+    ["FLOAT_VEC3", 0x8B51],
+    ["FLOAT_VEC4", 0x8B52],
+    ["FRAGMENT_SHADER", 0x8B30],
+    ["FRAMEBUFFER", 0x8D40],
+    ["FRAMEBUFFER_ATTACHMENT_OBJECT_NAME", 0x8CD1],
+    ["FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE", 0x8CD0],
+    ["FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE", 0x8CD3],
+    ["FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL", 0x8CD2],
+    ["FRAMEBUFFER_BINDING", 0x8CA6],
+    ["FRAMEBUFFER_COMPLETE", 0x8CD5],
+    ["FRAMEBUFFER_INCOMPLETE_ATTACHMENT", 0x8CD6],
+    ["FRAMEBUFFER_INCOMPLETE_DIMENSIONS", 0x8CD9],
+    ["FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT", 0x8CD7],
+    ["FRAMEBUFFER_UNSUPPORTED", 0x8CDD],
+    ["FRONT", 0x0404],
+    ["FRONT_AND_BACK", 0x0408],
+    ["FRONT_FACE", 0x0B46],
+    ["FUNC_ADD", 0x8006],
+    ["FUNC_REVERSE_SUBTRACT", 0x800B],
+    ["FUNC_SUBTRACT", 0x800A],
+    ["GENERATE_MIPMAP_HINT", 0x8192],
+    ["GEQUAL", 0x0206],
+    ["GREATER", 0x0204],
+    ["GREEN_BITS", 0x0D53],
+    ["HIGH_FLOAT", 0x8DF2],
+    ["HIGH_INT", 0x8DF5],
+    ["IMPLEMENTATION_COLOR_READ_FORMAT", 0x8B9B],
+    ["IMPLEMENTATION_COLOR_READ_TYPE", 0x8B9A],
+    ["INCR", 0x1E02],
+    ["INCR_WRAP", 0x8507],
+    ["INT", 0x1404],
+    ["INT_VEC2", 0x8B53],
+    ["INT_VEC3", 0x8B54],
+    ["INT_VEC4", 0x8B55],
+    ["INVALID_ENUM", 0x0500],
+    ["INVALID_FRAMEBUFFER_OPERATION", 0x0506],
+    ["INVALID_OPERATION", 0x0502],
+    ["INVALID_VALUE", 0x0501],
+    ["INVERT", 0x150A],
+    ["KEEP", 0x1E00],
+    ["LEQUAL", 0x0203],
+    ["LESS", 0x0201],
+    ["LINEAR", 0x2601],
+    ["LINEAR_MIPMAP_LINEAR", 0x2703],
+    ["LINEAR_MIPMAP_NEAREST", 0x2701],
+    ["LINES", 0x0001],
+    ["LINE_LOOP", 0x0002],
+    ["LINE_STRIP", 0x0003],
+    ["LINE_WIDTH", 0x0B21],
+    ["LINK_STATUS", 0x8B82],
+    ["LOW_FLOAT", 0x8DF0],
+    ["LOW_INT", 0x8DF3],
+    ["LUMINANCE", 0x1909],
+    ["LUMINANCE_ALPHA", 0x190A],
+    ["MAX_COMBINED_TEXTURE_IMAGE_UNITS", 0x8B4D],
+    ["MAX_CUBE_MAP_TEXTURE_SIZE", 0x851C],
+    ["MAX_FRAGMENT_UNIFORM_VECTORS", 0x8DFD],
+    ["MAX_RENDERBUFFER_SIZE", 0x84E8],
+    ["MAX_TEXTURE_IMAGE_UNITS", 0x8872],
+    ["MAX_TEXTURE_SIZE", 0x0D33],
+    ["MAX_VARYING_VECTORS", 0x8DFC],
+    ["MAX_VERTEX_ATTRIBS", 0x8869],
+    ["MAX_VERTEX_TEXTURE_IMAGE_UNITS", 0x8B4C],
+    ["MAX_VERTEX_UNIFORM_VECTORS", 0x8DFB],
+    ["MAX_VIEWPORT_DIMS", 0x0D3A],
+    ["MEDIUM_FLOAT", 0x8DF1],
+    ["MEDIUM_INT", 0x8DF4],
+    ["MIRRORED_REPEAT", 0x8370],
+    ["NEAREST", 0x2600],
+    ["NEAREST_MIPMAP_LINEAR", 0x2702],
+    ["NEAREST_MIPMAP_NEAREST", 0x2700],
+    ["NEVER", 0x0200],
+    ["NICEST", 0x1102],
+    ["NONE", 0],
+    ["NOTEQUAL", 0x0205],
+    ["NO_ERROR", 0],
+    ["ONE", 1],
+    ["ONE_MINUS_CONSTANT_ALPHA", 0x8004],
+    ["ONE_MINUS_CONSTANT_COLOR", 0x8002],
+    ["ONE_MINUS_DST_ALPHA", 0x0305],
+    ["ONE_MINUS_DST_COLOR", 0x0307],
+    ["ONE_MINUS_SRC_ALPHA", 0x0303],
+    ["ONE_MINUS_SRC_COLOR", 0x0301],
+    ["OUT_OF_MEMORY", 0x0505],
+    ["PACK_ALIGNMENT", 0x0D05],
+    ["POINTS", 0x0000],
+    ["POLYGON_OFFSET_FACTOR", 0x8038],
+    ["POLYGON_OFFSET_FILL", 0x8037],
+    ["POLYGON_OFFSET_UNITS", 0x2A00],
+    ["RED_BITS", 0x0D52],
+    ["RENDERBUFFER", 0x8D41],
+    ["RENDERBUFFER_ALPHA_SIZE", 0x8D53],
+    ["RENDERBUFFER_BINDING", 0x8CA7],
+    ["RENDERBUFFER_BLUE_SIZE", 0x8D52],
+    ["RENDERBUFFER_DEPTH_SIZE", 0x8D54],
+    ["RENDERBUFFER_GREEN_SIZE", 0x8D51],
+    ["RENDERBUFFER_HEIGHT", 0x8D43],
+    ["RENDERBUFFER_INTERNAL_FORMAT", 0x8D44],
+    ["RENDERBUFFER_RED_SIZE", 0x8D50],
+    ["RENDERBUFFER_STENCIL_SIZE", 0x8D55],
+    ["RENDERBUFFER_WIDTH", 0x8D42],
+    ["RENDERER", 0x1F01],
+    ["REPEAT", 0x2901],
+    ["REPLACE", 0x1E01],
+    ["RGB", 0x1907],
+    ["RGB565", 0x8D62],
+    ["RGB5_A1", 0x8057],
+    ["RGBA", 0x1908],
+    ["RGBA4", 0x8056],
+    ["SAMPLER_2D", 0x8B5E],
+    ["SAMPLER_CUBE", 0x8B60],
+    ["SAMPLES", 0x80A9],
+    ["SAMPLE_ALPHA_TO_COVERAGE", 0x809E],
+    ["SAMPLE_BUFFERS", 0x80A8],
+    ["SAMPLE_COVERAGE", 0x80A0],
+    ["SAMPLE_COVERAGE_INVERT", 0x80AB],
+    ["SAMPLE_COVERAGE_VALUE", 0x80AA],
+    ["SCISSOR_BOX", 0x0C10],
+    ["SCISSOR_TEST", 0x0C11],
+    ["SHADER_TYPE", 0x8B4F],
+    ["SHADING_LANGUAGE_VERSION", 0x8B8C],
+    ["SHORT", 0x1402],
+    ["SRC_ALPHA", 0x0302],
+    ["SRC_ALPHA_SATURATE", 0x0308],
+    ["SRC_COLOR", 0x0300],
+    ["STATIC_DRAW", 0x88E4],
+    ["STENCIL_ATTACHMENT", 0x8D20],
+    ["STENCIL_BACK_FAIL", 0x8801],
+    ["STENCIL_BACK_FUNC", 0x8800],
+    ["STENCIL_BACK_PASS_DEPTH_FAIL", 0x8802],
+    ["STENCIL_BACK_PASS_DEPTH_PASS", 0x8803],
+    ["STENCIL_BACK_REF", 0x8CA3],
+    ["STENCIL_BACK_VALUE_MASK", 0x8CA4],
+    ["STENCIL_BACK_WRITEMASK", 0x8CA5],
+    ["STENCIL_BITS", 0x0D57],
+    ["STENCIL_BUFFER_BIT", 0x00000400],
+    ["STENCIL_CLEAR_VALUE", 0x0B91],
+    ["STENCIL_FAIL", 0x0B94],
+    ["STENCIL_FUNC", 0x0B92],
+    ["STENCIL_INDEX", 0x1901],
+    ["STENCIL_INDEX8", 0x8D48],
+    ["STENCIL_PASS_DEPTH_FAIL", 0x0B95],
+    ["STENCIL_PASS_DEPTH_PASS", 0x0B96],
+    ["STENCIL_REF", 0x0B97],
+    ["STENCIL_TEST", 0x0B90],
+    ["STENCIL_VALUE_MASK", 0x0B93],
+    ["STENCIL_WRITEMASK", 0x0B98],
+    ["STREAM_DRAW", 0x88E0],
+    ["SUBPIXEL_BITS", 0x0D50],
+    ["TEXTURE", 0x1702],
+    ["TEXTURE0", 0x84C0],
+    ["TEXTURE1", 0x84C1],
+    ["TEXTURE10", 0x84CA],
+    ["TEXTURE11", 0x84CB],
+    ["TEXTURE12", 0x84CC],
+    ["TEXTURE13", 0x84CD],
+    ["TEXTURE14", 0x84CE],
+    ["TEXTURE15", 0x84CF],
+    ["TEXTURE16", 0x84D0],
+    ["TEXTURE17", 0x84D1],
+    ["TEXTURE18", 0x84D2],
+    ["TEXTURE19", 0x84D3],
+    ["TEXTURE2", 0x84C2],
+    ["TEXTURE20", 0x84D4],
+    ["TEXTURE21", 0x84D5],
+    ["TEXTURE22", 0x84D6],
+    ["TEXTURE23", 0x84D7],
+    ["TEXTURE24", 0x84D8],
+    ["TEXTURE25", 0x84D9],
+    ["TEXTURE26", 0x84DA],
+    ["TEXTURE27", 0x84DB],
+    ["TEXTURE28", 0x84DC],
+    ["TEXTURE29", 0x84DD],
+    ["TEXTURE3", 0x84C3],
+    ["TEXTURE30", 0x84DE],
+    ["TEXTURE31", 0x84DF],
+    ["TEXTURE4", 0x84C4],
+    ["TEXTURE5", 0x84C5],
+    ["TEXTURE6", 0x84C6],
+    ["TEXTURE7", 0x84C7],
+    ["TEXTURE8", 0x84C8],
+    ["TEXTURE9", 0x84C9],
+    ["TEXTURE_2D", 0x0DE1],
+    ["TEXTURE_BINDING_2D", 0x8069],
+    ["TEXTURE_BINDING_CUBE_MAP", 0x8514],
+    ["TEXTURE_CUBE_MAP", 0x8513],
+    ["TEXTURE_CUBE_MAP_NEGATIVE_X", 0x8516],
+    ["TEXTURE_CUBE_MAP_NEGATIVE_Y", 0x8518],
+    ["TEXTURE_CUBE_MAP_NEGATIVE_Z", 0x851A],
+    ["TEXTURE_CUBE_MAP_POSITIVE_X", 0x8515],
+    ["TEXTURE_CUBE_MAP_POSITIVE_Y", 0x8517],
+    ["TEXTURE_CUBE_MAP_POSITIVE_Z", 0x8519],
+    ["TEXTURE_MAG_FILTER", 0x2800],
+    ["TEXTURE_MIN_FILTER", 0x2801],
+    ["TEXTURE_WRAP_S", 0x2802],
+    ["TEXTURE_WRAP_T", 0x2803],
+    ["TRIANGLES", 0x0004],
+    ["TRIANGLE_FAN", 0x0006],
+    ["TRIANGLE_STRIP", 0x0005],
+    ["UNPACK_ALIGNMENT", 0x0CF5],
+    ["UNPACK_COLORSPACE_CONVERSION_WEBGL", 0x9243],
+    ["UNPACK_FLIP_Y_WEBGL", 0x9240],
+    ["UNPACK_PREMULTIPLY_ALPHA_WEBGL", 0x9241],
+    ["UNSIGNED_BYTE", 0x1401],
+    ["UNSIGNED_INT", 0x1405],
+    ["UNSIGNED_SHORT", 0x1403],
+    ["UNSIGNED_SHORT_4_4_4_4", 0x8033],
+    ["UNSIGNED_SHORT_5_5_5_1", 0x8034],
+    ["UNSIGNED_SHORT_5_6_5", 0x8363],
+    ["VALIDATE_STATUS", 0x8B83],
+    ["VENDOR", 0x1F00],
+    ["VERSION", 0x1F02],
+    ["VERTEX_ATTRIB_ARRAY_BUFFER_BINDING", 0x889F],
+    ["VERTEX_ATTRIB_ARRAY_ENABLED", 0x8622],
+    ["VERTEX_ATTRIB_ARRAY_NORMALIZED", 0x886A],
+    ["VERTEX_ATTRIB_ARRAY_POINTER", 0x8645],
+    ["VERTEX_ATTRIB_ARRAY_SIZE", 0x8623],
+    ["VERTEX_ATTRIB_ARRAY_STRIDE", 0x8624],
+    ["VERTEX_ATTRIB_ARRAY_TYPE", 0x8625],
+    ["VERTEX_SHADER", 0x8B31],
+    ["VIEWPORT", 0x0BA2],
+    ["ZERO", 0]
+]);
+
+function run() {
+    const output = document.createElement("div");
+    document.querySelector("body").appendChild(output);
+
+    let log = (msg) => {
+        output.appendChild(document.createTextNode(msg));
+        output.appendChild(document.createElement("br"));
+    }
+
+    for (let [key, value] of WebGLEnums) {
+        if (WebGLRenderingContext[key] === value)
+            log(`WebGLRenderingContext.${key} == ${value}`);
+        else
+            log(`WebGLRenderingContext.${key} != ${value} (was ${WebGLRenderingContext[key]})`);
+    }
+}
+
+window.addEventListener("load", run, false);
+</script>
index 3920ccf..9dfe6b3 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: Argument 1 ('program') to WebGLRenderingContextBase.getAttachedShaders must be an instance of WebGLProgram.
+PASS gl.getAttachedShaders(standardVert) threw exception TypeError: Argument 1 ('program') to WebGLRenderingContext.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 c83d1dd..0b118d9 100644 (file)
@@ -14,10 +14,10 @@ PASS context.detachShader(undefined, shader) was expected value: INVALID_VALUE.
 PASS context.shaderSource(undefined, undefined) was expected value: INVALID_VALUE.
 PASS context.shaderSource(undefined, 'foo') was expected value: INVALID_VALUE.
 PASS context.bindAttribLocation(undefined, 0, 'foo') was expected value: INVALID_VALUE.
-PASS context.bindBuffer(context.ARRAY_BUFFER, 0) threw exception TypeError: Argument 2 ('buffer') to WebGLRenderingContextBase.bindBuffer must be an instance of WebGLBuffer.
-PASS context.bindFramebuffer(context.FRAMEBUFFER, 0) threw exception TypeError: Argument 2 ('framebuffer') to WebGLRenderingContextBase.bindFramebuffer must be an instance of WebGLFramebuffer.
-PASS context.bindRenderbuffer(context.RENDERBUFFER, 0) threw exception TypeError: Argument 2 ('renderbuffer') to WebGLRenderingContextBase.bindRenderbuffer must be an instance of WebGLRenderbuffer.
-PASS context.bindTexture(context.TEXTURE_2D, 0) threw exception TypeError: Argument 2 ('texture') to WebGLRenderingContextBase.bindTexture must be an instance of WebGLTexture.
+PASS context.bindBuffer(context.ARRAY_BUFFER, 0) threw exception TypeError: Argument 2 ('buffer') to WebGLRenderingContext.bindBuffer must be an instance of WebGLBuffer.
+PASS context.bindFramebuffer(context.FRAMEBUFFER, 0) threw exception TypeError: Argument 2 ('framebuffer') to WebGLRenderingContext.bindFramebuffer must be an instance of WebGLFramebuffer.
+PASS context.bindRenderbuffer(context.RENDERBUFFER, 0) threw exception TypeError: Argument 2 ('renderbuffer') to WebGLRenderingContext.bindRenderbuffer must be an instance of WebGLRenderbuffer.
+PASS context.bindTexture(context.TEXTURE_2D, 0) threw exception TypeError: Argument 2 ('texture') to WebGLRenderingContext.bindTexture must be an instance of WebGLTexture.
 PASS context.bindBuffer(context.ARRAY_BUFFER, null) was expected value: NO_ERROR.
 PASS context.bindFramebuffer(context.FRAMEBUFFER, null) was expected value: NO_ERROR.
 PASS context.bindRenderbuffer(context.RENDERBUFFER, null) was expected value: NO_ERROR.
index f51473d..500b0bf 100644 (file)
@@ -15,7 +15,7 @@ PASS context.pixelStorei(context.UNPACK_FLIP_Y_WEBGL, true) is undefined.
 PASS context.texImage2D(context.TEXTURE_2D, 0, context.RGBA, context.RGBA, context.UNSIGNED_BYTE, video) is undefined.
 PASS context.texSubImage2D(context.TEXTURE_2D) threw exception TypeError: Not enough arguments.
 PASS context.texSubImage2D(context.TEXTURE_2D, 0, 10, 20, 0, 0, context.RGBA, context.UNSIGNED_BYTE, null) is undefined.
-PASS context.texSubImage2D(context.TEXTURE_2D, 0, 10, 20, 0, 0, context.RGBA, context.UNSIGNED_BYTE, 0) threw exception TypeError: Argument 9 ('pixels') to WebGLRenderingContextBase.texSubImage2D must be an instance of ArrayBufferView.
+PASS context.texSubImage2D(context.TEXTURE_2D, 0, 10, 20, 0, 0, context.RGBA, context.UNSIGNED_BYTE, 0) threw exception TypeError: Argument 9 ('pixels') to WebGLRenderingContext.texSubImage2D must be an instance of ArrayBufferView.
 PASS context.texSubImage2D(context.TEXTURE_2D, 0, 10, 20, 0, context.UNSIGNED_BYTE, 0) threw exception TypeError: Type error.
 PASS context.pixelStorei(context.UNPACK_FLIP_Y_WEBGL, false) is undefined.
 PASS context.texSubImage2D(context.TEXTURE_2D, 0, 10, 20, context.RGBA, context.UNSIGNED_BYTE, imageData) is undefined.
index b1648b9..efd58f7 100644 (file)
@@ -1228,7 +1228,6 @@ set(WebCore_SOURCES
     bindings/js/JSVideoTrackCustom.cpp
     bindings/js/JSVideoTrackListCustom.cpp
     bindings/js/JSWebGL2RenderingContextCustom.cpp
-    bindings/js/JSWebGLRenderingContextBaseCustom.cpp
     bindings/js/JSWebGLRenderingContextCustom.cpp
     bindings/js/JSWebGPUCommandBufferCustom.cpp
     bindings/js/JSWebGPURenderPassAttachmentDescriptorCustom.cpp
index 3cedaf2..090705c 100644 (file)
@@ -1,3 +1,51 @@
+2017-05-11  Dean Jackson  <dino@apple.com>
+
+        WebGLRenderingContext should implement WebGLRenderingContextBase
+        https://bugs.webkit.org/show_bug.cgi?id=171961
+        <rdar://problem/32124920>
+
+        Reviewed by Sam Weinig.
+
+        WebGLRenderingContext and WebGL2RenderingContext are both
+        defined to "implement" WebGLRenderingContextBase. However, we
+        were doing it via inheritance, which meant that some things
+        were not visible on the WebGLRenderingContext prototype.
+
+        Test: fast/canvas/webgl/constants-on-interface.html
+
+        * WebCore.xcodeproj/project.pbxproj: Move the Custom.cpp files
+        out of the GC-only area now they have real content.
+
+        * bindings/js/JSDocumentCustom.cpp: Handle the fact that we
+        don't use the base class from the bindings, so we need to
+        translate WebGL1 and WebGL2 contexts into the right JS classes.
+        (WebCore::JSDocument::getCSSCanvasContext):
+        * bindings/js/JSHTMLCanvasElementCustom.cpp:
+        (WebCore::JSHTMLCanvasElement::getContext):
+
+        * bindings/js/JSWebGL2RenderingContextCustom.cpp: Implement the
+        custom methods. In this case, we don't yet expose any
+        extensions for WebGL 2.
+        (WebCore::toJS):
+        (WebCore::JSWebGL2RenderingContext::getExtension):
+
+        * bindings/js/JSWebGLRenderingContextBaseCustom.cpp: Removed.
+
+        * bindings/js/JSWebGLRenderingContextCustom.cpp:
+        (WebCore::toJS):
+        (WebCore::JSWebGLRenderingContext::getExtension):
+
+        * html/canvas/WebGL2RenderingContext.h: Make some things public.
+        * html/canvas/WebGLRenderingContext.h: Ditto.
+
+        * html/canvas/WebGL2RenderingContext.idl: Use implements.
+        * html/canvas/WebGLRenderingContext.idl: Ditto.
+
+        * testing/Internals.cpp: This now takes a WebGLRenderingContext.
+        (WebCore::Internals::simulateWebGLContextChanged):
+        * testing/Internals.h:
+        * testing/Internals.idl:
+
 2017-05-11  Andy Estes  <aestes@apple.com>
 
         Fix a spelling mistake in ApplePayErrorCode
index d88211f..a353cd8 100644 (file)
                D3D4E973130C7CFE007BA540 /* HTMLSummaryElement.h in Headers */ = {isa = PBXBuildFile; fileRef = D3D4E971130C7CFE007BA540 /* HTMLSummaryElement.h */; };
                D3F3D3631A69B1900059FC2B /* JSWebGL2RenderingContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D3F3D3611A69B1900059FC2B /* JSWebGL2RenderingContext.cpp */; };
                D3F3D3641A69B1900059FC2B /* JSWebGL2RenderingContext.h in Headers */ = {isa = PBXBuildFile; fileRef = D3F3D3621A69B1900059FC2B /* JSWebGL2RenderingContext.h */; };
-               D3F3D3671A69B1A50059FC2B /* JSWebGLRenderingContextBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D3F3D3651A69B1A50059FC2B /* JSWebGLRenderingContextBase.cpp */; };
-               D3F3D3681A69B1A50059FC2B /* JSWebGLRenderingContextBase.h in Headers */ = {isa = PBXBuildFile; fileRef = D3F3D3661A69B1A50059FC2B /* JSWebGLRenderingContextBase.h */; };
                D3F3D3691A69B7B00059FC2B /* WebGLRenderingContextBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D3F3D35E1A69A5060059FC2B /* WebGLRenderingContextBase.cpp */; };
                D3F3D36A1A69B7B90059FC2B /* WebGLRenderingContextBase.h in Headers */ = {isa = PBXBuildFile; fileRef = D3F3D35F1A69A5060059FC2B /* WebGLRenderingContextBase.h */; };
-               D3F3D36B1A69B7C50059FC2B /* JSWebGLRenderingContextBaseCustom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D3F3D35A1A69A3B00059FC2B /* JSWebGLRenderingContextBaseCustom.cpp */; };
                D3F3D36C1A69B7D50059FC2B /* JSWebGL2RenderingContextCustom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D3F3D3591A69A3B00059FC2B /* JSWebGL2RenderingContextCustom.cpp */; };
                D3F3D36D1A69B7DC0059FC2B /* WebGL2RenderingContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D3F3D35B1A69A5060059FC2B /* WebGL2RenderingContext.cpp */; };
                D3F3D36E1A69B7E00059FC2B /* WebGL2RenderingContext.h in Headers */ = {isa = PBXBuildFile; fileRef = D3F3D35C1A69A5060059FC2B /* WebGL2RenderingContext.h */; };
                D3D4E970130C7CFE007BA540 /* HTMLSummaryElement.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = HTMLSummaryElement.cpp; sourceTree = "<group>"; };
                D3D4E971130C7CFE007BA540 /* HTMLSummaryElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = HTMLSummaryElement.h; sourceTree = "<group>"; };
                D3F3D3591A69A3B00059FC2B /* JSWebGL2RenderingContextCustom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSWebGL2RenderingContextCustom.cpp; sourceTree = "<group>"; };
-               D3F3D35A1A69A3B00059FC2B /* JSWebGLRenderingContextBaseCustom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSWebGLRenderingContextBaseCustom.cpp; sourceTree = "<group>"; };
                D3F3D35B1A69A5060059FC2B /* WebGL2RenderingContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebGL2RenderingContext.cpp; sourceTree = "<group>"; };
                D3F3D35C1A69A5060059FC2B /* WebGL2RenderingContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebGL2RenderingContext.h; sourceTree = "<group>"; };
                D3F3D35D1A69A5060059FC2B /* WebGL2RenderingContext.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebGL2RenderingContext.idl; sourceTree = "<group>"; };
                D3F3D3601A69A5060059FC2B /* WebGLRenderingContextBase.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebGLRenderingContextBase.idl; sourceTree = "<group>"; };
                D3F3D3611A69B1900059FC2B /* JSWebGL2RenderingContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSWebGL2RenderingContext.cpp; sourceTree = "<group>"; };
                D3F3D3621A69B1900059FC2B /* JSWebGL2RenderingContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSWebGL2RenderingContext.h; sourceTree = "<group>"; };
-               D3F3D3651A69B1A50059FC2B /* JSWebGLRenderingContextBase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSWebGLRenderingContextBase.cpp; sourceTree = "<group>"; };
-               D3F3D3661A69B1A50059FC2B /* JSWebGLRenderingContextBase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSWebGLRenderingContextBase.h; sourceTree = "<group>"; };
                D4F72C653A64807A83E76FB8 /* MathMLOperatorDictionary.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MathMLOperatorDictionary.cpp; sourceTree = "<group>"; };
                D619A305144E00BE004BC302 /* ChildListMutationScope.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ChildListMutationScope.cpp; sourceTree = "<group>"; };
                D619A306144E00BE004BC302 /* ChildListMutationScope.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ChildListMutationScope.h; sourceTree = "<group>"; };
                                07846384145B1B8E00A58DF1 /* JSTrackCustom.h */,
                                516BB7920CE91E6800512F79 /* JSTreeWalkerCustom.cpp */,
                                BE6DF70A171CA2C500DD52B8 /* JSVideoTrackListCustom.cpp */,
-                               D3F3D3591A69A3B00059FC2B /* JSWebGL2RenderingContextCustom.cpp */,
-                               49EED14C1051971A00099FAB /* JSWebGLRenderingContextCustom.cpp */,
                                31A088C41E737B2C003B6609 /* JSWebGPURenderingContextCustom.cpp */,
                                31A088C51E737B2C003B6609 /* JSWebGPURenderPassAttachmentDescriptorCustom.cpp */,
                                83A4A9F81CE7FD7E00709B00 /* JSXMLDocumentCustom.cpp */,
                                49C7B98B1042D2D30009D447 /* JSWebGLRenderbuffer.h */,
                                49EED1401051969400099FAB /* JSWebGLRenderingContext.cpp */,
                                49EED1411051969400099FAB /* JSWebGLRenderingContext.h */,
-                               D3F3D3651A69B1A50059FC2B /* JSWebGLRenderingContextBase.cpp */,
-                               D3F3D3661A69B1A50059FC2B /* JSWebGLRenderingContextBase.h */,
                                6F995A291A70833700A735F4 /* JSWebGLSampler.cpp */,
                                6F995A2A1A70833700A735F4 /* JSWebGLSampler.h */,
                                49C7B98F1042D2D30009D447 /* JSWebGLShader.cpp */,
                                07E116B01489C9A100EC5ACE /* JSTextTrackCustom.cpp */,
                                7C73FB17191EF808007DE061 /* JSUserMessageHandlersNamespaceCustom.cpp */,
                                BE6DF708171CA2C500DD52B8 /* JSVideoTrackCustom.cpp */,
-                               D3F3D35A1A69A3B00059FC2B /* JSWebGLRenderingContextBaseCustom.cpp */,
+                               D3F3D3591A69A3B00059FC2B /* JSWebGL2RenderingContextCustom.cpp */,
+                               49EED14C1051971A00099FAB /* JSWebGLRenderingContextCustom.cpp */,
                                38850C521E964C1100C60753 /* JSWebGPUCommandBufferCustom.cpp */,
                                E1FF8F661807460800132674 /* JSWebKitSubtleCryptoCustom.cpp */,
                                E1CA5CBB0E8CDCAF00E8EF90 /* JSWorkerCustom.cpp */,
                                6F995A321A70833700A735F4 /* JSWebGLQuery.h in Headers */,
                                49C7B99E1042D2D30009D447 /* JSWebGLRenderbuffer.h in Headers */,
                                49EED1471051969400099FAB /* JSWebGLRenderingContext.h in Headers */,
-                               D3F3D3681A69B1A50059FC2B /* JSWebGLRenderingContextBase.h in Headers */,
                                6F995A341A70833700A735F4 /* JSWebGLSampler.h in Headers */,
                                49C7B9A31042D2D30009D447 /* JSWebGLShader.h in Headers */,
                                A07D3356152B630E001B6393 /* JSWebGLShaderPrecisionFormat.h in Headers */,
                                6F995A311A70833700A735F4 /* JSWebGLQuery.cpp in Sources */,
                                49C7B99D1042D2D30009D447 /* JSWebGLRenderbuffer.cpp in Sources */,
                                49EED1461051969400099FAB /* JSWebGLRenderingContext.cpp in Sources */,
-                               D3F3D3671A69B1A50059FC2B /* JSWebGLRenderingContextBase.cpp in Sources */,
-                               D3F3D36B1A69B7C50059FC2B /* JSWebGLRenderingContextBaseCustom.cpp in Sources */,
                                49EED14F1051971A00099FAB /* JSWebGLRenderingContextCustom.cpp in Sources */,
                                6F995A331A70833700A735F4 /* JSWebGLSampler.cpp in Sources */,
                                49C7B9A21042D2D30009D447 /* JSWebGLShader.cpp in Sources */,
index 060c06b..331cfaf 100644 (file)
 #include <wtf/GetPtr.h>
 
 #if ENABLE(WEBGL)
-#include "JSWebGLRenderingContextBase.h"
+#include "JSWebGLRenderingContext.h"
+#if ENABLE(WEBGL2)
+#include "JSWebGL2RenderingContext.h"
+#endif
 #endif
 
 #if ENABLE(WEBGPU)
@@ -151,8 +154,12 @@ JSValue JSDocument::getCSSCanvasContext(JSC::ExecState& state)
         return jsNull();
 
 #if ENABLE(WEBGL)
-    if (is<WebGLRenderingContextBase>(*context))
-        return toJS(&state, globalObject(), downcast<WebGLRenderingContextBase>(*context));
+    if (is<WebGLRenderingContext>(*context))
+        return toJS(&state, globalObject(), downcast<WebGLRenderingContext>(*context));
+#if ENABLE(WEBGL2)
+    if (is<WebGL2RenderingContext>(*context))
+        return toJS(&state, globalObject(), downcast<WebGL2RenderingContext>(*context));
+#endif
 #endif
 #if ENABLE(WEBGPU)
     if (is<WebGPURenderingContext>(*context))
index 2fe81cc..bde12cd 100644 (file)
 
 #if ENABLE(WEBGL)
 #include "JSWebGLContextAttributes.h"
-#include "JSWebGLRenderingContextBase.h"
+#include "JSWebGLRenderingContext.h"
+#if ENABLE(WEBGL2)
+#include "JSWebGL2RenderingContext.h"
+#endif
 #endif
 
 #if ENABLE(WEBGPU)
@@ -64,7 +67,14 @@ JSValue JSHTMLCanvasElement::getContext(ExecState& state)
         auto attributes = convert<IDLDictionary<WebGLContextAttributes>>(state, state.argument(1));
         RETURN_IF_EXCEPTION(scope, JSValue());
 
-        return toJS<IDLNullable<IDLInterface<WebGLRenderingContextBase>>>(state, *globalObject(), static_cast<WebGLRenderingContextBase*>(wrapped().getContextWebGL(contextId, WTFMove(attributes))));
+        if (auto context = wrapped().getContextWebGL(contextId, WTFMove(attributes))) {
+            if (is<WebGLRenderingContext>(*context))
+                return toJS<IDLNullable<IDLInterface<WebGLRenderingContext>>>(state, *globalObject(), static_cast<WebGLRenderingContext*>(context));
+#if ENABLE(WEBGL2)
+            if (is<WebGL2RenderingContext>(*context))
+                return toJS<IDLNullable<IDLInterface<WebGL2RenderingContext>>>(state, *globalObject(), static_cast<WebGL2RenderingContext*>(context));
+#endif
+        }
     }
 #endif
 
index 9cefb0e..b22668b 100644 (file)
@@ -39,6 +39,25 @@ void JSWebGL2RenderingContext::visitAdditionalChildren(SlotVisitor& visitor)
     visitor.addOpaqueRoot(&wrapped());
 }
 
+static JSValue toJS(ExecState&, JSDOMGlobalObject&, WebGLExtension*)
+{
+    // No extensions for WebGL2 at the moment.
+    return jsNull();
+}
+
+JSValue JSWebGL2RenderingContext::getExtension(ExecState& state)
+{
+    VM& vm = state.vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    if (state.argumentCount() < 1)
+        return throwException(&state, scope, createNotEnoughArgumentsError(&state));
+
+    auto name = state.uncheckedArgument(0).toWTFString(&state);
+    RETURN_IF_EXCEPTION(scope, { });
+    return toJS(state, *globalObject(), wrapped().getExtension(name));
+}
+
 } // namespace WebCore
 
 #endif // ENABLE(WEBGL)
diff --git a/Source/WebCore/bindings/js/JSWebGLRenderingContextBaseCustom.cpp b/Source/WebCore/bindings/js/JSWebGLRenderingContextBaseCustom.cpp
deleted file mode 100644 (file)
index 66d7ebd..0000000
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
- * Copyright (C) 2015-2017 Apple Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
- */
-
-#include "config.h"
-
-#if ENABLE(WEBGL)
-
-#include "EXTBlendMinMax.h"
-#include "EXTFragDepth.h"
-#include "EXTShaderTextureLOD.h"
-#include "EXTTextureFilterAnisotropic.h"
-#include "EXTsRGB.h"
-#include "ExceptionCode.h"
-#include "JSANGLEInstancedArrays.h"
-#include "JSEXTBlendMinMax.h"
-#include "JSEXTFragDepth.h"
-#include "JSEXTShaderTextureLOD.h"
-#include "JSEXTTextureFilterAnisotropic.h"
-#include "JSEXTsRGB.h"
-#include "JSHTMLCanvasElement.h"
-#include "JSHTMLImageElement.h"
-#include "JSImageData.h"
-#include "JSOESElementIndexUint.h"
-#include "JSOESStandardDerivatives.h"
-#include "JSOESTextureFloat.h"
-#include "JSOESTextureFloatLinear.h"
-#include "JSOESTextureHalfFloat.h"
-#include "JSOESTextureHalfFloatLinear.h"
-#include "JSOESVertexArrayObject.h"
-#include "JSWebGLBuffer.h"
-#include "JSWebGLCompressedTextureATC.h"
-#include "JSWebGLCompressedTexturePVRTC.h"
-#include "JSWebGLCompressedTextureS3TC.h"
-#include "JSWebGLDebugRendererInfo.h"
-#include "JSWebGLDebugShaders.h"
-#include "JSWebGLDepthTexture.h"
-#include "JSWebGLDrawBuffers.h"
-#include "JSWebGLFramebuffer.h"
-#include "JSWebGLLoseContext.h"
-#include "JSWebGLProgram.h"
-#include "JSWebGLRenderbuffer.h"
-#include "JSWebGLRenderingContext.h"
-#include "JSWebGLShader.h"
-#include "JSWebGLTexture.h"
-#include "JSWebGLUniformLocation.h"
-#include "JSWebGLVertexArrayObject.h"
-#include "JSWebGLVertexArrayObjectOES.h"
-#include "JSWebKitCSSMatrix.h"
-#include "OESElementIndexUint.h"
-#include "OESStandardDerivatives.h"
-#include "OESTextureFloat.h"
-#include "OESTextureFloatLinear.h"
-#include "OESTextureHalfFloat.h"
-#include "OESTextureHalfFloatLinear.h"
-#include "OESVertexArrayObject.h"
-#include "WebGLBuffer.h"
-#include "WebGLCompressedTextureATC.h"
-#include "WebGLCompressedTexturePVRTC.h"
-#include "WebGLCompressedTextureS3TC.h"
-#include "WebGLDebugRendererInfo.h"
-#include "WebGLDebugShaders.h"
-#include "WebGLDepthTexture.h"
-#include "WebGLDrawBuffers.h"
-#include "WebGLExtension.h"
-#include "WebGLFramebuffer.h"
-#include "WebGLLoseContext.h"
-#include "WebGLProgram.h"
-#include "WebGLRenderingContextBase.h"
-#include "WebGLVertexArrayObject.h"
-#include "WebGLVertexArrayObjectOES.h"
-#include <runtime/Error.h>
-#include <runtime/JSObjectInlines.h>
-#include <runtime/JSTypedArrays.h>
-#include <runtime/TypedArrayInlines.h>
-#include <runtime/TypedArrays.h>
-#include <wtf/FastMalloc.h>
-
-#if ENABLE(VIDEO)
-#include "JSHTMLVideoElement.h"
-#endif
-
-#if ENABLE(WEBGL2)
-#include "JSWebGL2RenderingContext.h"
-#endif
-
-using namespace JSC;
-
-namespace WebCore {
-
-JSValue toJSNewlyCreated(ExecState*, JSDOMGlobalObject* globalObject, Ref<WebGLRenderingContextBase>&& object)
-{
-#if ENABLE(WEBGL2)
-    if (is<WebGL2RenderingContext>(object))
-        return createWrapper<WebGL2RenderingContext>(globalObject, WTFMove(object));
-#endif
-    return createWrapper<WebGLRenderingContext>(globalObject, WTFMove(object));
-}
-
-JSValue toJS(ExecState* state, JSDOMGlobalObject* globalObject, WebGLRenderingContextBase& object)
-{
-    return wrap(state, globalObject, object);
-}
-    
-static JSValue toJS(ExecState& state, JSDOMGlobalObject& globalObject, WebGLExtension* extension)
-{
-    if (!extension)
-        return jsNull();
-    switch (extension->getName()) {
-    case WebGLExtension::WebGLLoseContextName:
-        return toJS(&state, &globalObject, static_cast<WebGLLoseContext*>(extension));
-    case WebGLExtension::EXTShaderTextureLODName:
-        return toJS(&state, &globalObject, static_cast<EXTShaderTextureLOD*>(extension));
-    case WebGLExtension::EXTTextureFilterAnisotropicName:
-        return toJS(&state, &globalObject, static_cast<EXTTextureFilterAnisotropic*>(extension));
-    case WebGLExtension::EXTsRGBName:
-        return toJS(&state, &globalObject, static_cast<EXTsRGB*>(extension));
-    case WebGLExtension::EXTFragDepthName:
-        return toJS(&state, &globalObject, static_cast<EXTFragDepth*>(extension));
-    case WebGLExtension::EXTBlendMinMaxName:
-        return toJS(&state, &globalObject, static_cast<EXTBlendMinMax*>(extension));
-    case WebGLExtension::OESStandardDerivativesName:
-        return toJS(&state, &globalObject, static_cast<OESStandardDerivatives*>(extension));
-    case WebGLExtension::OESTextureFloatName:
-        return toJS(&state, &globalObject, static_cast<OESTextureFloat*>(extension));
-    case WebGLExtension::OESTextureFloatLinearName:
-        return toJS(&state, &globalObject, static_cast<OESTextureFloatLinear*>(extension));
-    case WebGLExtension::OESTextureHalfFloatName:
-        return toJS(&state, &globalObject, static_cast<OESTextureHalfFloat*>(extension));
-    case WebGLExtension::OESTextureHalfFloatLinearName:
-        return toJS(&state, &globalObject, static_cast<OESTextureHalfFloatLinear*>(extension));
-    case WebGLExtension::OESVertexArrayObjectName:
-        return toJS(&state, &globalObject, static_cast<OESVertexArrayObject*>(extension));
-    case WebGLExtension::OESElementIndexUintName:
-        return toJS(&state, &globalObject, static_cast<OESElementIndexUint*>(extension));
-    case WebGLExtension::WebGLDebugRendererInfoName:
-        return toJS(&state, &globalObject, static_cast<WebGLDebugRendererInfo*>(extension));
-    case WebGLExtension::WebGLDebugShadersName:
-        return toJS(&state, &globalObject, static_cast<WebGLDebugShaders*>(extension));
-    case WebGLExtension::WebGLCompressedTextureATCName:
-        return toJS(&state, &globalObject, static_cast<WebGLCompressedTextureATC*>(extension));
-    case WebGLExtension::WebGLCompressedTexturePVRTCName:
-        return toJS(&state, &globalObject, static_cast<WebGLCompressedTexturePVRTC*>(extension));
-    case WebGLExtension::WebGLCompressedTextureS3TCName:
-        return toJS(&state, &globalObject, static_cast<WebGLCompressedTextureS3TC*>(extension));
-    case WebGLExtension::WebGLDepthTextureName:
-        return toJS(&state, &globalObject, static_cast<WebGLDepthTexture*>(extension));
-    case WebGLExtension::WebGLDrawBuffersName:
-        return toJS(&state, &globalObject, static_cast<WebGLDrawBuffers*>(extension));
-    case WebGLExtension::ANGLEInstancedArraysName:
-        return toJS(&state, &globalObject, static_cast<ANGLEInstancedArrays*>(extension));
-    }
-    ASSERT_NOT_REACHED();
-    return jsNull();
-}
-
-bool JSWebGLRenderingContextBaseOwner::isReachableFromOpaqueRoots(Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
-{
-    JSWebGLRenderingContextBase* jsWebGLRenderingContext = jsCast<JSWebGLRenderingContextBase*>(handle.slot()->asCell());
-    void* root = WebCore::root(jsWebGLRenderingContext->wrapped().canvas());
-    return visitor.containsOpaqueRoot(root);
-}
-
-void JSWebGLRenderingContextBase::visitAdditionalChildren(SlotVisitor& visitor)
-{
-    visitor.addOpaqueRoot(&wrapped());
-    visitor.addOpaqueRoot(root(wrapped().canvas()));
-}
-
-JSValue JSWebGLRenderingContextBase::getExtension(ExecState& state)
-{
-    VM& vm = state.vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    if (state.argumentCount() < 1)
-        return throwException(&state, scope, createNotEnoughArgumentsError(&state));
-    
-    auto name = state.uncheckedArgument(0).toWTFString(&state);
-    RETURN_IF_EXCEPTION(scope, { });
-    return toJS(state, *globalObject(), wrapped().getExtension(name));
-}
-
-} // namespace WebCore
-
-#endif // ENABLE(WEBGL)
index 65abcdd..c3fa116 100644 (file)
  */
 
 #include "config.h"
+#include "JSWebGLRenderingContext.h"
 
 #if ENABLE(WEBGL)
-#include "JSWebGLRenderingContext.h"
 #include "DOMWrapperWorld.h"
-#include <JavaScriptCore/JSCellInlines.h>
-#include <JavaScriptCore/StructureInlines.h>
-#include <heap/HeapInlines.h>
-#include <heap/SlotVisitorInlines.h>
+#include "EXTBlendMinMax.h"
+#include "EXTFragDepth.h"
+#include "EXTShaderTextureLOD.h"
+#include "EXTTextureFilterAnisotropic.h"
+#include "EXTsRGB.h"
+#include "JSANGLEInstancedArrays.h"
+#include "JSEXTBlendMinMax.h"
+#include "JSEXTFragDepth.h"
+#include "JSEXTShaderTextureLOD.h"
+#include "JSEXTTextureFilterAnisotropic.h"
+#include "JSEXTsRGB.h"
+#include "JSOESElementIndexUint.h"
+#include "JSOESStandardDerivatives.h"
+#include "JSOESTextureFloat.h"
+#include "JSOESTextureFloatLinear.h"
+#include "JSOESTextureHalfFloat.h"
+#include "JSOESTextureHalfFloatLinear.h"
+#include "JSOESVertexArrayObject.h"
+#include "JSWebGLCompressedTextureATC.h"
+#include "JSWebGLCompressedTexturePVRTC.h"
+#include "JSWebGLCompressedTextureS3TC.h"
+#include "JSWebGLDebugRendererInfo.h"
+#include "JSWebGLDebugShaders.h"
+#include "JSWebGLDepthTexture.h"
+#include "JSWebGLDrawBuffers.h"
+#include "JSWebGLLoseContext.h"
+#include "JSWebGLVertexArrayObject.h"
+#include "JSWebGLVertexArrayObjectOES.h"
+#include "OESElementIndexUint.h"
+#include "OESStandardDerivatives.h"
+#include "OESTextureFloat.h"
+#include "OESTextureFloatLinear.h"
+#include "OESTextureHalfFloat.h"
+#include "OESTextureHalfFloatLinear.h"
+#include "OESVertexArrayObject.h"
+#include "WebGLCompressedTextureATC.h"
+#include "WebGLCompressedTexturePVRTC.h"
+#include "WebGLCompressedTextureS3TC.h"
+#include "WebGLDebugRendererInfo.h"
+#include "WebGLDebugShaders.h"
+#include "WebGLDepthTexture.h"
+#include "WebGLDrawBuffers.h"
+#include "WebGLExtension.h"
+#include "WebGLLoseContext.h"
+#include "WebGLVertexArrayObject.h"
+#include "WebGLVertexArrayObjectOES.h"
 
 using namespace JSC;
 
@@ -42,6 +84,71 @@ void JSWebGLRenderingContext::visitAdditionalChildren(SlotVisitor& visitor)
     visitor.addOpaqueRoot(&wrapped());
 }
 
+static JSValue toJS(ExecState& state, JSDOMGlobalObject& globalObject, WebGLExtension* extension)
+{
+    if (!extension)
+        return jsNull();
+    switch (extension->getName()) {
+    case WebGLExtension::WebGLLoseContextName:
+        return toJS(&state, &globalObject, static_cast<WebGLLoseContext*>(extension));
+    case WebGLExtension::EXTShaderTextureLODName:
+        return toJS(&state, &globalObject, static_cast<EXTShaderTextureLOD*>(extension));
+    case WebGLExtension::EXTTextureFilterAnisotropicName:
+        return toJS(&state, &globalObject, static_cast<EXTTextureFilterAnisotropic*>(extension));
+    case WebGLExtension::EXTsRGBName:
+        return toJS(&state, &globalObject, static_cast<EXTsRGB*>(extension));
+    case WebGLExtension::EXTFragDepthName:
+        return toJS(&state, &globalObject, static_cast<EXTFragDepth*>(extension));
+    case WebGLExtension::EXTBlendMinMaxName:
+        return toJS(&state, &globalObject, static_cast<EXTBlendMinMax*>(extension));
+    case WebGLExtension::OESStandardDerivativesName:
+        return toJS(&state, &globalObject, static_cast<OESStandardDerivatives*>(extension));
+    case WebGLExtension::OESTextureFloatName:
+        return toJS(&state, &globalObject, static_cast<OESTextureFloat*>(extension));
+    case WebGLExtension::OESTextureFloatLinearName:
+        return toJS(&state, &globalObject, static_cast<OESTextureFloatLinear*>(extension));
+    case WebGLExtension::OESTextureHalfFloatName:
+        return toJS(&state, &globalObject, static_cast<OESTextureHalfFloat*>(extension));
+    case WebGLExtension::OESTextureHalfFloatLinearName:
+        return toJS(&state, &globalObject, static_cast<OESTextureHalfFloatLinear*>(extension));
+    case WebGLExtension::OESVertexArrayObjectName:
+        return toJS(&state, &globalObject, static_cast<OESVertexArrayObject*>(extension));
+    case WebGLExtension::OESElementIndexUintName:
+        return toJS(&state, &globalObject, static_cast<OESElementIndexUint*>(extension));
+    case WebGLExtension::WebGLDebugRendererInfoName:
+        return toJS(&state, &globalObject, static_cast<WebGLDebugRendererInfo*>(extension));
+    case WebGLExtension::WebGLDebugShadersName:
+        return toJS(&state, &globalObject, static_cast<WebGLDebugShaders*>(extension));
+    case WebGLExtension::WebGLCompressedTextureATCName:
+        return toJS(&state, &globalObject, static_cast<WebGLCompressedTextureATC*>(extension));
+    case WebGLExtension::WebGLCompressedTexturePVRTCName:
+        return toJS(&state, &globalObject, static_cast<WebGLCompressedTexturePVRTC*>(extension));
+    case WebGLExtension::WebGLCompressedTextureS3TCName:
+        return toJS(&state, &globalObject, static_cast<WebGLCompressedTextureS3TC*>(extension));
+    case WebGLExtension::WebGLDepthTextureName:
+        return toJS(&state, &globalObject, static_cast<WebGLDepthTexture*>(extension));
+    case WebGLExtension::WebGLDrawBuffersName:
+        return toJS(&state, &globalObject, static_cast<WebGLDrawBuffers*>(extension));
+    case WebGLExtension::ANGLEInstancedArraysName:
+        return toJS(&state, &globalObject, static_cast<ANGLEInstancedArrays*>(extension));
+    }
+    ASSERT_NOT_REACHED();
+    return jsNull();
+}
+
+JSValue JSWebGLRenderingContext::getExtension(ExecState& state)
+{
+    VM& vm = state.vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    if (state.argumentCount() < 1)
+        return throwException(&state, scope, createNotEnoughArgumentsError(&state));
+
+    auto name = state.uncheckedArgument(0).toWTFString(&state);
+    RETURN_IF_EXCEPTION(scope, { });
+    return toJS(state, *globalObject(), wrapped().getExtension(name));
+}
+
 } // namespace WebCore
 
 #endif // ENABLE(WEBGL)
index 720b132..08f6235 100644 (file)
@@ -168,10 +168,6 @@ public:
     GC3Dboolean isVertexArray(WebGLVertexArrayObject* vertexArray);
     void bindVertexArray(WebGLVertexArrayObject* vertexArray);
     
-private:
-    bool isWebGL2() const final { return true; }
-
-    // Extensions
     WebGLExtension* getExtension(const String&) final;
     std::optional<Vector<String>> getSupportedExtensions() final;
     WebGLAny getParameter(GC3Denum pname) final;
@@ -179,6 +175,9 @@ private:
     void renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height) final;
     void hint(GC3Denum target, GC3Denum mode) final;
 
+private:
+    bool isWebGL2() const final { return true; }
+
     void initializeVertexArrayObjects() final;
     GC3Dint getMaxDrawBuffers() final;
     GC3Dint getMaxColorAttachments() final;
index 15c2f4e..e681b29 100644 (file)
@@ -50,7 +50,7 @@ typedef (ImageData or HTMLImageElement or HTMLCanvasElement or HTMLVideoElement)
     JSCustomMarkFunction,
     JSGenerateToJSObject,
     DoNotCheckConstants,
-] interface WebGL2RenderingContext : WebGLRenderingContextBase {
+] interface WebGL2RenderingContext {
     const GLenum READ_BUFFER                                   = 0x0C02;
     const GLenum UNPACK_ROW_LENGTH                             = 0x0CF2;
     const GLenum UNPACK_SKIP_ROWS                              = 0x0CF3;
@@ -337,11 +337,6 @@ typedef (ImageData or HTMLImageElement or HTMLCanvasElement or HTMLVideoElement)
     const GLuint64 TIMEOUT_IGNORED                             = 0xFFFFFFFFFFFFFFFF;
 
     /* Buffer objects */
-    // WebGL1:
-    void bufferData(GLenum target, GLsizeiptr size, GLenum usage);
-    void bufferData(GLenum target, BufferDataSource? srcData, GLenum usage);
-    void bufferSubData(GLenum target, GLintptr dstByteOffset, BufferDataSource? srcData);
-    // WebGL2:
     void bufferData(GLenum target, ArrayBufferView data, GLenum usage, GLuint srcOffset, optional GLuint length = 0);
     void bufferSubData(GLenum target, GLintptr dstByteOffset, ArrayBufferView srcData, GLuint srcOffset, optional GLuint length = 0);
 
@@ -466,3 +461,5 @@ typedef (ImageData or HTMLImageElement or HTMLCanvasElement or HTMLVideoElement)
     GLboolean isVertexArray(WebGLVertexArrayObject? vertexArray);
     void bindVertexArray(WebGLVertexArrayObject? vertexArray);
 };
+
+WebGL2RenderingContext implements WebGLRenderingContextBase;
index 5f4e5d0..0959660 100644 (file)
@@ -34,7 +34,6 @@ public:
     WebGLRenderingContext(HTMLCanvasElement&, GraphicsContext3DAttributes);
     WebGLRenderingContext(HTMLCanvasElement&, Ref<GraphicsContext3D>&&, GraphicsContext3DAttributes);
 
-private:
     bool isWebGL1() const final { return true; }
 
     WebGLExtension* getExtension(const String&) final;
index 80cd98e..9862777 100644 (file)
@@ -28,5 +28,8 @@
     JSCustomMarkFunction,
     JSGenerateToJSObject,
     DoNotCheckConstants,
-] interface WebGLRenderingContext : WebGLRenderingContextBase {
+    ExportMacro=WEBCORE_EXPORT,
+] interface WebGLRenderingContext {
 };
+
+WebGLRenderingContext implements WebGLRenderingContextBase;
index e24d719..7bf1f41 100644 (file)
 #include "ViewportArguments.h"
 #include "WebCoreJSClientData.h"
 #if ENABLE(WEBGL)
-#include "WebGLRenderingContextBase.h"
+#include "WebGLRenderingContext.h"
 #endif
 #include "WorkerThread.h"
 #include "WritingDirection.h"
@@ -3976,7 +3976,7 @@ void Internals::setAsRunningUserScripts(Document& document)
 }
 
 #if ENABLE(WEBGL)
-void Internals::simulateWebGLContextChanged(WebGLRenderingContextBase& context)
+void Internals::simulateWebGLContextChanged(WebGLRenderingContext& context)
 {
     context.simulateContextChanged();
 }
index 837a542..a5c714d 100644 (file)
@@ -76,7 +76,7 @@ class SourceBuffer;
 class StyleSheet;
 class TimeRanges;
 class TypeConversions;
-class WebGLRenderingContextBase;
+class WebGLRenderingContext;
 class XMLHttpRequest;
 
 class Internals final : public RefCounted<Internals>,  private ContextDestructionObserver
@@ -565,7 +565,7 @@ public:
     void setAsRunningUserScripts(Document&);
 
 #if ENABLE(WEBGL)
-    void simulateWebGLContextChanged(WebGLRenderingContextBase&);
+    void simulateWebGLContextChanged(WebGLRenderingContext&);
 #endif
 
 #if ENABLE(MEDIA_STREAM)
index 2ea1e01..8383e25 100644 (file)
@@ -530,7 +530,7 @@ enum EventThrottlingBehavior {
     void disableTileSizeUpdateDelay();
     void setSpeculativeTilingDelayDisabledForTesting(boolean disabled);
 
-    [Conditional=WEBGL] void simulateWebGLContextChanged(WebGLRenderingContextBase context);
+    [Conditional=WEBGL] void simulateWebGLContextChanged(WebGLRenderingContext context);
 
     [Conditional=MEDIA_STREAM] void observeMediaStreamTrack(MediaStreamTrack track);
     [Conditional=MEDIA_STREAM] Promise<ImageData> grabNextMediaStreamTrackFrame();