[WebGL] More GraphicsContext3D to GraphicsContextGL renaming
authordino@apple.com <dino@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 8 Jan 2020 20:27:42 +0000 (20:27 +0000)
committerdino@apple.com <dino@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 8 Jan 2020 20:27:42 +0000 (20:27 +0000)
https://bugs.webkit.org/show_bug.cgi?id=205949
<rdar://problem/58416989>

Reviewed by Antoine Quint.

Source/WebCore:

Rename the GC3D-prefixed types.

* Headers.cmake:
* WebCore.xcodeproj/project.pbxproj:
* html/HTMLVideoElement.cpp:
* html/HTMLVideoElement.h:
* html/OffscreenCanvas.cpp:
* html/canvas/ANGLEInstancedArrays.cpp:
* html/canvas/ANGLEInstancedArrays.h:
* html/canvas/OESVertexArrayObject.cpp:
* html/canvas/OESVertexArrayObject.h:
* html/canvas/WebGL2RenderingContext.cpp:
* html/canvas/WebGL2RenderingContext.h:
* html/canvas/WebGLActiveInfo.h:
* html/canvas/WebGLBuffer.cpp:
* html/canvas/WebGLBuffer.h:
* html/canvas/WebGLDrawBuffers.cpp:
* html/canvas/WebGLDrawBuffers.h:
* html/canvas/WebGLFramebuffer.cpp:
* html/canvas/WebGLFramebuffer.h:
* html/canvas/WebGLObject.cpp:
* html/canvas/WebGLObject.h:
* html/canvas/WebGLProgram.cpp:
* html/canvas/WebGLProgram.h:
* html/canvas/WebGLQuery.cpp:
* html/canvas/WebGLQuery.h:
* html/canvas/WebGLRenderbuffer.cpp:
* html/canvas/WebGLRenderbuffer.h:
* html/canvas/WebGLRenderingContext.cpp:
* html/canvas/WebGLRenderingContext.h:
* html/canvas/WebGLRenderingContextBase.cpp:
* html/canvas/WebGLRenderingContextBase.h:
* html/canvas/WebGLSampler.cpp:
* html/canvas/WebGLSampler.h:
* html/canvas/WebGLShader.cpp:
* html/canvas/WebGLShader.h:
* html/canvas/WebGLShaderPrecisionFormat.cpp:
* html/canvas/WebGLShaderPrecisionFormat.h:
* html/canvas/WebGLSync.cpp:
* html/canvas/WebGLSync.h:
* html/canvas/WebGLTexture.cpp:
* html/canvas/WebGLTexture.h:
* html/canvas/WebGLTransformFeedback.cpp:
* html/canvas/WebGLTransformFeedback.h:
* html/canvas/WebGLUniformLocation.cpp:
* html/canvas/WebGLUniformLocation.h:
* html/canvas/WebGLVertexArrayObject.cpp:
* html/canvas/WebGLVertexArrayObject.h:
* html/canvas/WebGLVertexArrayObjectBase.cpp:
* html/canvas/WebGLVertexArrayObjectBase.h:
* html/canvas/WebGLVertexArrayObjectOES.cpp:
* html/canvas/WebGLVertexArrayObjectOES.h:
* platform/graphics/ExtensionsGL.h:
* platform/graphics/GraphicsContextGL.cpp:
* platform/graphics/GraphicsContextGL.h:
* platform/graphics/GraphicsTypesGL.h: Renamed from Source/WebCore/platform/graphics/GraphicsTypes3D.h.
* platform/graphics/ImageBuffer.cpp:
* platform/graphics/ImageBuffer.h:
* platform/graphics/MediaPlayer.cpp:
* platform/graphics/MediaPlayer.h:
* platform/graphics/MediaPlayerPrivate.h:
* platform/graphics/angle/ExtensionsGLANGLE.cpp:
* platform/graphics/angle/ExtensionsGLANGLE.h:
* platform/graphics/angle/GraphicsContextGLANGLE.cpp:
* platform/graphics/angle/TemporaryANGLESetting.h:
* platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h:
* platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm:
* platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h:
* platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm:
* platform/graphics/cairo/ImageBufferCairo.cpp:
* platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm:
* platform/graphics/cocoa/WebGLLayer.mm:
* platform/graphics/cv/TextureCacheCV.h:
* platform/graphics/cv/TextureCacheCV.mm:
* platform/graphics/cv/VideoTextureCopierCV.cpp:
* platform/graphics/cv/VideoTextureCopierCV.h:
* platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:
* platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h:
* platform/graphics/opengl/ExtensionsGLOpenGL.cpp:
* platform/graphics/opengl/ExtensionsGLOpenGL.h:
* platform/graphics/opengl/ExtensionsGLOpenGLCommon.cpp:
* platform/graphics/opengl/ExtensionsGLOpenGLCommon.h:
* platform/graphics/opengl/ExtensionsGLOpenGLES.cpp:
* platform/graphics/opengl/ExtensionsGLOpenGLES.h:
* platform/graphics/opengl/GraphicsContextGLOpenGL.cpp:
* platform/graphics/opengl/GraphicsContextGLOpenGL.h:
* platform/graphics/opengl/GraphicsContextGLOpenGLBase.cpp:
* platform/graphics/opengl/GraphicsContextGLOpenGLCommon.cpp:
* platform/graphics/opengl/GraphicsContextGLOpenGLES.cpp:
* platform/graphics/opengl/TemporaryOpenGLSetting.h:
* platform/graphics/texmap/GraphicsContextGLTextureMapper.cpp:
* platform/graphics/texmap/TextureMapperGL.cpp:

Source/WebKit:

* WebProcess/GPU/media/MediaPlayerPrivateRemote.cpp:
(WebKit::MediaPlayerPrivateRemote::copyVideoTextureToPlatformTexture):
* WebProcess/GPU/media/MediaPlayerPrivateRemote.h:

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

94 files changed:
Source/WebCore/ChangeLog
Source/WebCore/Headers.cmake
Source/WebCore/WebCore.xcodeproj/project.pbxproj
Source/WebCore/html/HTMLVideoElement.cpp
Source/WebCore/html/HTMLVideoElement.h
Source/WebCore/html/OffscreenCanvas.cpp
Source/WebCore/html/canvas/ANGLEInstancedArrays.cpp
Source/WebCore/html/canvas/ANGLEInstancedArrays.h
Source/WebCore/html/canvas/OESVertexArrayObject.cpp
Source/WebCore/html/canvas/OESVertexArrayObject.h
Source/WebCore/html/canvas/WebGL2RenderingContext.cpp
Source/WebCore/html/canvas/WebGL2RenderingContext.h
Source/WebCore/html/canvas/WebGLActiveInfo.h
Source/WebCore/html/canvas/WebGLBuffer.cpp
Source/WebCore/html/canvas/WebGLBuffer.h
Source/WebCore/html/canvas/WebGLDrawBuffers.cpp
Source/WebCore/html/canvas/WebGLDrawBuffers.h
Source/WebCore/html/canvas/WebGLFramebuffer.cpp
Source/WebCore/html/canvas/WebGLFramebuffer.h
Source/WebCore/html/canvas/WebGLObject.cpp
Source/WebCore/html/canvas/WebGLObject.h
Source/WebCore/html/canvas/WebGLProgram.cpp
Source/WebCore/html/canvas/WebGLProgram.h
Source/WebCore/html/canvas/WebGLQuery.cpp
Source/WebCore/html/canvas/WebGLQuery.h
Source/WebCore/html/canvas/WebGLRenderbuffer.cpp
Source/WebCore/html/canvas/WebGLRenderbuffer.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/WebGLSampler.cpp
Source/WebCore/html/canvas/WebGLSampler.h
Source/WebCore/html/canvas/WebGLShader.cpp
Source/WebCore/html/canvas/WebGLShader.h
Source/WebCore/html/canvas/WebGLShaderPrecisionFormat.cpp
Source/WebCore/html/canvas/WebGLShaderPrecisionFormat.h
Source/WebCore/html/canvas/WebGLSync.cpp
Source/WebCore/html/canvas/WebGLSync.h
Source/WebCore/html/canvas/WebGLTexture.cpp
Source/WebCore/html/canvas/WebGLTexture.h
Source/WebCore/html/canvas/WebGLTransformFeedback.cpp
Source/WebCore/html/canvas/WebGLTransformFeedback.h
Source/WebCore/html/canvas/WebGLUniformLocation.cpp
Source/WebCore/html/canvas/WebGLUniformLocation.h
Source/WebCore/html/canvas/WebGLVertexArrayObject.cpp
Source/WebCore/html/canvas/WebGLVertexArrayObject.h
Source/WebCore/html/canvas/WebGLVertexArrayObjectBase.cpp
Source/WebCore/html/canvas/WebGLVertexArrayObjectBase.h
Source/WebCore/html/canvas/WebGLVertexArrayObjectOES.cpp
Source/WebCore/html/canvas/WebGLVertexArrayObjectOES.h
Source/WebCore/platform/graphics/ExtensionsGL.h
Source/WebCore/platform/graphics/GraphicsContextGL.cpp
Source/WebCore/platform/graphics/GraphicsContextGL.h
Source/WebCore/platform/graphics/GraphicsTypesGL.h [moved from Source/WebCore/platform/graphics/GraphicsTypes3D.h with 67% similarity]
Source/WebCore/platform/graphics/ImageBuffer.cpp
Source/WebCore/platform/graphics/ImageBuffer.h
Source/WebCore/platform/graphics/MediaPlayer.cpp
Source/WebCore/platform/graphics/MediaPlayer.h
Source/WebCore/platform/graphics/MediaPlayerPrivate.h
Source/WebCore/platform/graphics/angle/ExtensionsGLANGLE.cpp
Source/WebCore/platform/graphics/angle/ExtensionsGLANGLE.h
Source/WebCore/platform/graphics/angle/GraphicsContextGLANGLE.cpp
Source/WebCore/platform/graphics/angle/TemporaryANGLESetting.h
Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h
Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm
Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h
Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm
Source/WebCore/platform/graphics/cairo/ImageBufferCairo.cpp
Source/WebCore/platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm
Source/WebCore/platform/graphics/cocoa/WebGLLayer.mm
Source/WebCore/platform/graphics/cv/TextureCacheCV.h
Source/WebCore/platform/graphics/cv/TextureCacheCV.mm
Source/WebCore/platform/graphics/cv/VideoTextureCopierCV.cpp
Source/WebCore/platform/graphics/cv/VideoTextureCopierCV.h
Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp
Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h
Source/WebCore/platform/graphics/opengl/ExtensionsGLOpenGL.cpp
Source/WebCore/platform/graphics/opengl/ExtensionsGLOpenGL.h
Source/WebCore/platform/graphics/opengl/ExtensionsGLOpenGLCommon.cpp
Source/WebCore/platform/graphics/opengl/ExtensionsGLOpenGLCommon.h
Source/WebCore/platform/graphics/opengl/ExtensionsGLOpenGLES.cpp
Source/WebCore/platform/graphics/opengl/ExtensionsGLOpenGLES.h
Source/WebCore/platform/graphics/opengl/GraphicsContextGLOpenGL.cpp
Source/WebCore/platform/graphics/opengl/GraphicsContextGLOpenGL.h
Source/WebCore/platform/graphics/opengl/GraphicsContextGLOpenGLBase.cpp
Source/WebCore/platform/graphics/opengl/GraphicsContextGLOpenGLCommon.cpp
Source/WebCore/platform/graphics/opengl/GraphicsContextGLOpenGLES.cpp
Source/WebCore/platform/graphics/opengl/TemporaryOpenGLSetting.h
Source/WebCore/platform/graphics/texmap/GraphicsContextGLTextureMapper.cpp
Source/WebCore/platform/graphics/texmap/TextureMapperGL.cpp
Source/WebKit/ChangeLog
Source/WebKit/WebProcess/GPU/media/MediaPlayerPrivateRemote.cpp
Source/WebKit/WebProcess/GPU/media/MediaPlayerPrivateRemote.h

index d4a04a3..43c4547 100644 (file)
@@ -1,3 +1,104 @@
+2020-01-08  Dean Jackson  <dino@apple.com>
+
+        [WebGL] More GraphicsContext3D to GraphicsContextGL renaming
+        https://bugs.webkit.org/show_bug.cgi?id=205949
+        <rdar://problem/58416989>
+
+        Reviewed by Antoine Quint.
+
+        Rename the GC3D-prefixed types.
+
+        * Headers.cmake:
+        * WebCore.xcodeproj/project.pbxproj:
+        * html/HTMLVideoElement.cpp:
+        * html/HTMLVideoElement.h:
+        * html/OffscreenCanvas.cpp:
+        * html/canvas/ANGLEInstancedArrays.cpp:
+        * html/canvas/ANGLEInstancedArrays.h:
+        * html/canvas/OESVertexArrayObject.cpp:
+        * html/canvas/OESVertexArrayObject.h:
+        * html/canvas/WebGL2RenderingContext.cpp:
+        * html/canvas/WebGL2RenderingContext.h:
+        * html/canvas/WebGLActiveInfo.h:
+        * html/canvas/WebGLBuffer.cpp:
+        * html/canvas/WebGLBuffer.h:
+        * html/canvas/WebGLDrawBuffers.cpp:
+        * html/canvas/WebGLDrawBuffers.h:
+        * html/canvas/WebGLFramebuffer.cpp:
+        * html/canvas/WebGLFramebuffer.h:
+        * html/canvas/WebGLObject.cpp:
+        * html/canvas/WebGLObject.h:
+        * html/canvas/WebGLProgram.cpp:
+        * html/canvas/WebGLProgram.h:
+        * html/canvas/WebGLQuery.cpp:
+        * html/canvas/WebGLQuery.h:
+        * html/canvas/WebGLRenderbuffer.cpp:
+        * html/canvas/WebGLRenderbuffer.h:
+        * html/canvas/WebGLRenderingContext.cpp:
+        * html/canvas/WebGLRenderingContext.h:
+        * html/canvas/WebGLRenderingContextBase.cpp:
+        * html/canvas/WebGLRenderingContextBase.h:
+        * html/canvas/WebGLSampler.cpp:
+        * html/canvas/WebGLSampler.h:
+        * html/canvas/WebGLShader.cpp:
+        * html/canvas/WebGLShader.h:
+        * html/canvas/WebGLShaderPrecisionFormat.cpp:
+        * html/canvas/WebGLShaderPrecisionFormat.h:
+        * html/canvas/WebGLSync.cpp:
+        * html/canvas/WebGLSync.h:
+        * html/canvas/WebGLTexture.cpp:
+        * html/canvas/WebGLTexture.h:
+        * html/canvas/WebGLTransformFeedback.cpp:
+        * html/canvas/WebGLTransformFeedback.h:
+        * html/canvas/WebGLUniformLocation.cpp:
+        * html/canvas/WebGLUniformLocation.h:
+        * html/canvas/WebGLVertexArrayObject.cpp:
+        * html/canvas/WebGLVertexArrayObject.h:
+        * html/canvas/WebGLVertexArrayObjectBase.cpp:
+        * html/canvas/WebGLVertexArrayObjectBase.h:
+        * html/canvas/WebGLVertexArrayObjectOES.cpp:
+        * html/canvas/WebGLVertexArrayObjectOES.h:
+        * platform/graphics/ExtensionsGL.h:
+        * platform/graphics/GraphicsContextGL.cpp:
+        * platform/graphics/GraphicsContextGL.h:
+        * platform/graphics/GraphicsTypesGL.h: Renamed from Source/WebCore/platform/graphics/GraphicsTypes3D.h.
+        * platform/graphics/ImageBuffer.cpp:
+        * platform/graphics/ImageBuffer.h:
+        * platform/graphics/MediaPlayer.cpp:
+        * platform/graphics/MediaPlayer.h:
+        * platform/graphics/MediaPlayerPrivate.h:
+        * platform/graphics/angle/ExtensionsGLANGLE.cpp:
+        * platform/graphics/angle/ExtensionsGLANGLE.h:
+        * platform/graphics/angle/GraphicsContextGLANGLE.cpp:
+        * platform/graphics/angle/TemporaryANGLESetting.h:
+        * platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h:
+        * platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm:
+        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h:
+        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm:
+        * platform/graphics/cairo/ImageBufferCairo.cpp:
+        * platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm:
+        * platform/graphics/cocoa/WebGLLayer.mm:
+        * platform/graphics/cv/TextureCacheCV.h:
+        * platform/graphics/cv/TextureCacheCV.mm:
+        * platform/graphics/cv/VideoTextureCopierCV.cpp:
+        * platform/graphics/cv/VideoTextureCopierCV.h:
+        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:
+        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h:
+        * platform/graphics/opengl/ExtensionsGLOpenGL.cpp:
+        * platform/graphics/opengl/ExtensionsGLOpenGL.h:
+        * platform/graphics/opengl/ExtensionsGLOpenGLCommon.cpp:
+        * platform/graphics/opengl/ExtensionsGLOpenGLCommon.h:
+        * platform/graphics/opengl/ExtensionsGLOpenGLES.cpp:
+        * platform/graphics/opengl/ExtensionsGLOpenGLES.h:
+        * platform/graphics/opengl/GraphicsContextGLOpenGL.cpp:
+        * platform/graphics/opengl/GraphicsContextGLOpenGL.h:
+        * platform/graphics/opengl/GraphicsContextGLOpenGLBase.cpp:
+        * platform/graphics/opengl/GraphicsContextGLOpenGLCommon.cpp:
+        * platform/graphics/opengl/GraphicsContextGLOpenGLES.cpp:
+        * platform/graphics/opengl/TemporaryOpenGLSetting.h:
+        * platform/graphics/texmap/GraphicsContextGLTextureMapper.cpp:
+        * platform/graphics/texmap/TextureMapperGL.cpp:
+
 2020-01-08  Peng Liu  <peng.liu6@apple.com>
 
         After playing a video and making it full screen, the video exits full screen and stops but the audio continues to play
index 812ed46..296dea7 100644 (file)
@@ -1068,7 +1068,7 @@ set(WebCore_PRIVATE_FRAMEWORK_HEADERS
     platform/graphics/GraphicsLayerTransform.h
     platform/graphics/GraphicsLayerUpdater.h
     platform/graphics/GraphicsTypes.h
-    platform/graphics/GraphicsTypes3D.h
+    platform/graphics/GraphicsTypesGL.h
     platform/graphics/Icon.h
     platform/graphics/Image.h
     platform/graphics/ImageBackingStore.h
index 4514af6..6e28b57 100644 (file)
                7779BD961F32246A00C21417 /* JSVisualViewport.h in Headers */ = {isa = PBXBuildFile; fileRef = 7779BD921F2FDBF700C21417 /* JSVisualViewport.h */; };
                77A17A7212F28182004E02F6 /* OESVertexArrayObject.h in Headers */ = {isa = PBXBuildFile; fileRef = 77A17A6F12F28182004E02F6 /* OESVertexArrayObject.h */; };
                77A17A7812F28642004E02F6 /* WebGLVertexArrayObjectOES.h in Headers */ = {isa = PBXBuildFile; fileRef = 77A17A7512F28642004E02F6 /* WebGLVertexArrayObjectOES.h */; };
-               77A17A7B12F2890B004E02F6 /* GraphicsTypes3D.h in Headers */ = {isa = PBXBuildFile; fileRef = 77A17A7A12F2890B004E02F6 /* GraphicsTypes3D.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               77A17A7B12F2890B004E02F6 /* GraphicsTypesGL.h in Headers */ = {isa = PBXBuildFile; fileRef = 77A17A7A12F2890B004E02F6 /* GraphicsTypesGL.h */; settings = {ATTRIBUTES = (Private, ); }; };
                77A17AA712F28B2A004E02F6 /* JSOESVertexArrayObject.h in Headers */ = {isa = PBXBuildFile; fileRef = 77A17AA312F28B2A004E02F6 /* JSOESVertexArrayObject.h */; };
                77D510041ED4F71E00DA4C87 /* JSCredentialRequestOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 77D50FFF1ED4F70C00DA4C87 /* JSCredentialRequestOptions.h */; };
                77D510061ED4F72500DA4C87 /* JSCredentialCreationOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 77D50FFD1ED4F70C00DA4C87 /* JSCredentialCreationOptions.h */; };
                77A17A7412F28642004E02F6 /* WebGLVertexArrayObjectOES.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebGLVertexArrayObjectOES.cpp; sourceTree = "<group>"; };
                77A17A7512F28642004E02F6 /* WebGLVertexArrayObjectOES.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebGLVertexArrayObjectOES.h; sourceTree = "<group>"; };
                77A17A7612F28642004E02F6 /* WebGLVertexArrayObjectOES.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebGLVertexArrayObjectOES.idl; sourceTree = "<group>"; };
-               77A17A7A12F2890B004E02F6 /* GraphicsTypes3D.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GraphicsTypes3D.h; sourceTree = "<group>"; };
+               77A17A7A12F2890B004E02F6 /* GraphicsTypesGL.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GraphicsTypesGL.h; sourceTree = "<group>"; };
                77A17AA212F28B2A004E02F6 /* JSOESVertexArrayObject.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSOESVertexArrayObject.cpp; sourceTree = "<group>"; };
                77A17AA312F28B2A004E02F6 /* JSOESVertexArrayObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSOESVertexArrayObject.h; sourceTree = "<group>"; };
                77AAD6831ECFB66200BFA2D1 /* CredentialCreationOptions.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = CredentialCreationOptions.idl; sourceTree = "<group>"; };
                                0FA24D78162DF91900A3F4C0 /* GraphicsLayerUpdater.h */,
                                B2A015940AF6CD53006BCE0E /* GraphicsTypes.cpp */,
                                B2A015950AF6CD53006BCE0E /* GraphicsTypes.h */,
-                               77A17A7A12F2890B004E02F6 /* GraphicsTypes3D.h */,
+                               77A17A7A12F2890B004E02F6 /* GraphicsTypesGL.h */,
                                CDA595922146DEC300A84185 /* HEVCUtilities.cpp */,
                                CDA595912146DEC300A84185 /* HEVCUtilities.h */,
                                B27535400B053814002CE64F /* Icon.h */,
                                1AC69593161A1E53003732CB /* GraphicsLayerFactory.h in Headers */,
                                0FA24D7A162DF91900A3F4C0 /* GraphicsLayerUpdater.h in Headers */,
                                B2A015AB0AF6CD53006BCE0E /* GraphicsTypes.h in Headers */,
-                               77A17A7B12F2890B004E02F6 /* GraphicsTypes3D.h in Headers */,
+                               77A17A7B12F2890B004E02F6 /* GraphicsTypesGL.h in Headers */,
                                E112F4721E3A861600D6CDFD /* Grid.h in Headers */,
                                CD3E251C18046B0600E27F56 /* GridArea.h in Headers */,
                                CDEF4FD717E85C8F00AEE24B /* GridLength.h in Headers */,
index cc93ada..9efa73a 100644 (file)
@@ -294,7 +294,7 @@ void HTMLVideoElement::paintCurrentFrameInContext(GraphicsContext& context, cons
     player->paintCurrentFrameInContext(context, destRect);
 }
 
-bool HTMLVideoElement::copyVideoTextureToPlatformTexture(GraphicsContextGLOpenGL* context, Platform3DObject texture, GC3Denum target, GC3Dint level, GC3Denum internalFormat, GC3Denum format, GC3Denum type, bool premultiplyAlpha, bool flipY)
+bool HTMLVideoElement::copyVideoTextureToPlatformTexture(GraphicsContextGLOpenGL* context, PlatformGLObject texture, GCGLenum target, GCGLint level, GCGLenum internalFormat, GCGLenum format, GCGLenum type, bool premultiplyAlpha, bool flipY)
 {
     if (!player())
         return false;
index 4c88208..bbfcb99 100644 (file)
@@ -74,7 +74,7 @@ public:
 
     // Used by WebGL to do GPU-GPU textures copy if possible.
     // See more details at MediaPlayer::copyVideoTextureToPlatformTexture() defined in Source/WebCore/platform/graphics/MediaPlayer.h.
-    bool copyVideoTextureToPlatformTexture(GraphicsContextGLOpenGL*, Platform3DObject texture, GC3Denum target, GC3Dint level, GC3Denum internalFormat, GC3Denum format, GC3Denum type, bool premultiplyAlpha, bool flipY);
+    bool copyVideoTextureToPlatformTexture(GraphicsContextGLOpenGL*, PlatformGLObject texture, GCGLenum target, GCGLint level, GCGLenum internalFormat, GCGLenum format, GCGLenum type, bool premultiplyAlpha, bool flipY);
 
     bool shouldDisplayPosterImage() const { return displayMode() == Poster || displayMode() == PosterWaitingForVideo; }
 
index 091a369..f744851 100644 (file)
@@ -154,7 +154,7 @@ ExceptionOr<RefPtr<ImageBitmap>> OffscreenCanvas::transferToImageBitmap()
         // creates a new backing store. Since we're not doing that yet, we
         // need to erase what's there.
 
-        GC3Dfloat clearColor[4];
+        GCGLfloat clearColor[4];
         gc3d->getFloatv(GraphicsContextGL::COLOR_CLEAR_VALUE, clearColor);
         gc3d->clearColor(0, 0, 0, 0);
         gc3d->clear(GraphicsContextGL::COLOR_BUFFER_BIT | GraphicsContextGL::DEPTH_BUFFER_BIT | GraphicsContextGL::STENCIL_BUFFER_BIT);
index 8d74e40..3d57013 100644 (file)
@@ -66,21 +66,21 @@ bool ANGLEInstancedArrays::supported(WebGLRenderingContextBase& context)
 #endif
 }
 
-void ANGLEInstancedArrays::drawArraysInstancedANGLE(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount)
+void ANGLEInstancedArrays::drawArraysInstancedANGLE(GCGLenum mode, GCGLint first, GCGLsizei count, GCGLsizei primcount)
 {
     if (m_context.isContextLost())
         return;
     m_context.drawArraysInstanced(mode, first, count, primcount);
 }
 
-void ANGLEInstancedArrays::drawElementsInstancedANGLE(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, GC3Dsizei primcount)
+void ANGLEInstancedArrays::drawElementsInstancedANGLE(GCGLenum mode, GCGLsizei count, GCGLenum type, long long offset, GCGLsizei primcount)
 {
     if (m_context.isContextLost())
         return;
     m_context.drawElementsInstanced(mode, count, type, offset, primcount);
 }
 
-void ANGLEInstancedArrays::vertexAttribDivisorANGLE(GC3Duint index, GC3Duint divisor)
+void ANGLEInstancedArrays::vertexAttribDivisorANGLE(GCGLuint index, GCGLuint divisor)
 {
     if (m_context.isContextLost())
         return;
index d413827..8370914 100644 (file)
@@ -40,9 +40,9 @@ public:
 
     static bool supported(WebGLRenderingContextBase&);
 
-    void drawArraysInstancedANGLE(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount);
-    void drawElementsInstancedANGLE(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, GC3Dsizei primcount);
-    void vertexAttribDivisorANGLE(GC3Duint index, GC3Duint divisor);
+    void drawArraysInstancedANGLE(GCGLenum mode, GCGLint first, GCGLsizei count, GCGLsizei primcount);
+    void drawElementsInstancedANGLE(GCGLenum mode, GCGLsizei count, GCGLenum type, long long offset, GCGLsizei primcount);
+    void vertexAttribDivisorANGLE(GCGLuint index, GCGLuint divisor);
 };
 
 } // namespace WebCore
index 410cea5..76c6120 100644 (file)
@@ -64,7 +64,7 @@ void OESVertexArrayObject::deleteVertexArrayOES(WebGLVertexArrayObjectOES* array
     arrayObject->deleteObject(m_context.graphicsContextGL());
 }
 
-GC3Dboolean OESVertexArrayObject::isVertexArrayOES(WebGLVertexArrayObjectOES* arrayObject)
+GCGLboolean OESVertexArrayObject::isVertexArrayOES(WebGLVertexArrayObjectOES* arrayObject)
 {
     return arrayObject && !m_context.isContextLost() && arrayObject->hasEverBeenBound()
         && m_context.graphicsContextGL()->getExtensions().isVertexArrayOES(arrayObject->object());
index 3564b3b..9508e6a 100644 (file)
@@ -27,7 +27,7 @@
 
 #if ENABLE(WEBGL)
 
-#include "GraphicsTypes3D.h"
+#include "GraphicsTypesGL.h"
 #include "WebGLExtension.h"
 
 namespace WebCore {
@@ -41,7 +41,7 @@ public:
 
     RefPtr<WebGLVertexArrayObjectOES> createVertexArrayOES();
     void deleteVertexArrayOES(WebGLVertexArrayObjectOES*);
-    GC3Dboolean isVertexArrayOES(WebGLVertexArrayObjectOES*);
+    GCGLboolean isVertexArrayOES(WebGLVertexArrayObjectOES*);
     void bindVertexArrayOES(WebGLVertexArrayObjectOES*);
 
 private:
index 825e75a..bae9b4b 100644 (file)
@@ -138,7 +138,7 @@ inline static Optional<unsigned> arrayBufferViewElementSize(const ArrayBufferVie
     RELEASE_ASSERT_NOT_REACHED();
 }
 
-void WebGL2RenderingContext::bufferData(GC3Denum target, const ArrayBufferView& data, GC3Denum usage, GC3Duint srcOffset, GC3Duint length)
+void WebGL2RenderingContext::bufferData(GCGLenum target, const ArrayBufferView& data, GCGLenum usage, GCGLuint srcOffset, GCGLuint length)
 {
     auto optionalElementSize = arrayBufferViewElementSize(data);
     if (!optionalElementSize) {
@@ -146,12 +146,12 @@ void WebGL2RenderingContext::bufferData(GC3Denum target, const ArrayBufferView&
         return;
     }
     auto elementSize = optionalElementSize.value();
-    Checked<GC3Duint, RecordOverflow> checkedElementSize(elementSize);
+    Checked<GCGLuint, RecordOverflow> checkedElementSize(elementSize);
 
-    Checked<GC3Duint, RecordOverflow> checkedSrcOffset(srcOffset);
-    Checked<GC3Duint, RecordOverflow> checkedByteSrcOffset = checkedSrcOffset * checkedElementSize;
-    Checked<GC3Duint, RecordOverflow> checkedlength(length);
-    Checked<GC3Duint, RecordOverflow> checkedByteLength = checkedlength * checkedElementSize;
+    Checked<GCGLuint, RecordOverflow> checkedSrcOffset(srcOffset);
+    Checked<GCGLuint, RecordOverflow> checkedByteSrcOffset = checkedSrcOffset * checkedElementSize;
+    Checked<GCGLuint, RecordOverflow> checkedlength(length);
+    Checked<GCGLuint, RecordOverflow> checkedByteLength = checkedlength * checkedElementSize;
 
     if (checkedByteSrcOffset.hasOverflowed()
         || checkedByteLength.hasOverflowed()
@@ -169,7 +169,7 @@ void WebGL2RenderingContext::bufferData(GC3Denum target, const ArrayBufferView&
     WebGLRenderingContextBase::bufferData(target, BufferDataSource(slice.get()), usage);
 }
 
-void WebGL2RenderingContext::bufferSubData(GC3Denum target, long long offset, const ArrayBufferView& data, GC3Duint srcOffset, GC3Duint length)
+void WebGL2RenderingContext::bufferSubData(GCGLenum target, long long offset, const ArrayBufferView& data, GCGLuint srcOffset, GCGLuint length)
 {
     auto optionalElementSize = arrayBufferViewElementSize(data);
     if (!optionalElementSize) {
@@ -177,12 +177,12 @@ void WebGL2RenderingContext::bufferSubData(GC3Denum target, long long offset, co
         return;
     }
     auto elementSize = optionalElementSize.value();
-    Checked<GC3Duint, RecordOverflow> checkedElementSize(elementSize);
+    Checked<GCGLuint, RecordOverflow> checkedElementSize(elementSize);
 
-    Checked<GC3Duint, RecordOverflow> checkedSrcOffset(srcOffset);
-    Checked<GC3Duint, RecordOverflow> checkedByteSrcOffset = checkedSrcOffset * checkedElementSize;
-    Checked<GC3Duint, RecordOverflow> checkedlength(length);
-    Checked<GC3Duint, RecordOverflow> checkedByteLength = checkedlength * checkedElementSize;
+    Checked<GCGLuint, RecordOverflow> checkedSrcOffset(srcOffset);
+    Checked<GCGLuint, RecordOverflow> checkedByteSrcOffset = checkedSrcOffset * checkedElementSize;
+    Checked<GCGLuint, RecordOverflow> checkedlength(length);
+    Checked<GCGLuint, RecordOverflow> checkedByteLength = checkedlength * checkedElementSize;
 
     if (checkedByteSrcOffset.hasOverflowed()
         || checkedByteLength.hasOverflowed()
@@ -201,7 +201,7 @@ void WebGL2RenderingContext::bufferSubData(GC3Denum target, long long offset, co
     WebGLRenderingContextBase::bufferSubData(target, offset, BufferDataSource(slice.get()));
 }
 
-void WebGL2RenderingContext::copyBufferSubData(GC3Denum readTarget, GC3Denum writeTarget, GC3Dint64 readOffset, GC3Dint64 writeOffset, GC3Dint64 size)
+void WebGL2RenderingContext::copyBufferSubData(GCGLenum readTarget, GCGLenum writeTarget, GCGLint64 readOffset, GCGLint64 writeOffset, GCGLint64 size)
 {
     if (isContextLostOrPending())
         return;
@@ -221,9 +221,9 @@ void WebGL2RenderingContext::copyBufferSubData(GC3Denum readTarget, GC3Denum wri
         return;
     }
 
-    Checked<GC3Dintptr, RecordOverflow> checkedReadOffset(readOffset);
-    Checked<GC3Dintptr, RecordOverflow> checkedWriteOffset(writeOffset);
-    Checked<GC3Dsizeiptr, RecordOverflow> checkedSize(size);
+    Checked<GCGLintptr, RecordOverflow> checkedReadOffset(readOffset);
+    Checked<GCGLintptr, RecordOverflow> checkedWriteOffset(writeOffset);
+    Checked<GCGLsizeiptr, RecordOverflow> checkedSize(size);
     if (checkedReadOffset.hasOverflowed() || checkedWriteOffset.hasOverflowed() || checkedSize.hasOverflowed()) {
         synthesizeGLError(GraphicsContextGL::INVALID_VALUE, "copyBufferSubData", "Offset or size is too big");
         return;
@@ -244,7 +244,7 @@ void WebGL2RenderingContext::copyBufferSubData(GC3Denum readTarget, GC3Denum wri
     }
 }
 
-void WebGL2RenderingContext::getBufferSubData(GC3Denum target, long long srcByteOffset, RefPtr<ArrayBufferView>&& dstData, GC3Duint dstOffset, GC3Duint length)
+void WebGL2RenderingContext::getBufferSubData(GCGLenum target, long long srcByteOffset, RefPtr<ArrayBufferView>&& dstData, GCGLuint dstOffset, GCGLuint length)
 {
     if (isContextLostOrPending())
         return;
@@ -274,10 +274,10 @@ void WebGL2RenderingContext::getBufferSubData(GC3Denum target, long long srcByte
         return;
     }
 
-    GC3Duint copyLength = length ? length : dstDataLength - dstOffset;
+    GCGLuint copyLength = length ? length : dstDataLength - dstOffset;
 
-    Checked<GC3Duint, RecordOverflow> checkedDstOffset(dstOffset);
-    Checked<GC3Duint, RecordOverflow> checkedCopyLength(copyLength);
+    Checked<GCGLuint, RecordOverflow> checkedDstOffset(dstOffset);
+    Checked<GCGLuint, RecordOverflow> checkedCopyLength(copyLength);
     auto checkedDestinationEnd = checkedDstOffset + checkedCopyLength;
     if (checkedDestinationEnd.hasOverflowed()) {
         synthesizeGLError(GraphicsContextGL::INVALID_OPERATION, "getBufferSubData", "dstOffset + copyLength is too high");
@@ -294,9 +294,9 @@ void WebGL2RenderingContext::getBufferSubData(GC3Denum target, long long srcByte
         return;
     }
 
-    Checked<GC3Dintptr, RecordOverflow> checkedSrcByteOffset(srcByteOffset);
-    Checked<GC3Dintptr, RecordOverflow> checkedCopyLengthPtr(copyLength);
-    Checked<GC3Dintptr, RecordOverflow> checkedElementSize(elementSize);
+    Checked<GCGLintptr, RecordOverflow> checkedSrcByteOffset(srcByteOffset);
+    Checked<GCGLintptr, RecordOverflow> checkedCopyLengthPtr(copyLength);
+    Checked<GCGLintptr, RecordOverflow> checkedElementSize(elementSize);
     auto checkedSourceEnd = checkedSrcByteOffset + checkedCopyLengthPtr * checkedElementSize;
     if (checkedSourceEnd.hasOverflowed() || checkedSourceEnd.unsafeGet() > buffer->byteLength()) {
         synthesizeGLError(GraphicsContextGL::INVALID_OPERATION, "getBufferSubData", "Parameters would read outside the bounds of the source buffer");
@@ -306,7 +306,7 @@ void WebGL2RenderingContext::getBufferSubData(GC3Denum target, long long srcByte
     m_context->moveErrorsToSyntheticErrorList();
 #if PLATFORM(COCOA)
     // FIXME: Coalesce multiple getBufferSubData() calls to use a single map() call
-    void* ptr = m_context->mapBufferRange(target, checkedSrcByteOffset.unsafeGet(), static_cast<GC3Dsizeiptr>(checkedCopyLengthPtr.unsafeGet() * checkedElementSize.unsafeGet()), GraphicsContextGL::MAP_READ_BIT);
+    void* ptr = m_context->mapBufferRange(target, checkedSrcByteOffset.unsafeGet(), static_cast<GCGLsizeiptr>(checkedCopyLengthPtr.unsafeGet() * checkedElementSize.unsafeGet()), GraphicsContextGL::MAP_READ_BIT);
     memcpy(static_cast<char*>(dstData->baseAddress()) + dstData->byteOffset() + dstOffset * elementSize, ptr, copyLength * elementSize);
     if (!m_context->unmapBuffer(target))
         synthesizeGLError(GraphicsContextGL::INVALID_OPERATION, "getBufferSubData", "Failed while unmapping buffer");
@@ -314,18 +314,18 @@ void WebGL2RenderingContext::getBufferSubData(GC3Denum target, long long srcByte
     m_context->moveErrorsToSyntheticErrorList();
 }
 
-void WebGL2RenderingContext::blitFramebuffer(GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dbitfield, GC3Denum)
+void WebGL2RenderingContext::blitFramebuffer(GCGLint, GCGLint, GCGLint, GCGLint, GCGLint, GCGLint, GCGLint, GCGLint, GCGLbitfield, GCGLenum)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] blitFramebuffer()");
 }
 
-void WebGL2RenderingContext::framebufferTextureLayer(GC3Denum, GC3Denum, WebGLTexture*, GC3Dint, GC3Dint)
+void WebGL2RenderingContext::framebufferTextureLayer(GCGLenum, GCGLenum, WebGLTexture*, GCGLint, GCGLint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] framebufferTextureLayer()");
 }
 
 #if !USE(OPENGL_ES)
-static bool isRenderableInternalformat(GC3Denum internalformat)
+static bool isRenderableInternalformat(GCGLenum internalformat)
 {
     // OpenGL ES 3: internalformat must be a color-renderable, depth-renderable, or stencil-renderable format, as shown in Table 1 below.
     switch (internalformat) {
@@ -368,7 +368,7 @@ static bool isRenderableInternalformat(GC3Denum internalformat)
 }
 #endif
 
-WebGLAny WebGL2RenderingContext::getInternalformatParameter(GC3Denum target, GC3Denum internalformat, GC3Denum pname)
+WebGLAny WebGL2RenderingContext::getInternalformatParameter(GCGLenum target, GCGLenum internalformat, GCGLenum pname)
 {
     if (isContextLostOrPending())
         return nullptr;
@@ -382,7 +382,7 @@ WebGLAny WebGL2RenderingContext::getInternalformatParameter(GC3Denum target, GC3
 #if USE(OPENGL_ES)
     m_context->getInternalformativ(target, internalformat, GraphicsContextGL::NUM_SAMPLE_COUNTS, 1, &numValues);
 
-    GC3Dint params[numValues];
+    GCGLint params[numValues];
     m_context->getInternalformativ(target, internalformat, pname, numValues, params);
 #else
     // On desktop OpenGL 4.1 or below we must emulate glGetInternalformativ.
@@ -399,7 +399,7 @@ WebGLAny WebGL2RenderingContext::getInternalformatParameter(GC3Denum target, GC3
         return nullptr;
     }
 
-    Vector<GC3Dint> samples;
+    Vector<GCGLint> samples;
     // The way I understand this is that this will return a MINIMUM numSamples for all accepeted internalformats.
     // However, the true value of this on supported GL versions is gleaned via a getInternalformativ call that depends on internalformat.
     int numSamplesMask = getIntParameter(GraphicsContextGL::MAX_SAMPLES);
@@ -412,7 +412,7 @@ WebGLAny WebGL2RenderingContext::getInternalformatParameter(GC3Denum target, GC3
     // Since multisampling is not supported for signed and unsigned integer internal formats,
     // the value of GL_NUM_SAMPLE_COUNTS will be zero for such formats.
     numValues = isIntegerFormat(internalformat) ? 0 : samples.size();
-    GC3Dint params[numValues];
+    GCGLint params[numValues];
     for (size_t i = 0; i < samples.size(); ++i)
         params[i] = samples[i];
 #endif
@@ -420,22 +420,22 @@ WebGLAny WebGL2RenderingContext::getInternalformatParameter(GC3Denum target, GC3
     return Int32Array::tryCreate(params, numValues);
 }
 
-void WebGL2RenderingContext::invalidateFramebuffer(GC3Denum, const Vector<GC3Denum>&)
+void WebGL2RenderingContext::invalidateFramebuffer(GCGLenum, const Vector<GCGLenum>&)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] invalidateFramebuffer()");
 }
 
-void WebGL2RenderingContext::invalidateSubFramebuffer(GC3Denum, const Vector<GC3Denum>&, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei)
+void WebGL2RenderingContext::invalidateSubFramebuffer(GCGLenum, const Vector<GCGLenum>&, GCGLint, GCGLint, GCGLsizei, GCGLsizei)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] invalidateSubFramebuffer()");
 }
 
-void WebGL2RenderingContext::readBuffer(GC3Denum)
+void WebGL2RenderingContext::readBuffer(GCGLenum)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] readBuffer()");
 }
 
-void WebGL2RenderingContext::renderbufferStorageMultisample(GC3Denum target, GC3Dsizei samples, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height)
+void WebGL2RenderingContext::renderbufferStorageMultisample(GCGLenum target, GCGLsizei samples, GCGLenum internalformat, GCGLsizei width, GCGLsizei height)
 {
     // To be backward compatible with WebGL 1, also accepts internal format DEPTH_STENCIL,
     // which should be mapped to DEPTH24_STENCIL8 by implementations.
@@ -504,7 +504,7 @@ void WebGL2RenderingContext::renderbufferStorageMultisample(GC3Denum target, GC3
     applyStencilTest();
 }
 
-bool WebGL2RenderingContext::validateTexStorageFuncParameters(GC3Denum target, GC3Dsizei levels, GC3Denum internalFormat, GC3Dsizei width, GC3Dsizei height, const char* functionName)
+bool WebGL2RenderingContext::validateTexStorageFuncParameters(GCGLenum target, GCGLsizei levels, GCGLenum internalFormat, GCGLsizei width, GCGLsizei height, const char* functionName)
 {
     if (width < 0 || height < 0) {
         synthesizeGLError(GraphicsContextGL::INVALID_VALUE, functionName, "width or height < 0");
@@ -595,7 +595,7 @@ bool WebGL2RenderingContext::validateTexStorageFuncParameters(GC3Denum target, G
     return true;
 }
 
-void WebGL2RenderingContext::texStorage2D(GC3Denum target, GC3Dsizei levels, GC3Denum internalFormat, GC3Dsizei width, GC3Dsizei height)
+void WebGL2RenderingContext::texStorage2D(GCGLenum target, GCGLsizei levels, GCGLenum internalFormat, GCGLsizei width, GCGLsizei height)
 {
     if (isContextLostOrPending())
         return;
@@ -619,18 +619,18 @@ void WebGL2RenderingContext::texStorage2D(GC3Denum target, GC3Dsizei levels, GC3
     m_context->texStorage2D(target, levels, internalFormat, width, height);
 
     {
-        GC3Denum format;
-        GC3Denum type;
+        GCGLenum format;
+        GCGLenum type;
         if (!GraphicsContextGLOpenGL::possibleFormatAndTypeForInternalFormat(internalFormat, format, type)) {
             synthesizeGLError(GraphicsContextGL::INVALID_ENUM, "texStorage2D", "Texture has unknown internal format");
             return;
         }
 
-        GC3Dsizei levelWidth = width;
-        GC3Dsizei levelHeight = height;
+        GCGLsizei levelWidth = width;
+        GCGLsizei levelHeight = height;
 
         unsigned size;
-        GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_unpackAlignment, &size, nullptr);
+        GCGLenum error = m_context->computeImageSizeInBytes(format, type, width, height, m_unpackAlignment, &size, nullptr);
         if (error != GraphicsContextGL::NO_ERROR) {
             synthesizeGLError(error, "texStorage2D", "bad dimensions");
             return;
@@ -639,7 +639,7 @@ void WebGL2RenderingContext::texStorage2D(GC3Denum target, GC3Dsizei levels, GC3
         Vector<char> data(size);
         memset(data.data(), 0, size);
 
-        for (GC3Dsizei level = 0; level < levels; ++level) {
+        for (GCGLsizei level = 0; level < levels; ++level) {
             if (target == GraphicsContextGL::TEXTURE_CUBE_MAP) {
                 m_context->texSubImage2D(GraphicsContextGL::TEXTURE_CUBE_MAP_POSITIVE_X, level, 0, 0, levelWidth, levelHeight, format, type, data.data());
                 m_context->texSubImage2D(GraphicsContextGL::TEXTURE_CUBE_MAP_NEGATIVE_X, level, 0, 0, levelWidth, levelHeight, format, type, data.data());
@@ -654,7 +654,7 @@ void WebGL2RenderingContext::texStorage2D(GC3Denum target, GC3Dsizei levels, GC3
         }
     }
 
-    for (GC3Dsizei level = 0; level < levels; ++level) {
+    for (GCGLsizei level = 0; level < levels; ++level) {
         if (target == GraphicsContextGL::TEXTURE_CUBE_MAP) {
             texture->setLevelInfo(GraphicsContextGL::TEXTURE_CUBE_MAP_POSITIVE_X, level, internalFormat, width, height, GraphicsContextGL::UNSIGNED_BYTE);
             texture->setLevelInfo(GraphicsContextGL::TEXTURE_CUBE_MAP_NEGATIVE_X, level, internalFormat, width, height, GraphicsContextGL::UNSIGNED_BYTE);
@@ -667,207 +667,207 @@ void WebGL2RenderingContext::texStorage2D(GC3Denum target, GC3Dsizei levels, GC3
     }
 }
 
-void WebGL2RenderingContext::texStorage3D(GC3Denum, GC3Dsizei, GC3Denum, GC3Dsizei, GC3Dsizei, GC3Dsizei)
+void WebGL2RenderingContext::texStorage3D(GCGLenum, GCGLsizei, GCGLenum, GCGLsizei, GCGLsizei, GCGLsizei)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] texStorage3D()");
 }
 
-void WebGL2RenderingContext::texImage2D(GC3Denum, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Dint, GC3Denum, GC3Denum, GC3Dint64)
+void WebGL2RenderingContext::texImage2D(GCGLenum, GCGLint, GCGLint, GCGLsizei, GCGLsizei, GCGLint, GCGLenum, GCGLenum, GCGLint64)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] texImage2D()");
 }
 
-ExceptionOr<void> WebGL2RenderingContext::texImage2D(GC3Denum, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Dint, GC3Denum, GC3Denum, TexImageSource&&)
+ExceptionOr<void> WebGL2RenderingContext::texImage2D(GCGLenum, GCGLint, GCGLint, GCGLsizei, GCGLsizei, GCGLint, GCGLenum, GCGLenum, TexImageSource&&)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] texImage2D()");
     return { };
 }
 
-void WebGL2RenderingContext::texImage2D(GC3Denum, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Dint, GC3Denum, GC3Denum, RefPtr<ArrayBufferView>&&, GC3Duint)
+void WebGL2RenderingContext::texImage2D(GCGLenum, GCGLint, GCGLint, GCGLsizei, GCGLsizei, GCGLint, GCGLenum, GCGLenum, RefPtr<ArrayBufferView>&&, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] texImage2D()");
 }
 
-void WebGL2RenderingContext::texImage3D(GC3Denum, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Dsizei, GC3Dint, GC3Denum, GC3Denum, GC3Dint64)
+void WebGL2RenderingContext::texImage3D(GCGLenum, GCGLint, GCGLint, GCGLsizei, GCGLsizei, GCGLsizei, GCGLint, GCGLenum, GCGLenum, GCGLint64)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] texImage3D()");
 }
 
-ExceptionOr<void> WebGL2RenderingContext::texImage3D(GC3Denum, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Dsizei, GC3Dint, GC3Denum, GC3Denum, TexImageSource&&)
+ExceptionOr<void> WebGL2RenderingContext::texImage3D(GCGLenum, GCGLint, GCGLint, GCGLsizei, GCGLsizei, GCGLsizei, GCGLint, GCGLenum, GCGLenum, TexImageSource&&)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] texImage3D()");
     return { };
 }
 
-void WebGL2RenderingContext::texImage3D(GC3Denum, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Dsizei, GC3Dint, GC3Denum, GC3Denum, RefPtr<ArrayBufferView>&&)
+void WebGL2RenderingContext::texImage3D(GCGLenum, GCGLint, GCGLint, GCGLsizei, GCGLsizei, GCGLsizei, GCGLint, GCGLenum, GCGLenum, RefPtr<ArrayBufferView>&&)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] texImage3D()");
 }
 
-void WebGL2RenderingContext::texImage3D(GC3Denum, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Dsizei, GC3Dint, GC3Denum, GC3Denum, RefPtr<ArrayBufferView>&&, GC3Duint)
+void WebGL2RenderingContext::texImage3D(GCGLenum, GCGLint, GCGLint, GCGLsizei, GCGLsizei, GCGLsizei, GCGLint, GCGLenum, GCGLenum, RefPtr<ArrayBufferView>&&, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] texImage3D()");
 }
 
-void WebGL2RenderingContext::texSubImage2D(GC3Denum, GC3Dint, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Denum, GC3Denum, GC3Dint64)
+void WebGL2RenderingContext::texSubImage2D(GCGLenum, GCGLint, GCGLint, GCGLint, GCGLsizei, GCGLsizei, GCGLenum, GCGLenum, GCGLint64)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] texSubImage2D()");
 }
 
-ExceptionOr<void> WebGL2RenderingContext::texSubImage2D(GC3Denum, GC3Dint, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Denum, GC3Denum, TexImageSource&&)
+ExceptionOr<void> WebGL2RenderingContext::texSubImage2D(GCGLenum, GCGLint, GCGLint, GCGLint, GCGLsizei, GCGLsizei, GCGLenum, GCGLenum, TexImageSource&&)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] texSubImage2D()");
     return { };
 }
 
-void WebGL2RenderingContext::texSubImage2D(GC3Denum, GC3Dint, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Denum, GC3Denum, RefPtr<ArrayBufferView>&&, GC3Duint)
+void WebGL2RenderingContext::texSubImage2D(GCGLenum, GCGLint, GCGLint, GCGLint, GCGLsizei, GCGLsizei, GCGLenum, GCGLenum, RefPtr<ArrayBufferView>&&, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] texSubImage2D()");
 }
 
-void WebGL2RenderingContext::texSubImage3D(GC3Denum, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Dsizei, GC3Denum, GC3Denum, GC3Dint64)
+void WebGL2RenderingContext::texSubImage3D(GCGLenum, GCGLint, GCGLint, GCGLint, GCGLint, GCGLsizei, GCGLsizei, GCGLsizei, GCGLenum, GCGLenum, GCGLint64)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] texSubImage3D()");
 }
 
-void WebGL2RenderingContext::texSubImage3D(GC3Denum, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Dsizei, GC3Denum, GC3Denum, RefPtr<ArrayBufferView>&&, GC3Duint)
+void WebGL2RenderingContext::texSubImage3D(GCGLenum, GCGLint, GCGLint, GCGLint, GCGLint, GCGLsizei, GCGLsizei, GCGLsizei, GCGLenum, GCGLenum, RefPtr<ArrayBufferView>&&, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] texSubImage3D()");
 }
 
-ExceptionOr<void> WebGL2RenderingContext::texSubImage3D(GC3Denum, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Dsizei, GC3Denum, GC3Denum, TexImageSource&&)
+ExceptionOr<void> WebGL2RenderingContext::texSubImage3D(GCGLenum, GCGLint, GCGLint, GCGLint, GCGLint, GCGLsizei, GCGLsizei, GCGLsizei, GCGLenum, GCGLenum, TexImageSource&&)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] texSubImage3D()");
     return { };
 }
 
-void WebGL2RenderingContext::copyTexSubImage3D(GC3Denum, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei)
+void WebGL2RenderingContext::copyTexSubImage3D(GCGLenum, GCGLint, GCGLint, GCGLint, GCGLint, GCGLint, GCGLint, GCGLsizei, GCGLsizei)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] copyTexSubImage3D()");
 }
 
-void WebGL2RenderingContext::compressedTexImage3D(GC3Denum, GC3Dint, GC3Denum, GC3Dsizei, GC3Dsizei, GC3Dsizei, GC3Dint, GC3Dsizei, GC3Dint64)
+void WebGL2RenderingContext::compressedTexImage3D(GCGLenum, GCGLint, GCGLenum, GCGLsizei, GCGLsizei, GCGLsizei, GCGLint, GCGLsizei, GCGLint64)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] compressedTexImage3D()");
 }
 
-void WebGL2RenderingContext::compressedTexImage3D(GC3Denum, GC3Dint, GC3Denum, GC3Dsizei, GC3Dsizei, GC3Dsizei, GC3Dint, ArrayBufferView&, GC3Duint, GC3Duint)
+void WebGL2RenderingContext::compressedTexImage3D(GCGLenum, GCGLint, GCGLenum, GCGLsizei, GCGLsizei, GCGLsizei, GCGLint, ArrayBufferView&, GCGLuint, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] compressedTexImage3D()");
 }
 
-void WebGL2RenderingContext::compressedTexSubImage3D(GC3Denum, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Dsizei, GC3Denum, GC3Dsizei, GC3Dint64)
+void WebGL2RenderingContext::compressedTexSubImage3D(GCGLenum, GCGLint, GCGLint, GCGLint, GCGLint, GCGLsizei, GCGLsizei, GCGLsizei, GCGLenum, GCGLsizei, GCGLint64)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] compressedTexSubImage3D()");
 }
 
-void WebGL2RenderingContext::compressedTexSubImage3D(GC3Denum, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Dsizei, GC3Denum, ArrayBufferView&, GC3Duint, GC3Duint)
+void WebGL2RenderingContext::compressedTexSubImage3D(GCGLenum, GCGLint, GCGLint, GCGLint, GCGLint, GCGLsizei, GCGLsizei, GCGLsizei, GCGLenum, ArrayBufferView&, GCGLuint, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] compressedTexSubImage3D()");
 }
 
-GC3Dint WebGL2RenderingContext::getFragDataLocation(WebGLProgram&, const String&)
+GCGLint WebGL2RenderingContext::getFragDataLocation(WebGLProgram&, const String&)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] getFragDataLocation()");
     return 0;
 }
 
-void WebGL2RenderingContext::uniform1ui(WebGLUniformLocation*, GC3Duint)
+void WebGL2RenderingContext::uniform1ui(WebGLUniformLocation*, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] uniform1ui()");
 }
 
-void WebGL2RenderingContext::uniform2ui(WebGLUniformLocation*, GC3Duint, GC3Duint)
+void WebGL2RenderingContext::uniform2ui(WebGLUniformLocation*, GCGLuint, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] uniform2ui()");
 }
 
-void WebGL2RenderingContext::uniform3ui(WebGLUniformLocation*, GC3Duint, GC3Duint, GC3Duint)
+void WebGL2RenderingContext::uniform3ui(WebGLUniformLocation*, GCGLuint, GCGLuint, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] uniform3ui()");
 }
 
-void WebGL2RenderingContext::uniform4ui(WebGLUniformLocation*, GC3Duint, GC3Duint, GC3Duint, GC3Duint)
+void WebGL2RenderingContext::uniform4ui(WebGLUniformLocation*, GCGLuint, GCGLuint, GCGLuint, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] uniform4ui()");
 }
 
-void WebGL2RenderingContext::uniform1uiv(WebGLUniformLocation*, Uint32List&&, GC3Duint, GC3Duint)
+void WebGL2RenderingContext::uniform1uiv(WebGLUniformLocation*, Uint32List&&, GCGLuint, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] uniform1uiv()");
 }
 
-void WebGL2RenderingContext::uniform2uiv(WebGLUniformLocation*, Uint32List&&, GC3Duint, GC3Duint)
+void WebGL2RenderingContext::uniform2uiv(WebGLUniformLocation*, Uint32List&&, GCGLuint, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] uniform2uiv()");
 }
 
-void WebGL2RenderingContext::uniform3uiv(WebGLUniformLocation*, Uint32List&&, GC3Duint, GC3Duint)
+void WebGL2RenderingContext::uniform3uiv(WebGLUniformLocation*, Uint32List&&, GCGLuint, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] uniform3uiv()");
 }
 
-void WebGL2RenderingContext::uniform4uiv(WebGLUniformLocation*, Uint32List&&, GC3Duint, GC3Duint)
+void WebGL2RenderingContext::uniform4uiv(WebGLUniformLocation*, Uint32List&&, GCGLuint, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] uniform4uiv()");
 }
 
-void WebGL2RenderingContext::uniformMatrix2x3fv(WebGLUniformLocation*, GC3Dboolean, Float32List&&, GC3Duint, GC3Duint)
+void WebGL2RenderingContext::uniformMatrix2x3fv(WebGLUniformLocation*, GCGLboolean, Float32List&&, GCGLuint, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] uniformMatrix2x3fv()");
 }
 
-void WebGL2RenderingContext::uniformMatrix3x2fv(WebGLUniformLocation*, GC3Dboolean, Float32List&&, GC3Duint, GC3Duint)
+void WebGL2RenderingContext::uniformMatrix3x2fv(WebGLUniformLocation*, GCGLboolean, Float32List&&, GCGLuint, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] uniformMatrix3x2fv()");
 }
 
-void WebGL2RenderingContext::uniformMatrix2x4fv(WebGLUniformLocation*, GC3Dboolean, Float32List&&, GC3Duint, GC3Duint)
+void WebGL2RenderingContext::uniformMatrix2x4fv(WebGLUniformLocation*, GCGLboolean, Float32List&&, GCGLuint, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] uniformMatrix2x4fv()");
 }
 
-void WebGL2RenderingContext::uniformMatrix4x2fv(WebGLUniformLocation*, GC3Dboolean, Float32List&&, GC3Duint, GC3Duint)
+void WebGL2RenderingContext::uniformMatrix4x2fv(WebGLUniformLocation*, GCGLboolean, Float32List&&, GCGLuint, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] uniformMatrix4x2fv()");
 }
 
-void WebGL2RenderingContext::uniformMatrix3x4fv(WebGLUniformLocation*, GC3Dboolean, Float32List&&, GC3Duint, GC3Duint)
+void WebGL2RenderingContext::uniformMatrix3x4fv(WebGLUniformLocation*, GCGLboolean, Float32List&&, GCGLuint, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] uniformMatrix3x4fv()");
 }
 
-void WebGL2RenderingContext::uniformMatrix4x3fv(WebGLUniformLocation*, GC3Dboolean, Float32List&&, GC3Duint, GC3Duint)
+void WebGL2RenderingContext::uniformMatrix4x3fv(WebGLUniformLocation*, GCGLboolean, Float32List&&, GCGLuint, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] uniformMatrix4x3fv()");
 }
 
-void WebGL2RenderingContext::vertexAttribI4i(GC3Duint, GC3Dint, GC3Dint, GC3Dint, GC3Dint)
+void WebGL2RenderingContext::vertexAttribI4i(GCGLuint, GCGLint, GCGLint, GCGLint, GCGLint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] vertexAttribI4i()");
 }
 
-void WebGL2RenderingContext::vertexAttribI4iv(GC3Duint, Int32List&&)
+void WebGL2RenderingContext::vertexAttribI4iv(GCGLuint, Int32List&&)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] vertexAttribI4iv()");
 }
 
-void WebGL2RenderingContext::vertexAttribI4ui(GC3Duint, GC3Duint, GC3Duint, GC3Duint, GC3Duint)
+void WebGL2RenderingContext::vertexAttribI4ui(GCGLuint, GCGLuint, GCGLuint, GCGLuint, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] vertexAttribI4ui()");
 }
 
-void WebGL2RenderingContext::vertexAttribI4uiv(GC3Duint, Uint32List&&)
+void WebGL2RenderingContext::vertexAttribI4uiv(GCGLuint, Uint32List&&)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] vertexAttribI4uiv()");
 }
 
-void WebGL2RenderingContext::vertexAttribIPointer(GC3Duint, GC3Dint, GC3Denum, GC3Dsizei, GC3Dint64)
+void WebGL2RenderingContext::vertexAttribIPointer(GCGLuint, GCGLint, GCGLenum, GCGLsizei, GCGLint64)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] vertexAttribIPointer()");
 }
 
-void WebGL2RenderingContext::clear(GC3Dbitfield mask)
+void WebGL2RenderingContext::clear(GCGLbitfield mask)
 {
     if (isContextLostOrPending())
         return;
@@ -889,7 +889,7 @@ void WebGL2RenderingContext::clear(GC3Dbitfield mask)
     markContextChangedAndNotifyCanvasObserver();
 }
 
-void WebGL2RenderingContext::vertexAttribDivisor(GC3Duint index, GC3Duint divisor)
+void WebGL2RenderingContext::vertexAttribDivisor(GCGLuint index, GCGLuint divisor)
 {
     if (isContextLostOrPending())
         return;
@@ -897,7 +897,7 @@ void WebGL2RenderingContext::vertexAttribDivisor(GC3Duint index, GC3Duint diviso
     WebGLRenderingContextBase::vertexAttribDivisor(index, divisor);
 }
 
-void WebGL2RenderingContext::drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei instanceCount)
+void WebGL2RenderingContext::drawArraysInstanced(GCGLenum mode, GCGLint first, GCGLsizei count, GCGLsizei instanceCount)
 {
     if (isContextLostOrPending())
         return;
@@ -905,7 +905,7 @@ void WebGL2RenderingContext::drawArraysInstanced(GC3Denum mode, GC3Dint first, G
     WebGLRenderingContextBase::drawArraysInstanced(mode, first, count, instanceCount);
 }
 
-void WebGL2RenderingContext::drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, GC3Dint64 offset, GC3Dsizei instanceCount)
+void WebGL2RenderingContext::drawElementsInstanced(GCGLenum mode, GCGLsizei count, GCGLenum type, GCGLint64 offset, GCGLsizei instanceCount)
 {
     if (isContextLostOrPending())
         return;
@@ -913,17 +913,17 @@ void WebGL2RenderingContext::drawElementsInstanced(GC3Denum mode, GC3Dsizei coun
     WebGLRenderingContextBase::drawElementsInstanced(mode, count, type, offset, instanceCount);
 }
 
-void WebGL2RenderingContext::drawRangeElements(GC3Denum, GC3Duint, GC3Duint, GC3Dsizei, GC3Denum, GC3Dint64)
+void WebGL2RenderingContext::drawRangeElements(GCGLenum, GCGLuint, GCGLuint, GCGLsizei, GCGLenum, GCGLint64)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] drawRangeElements()");
 }
 
-void WebGL2RenderingContext::drawBuffers(const Vector<GC3Denum>& buffers)
+void WebGL2RenderingContext::drawBuffers(const Vector<GCGLenum>& buffers)
 {
     if (isContextLost())
         return;
-    GC3Dsizei n = buffers.size();
-    const GC3Denum* bufs = buffers.data();
+    GCGLsizei n = buffers.size();
+    const GCGLenum* bufs = buffers.data();
     if (!m_framebufferBinding) {
         if (n != 1) {
             synthesizeGLError(GraphicsContextGL::INVALID_VALUE, "drawBuffers", "more than one buffer");
@@ -934,7 +934,7 @@ void WebGL2RenderingContext::drawBuffers(const Vector<GC3Denum>& buffers)
             return;
         }
         // Because the backbuffer is simulated on all current WebKit ports, we need to change BACK to COLOR_ATTACHMENT0.
-        GC3Denum value = (bufs[0] == GraphicsContextGL::BACK) ? GraphicsContextGL::COLOR_ATTACHMENT0 : GraphicsContextGL::NONE;
+        GCGLenum value = (bufs[0] == GraphicsContextGL::BACK) ? GraphicsContextGL::COLOR_ATTACHMENT0 : GraphicsContextGL::NONE;
         graphicsContextGL()->getExtensions().drawBuffersEXT(1, &value);
         setBackDrawBuffer(bufs[0]);
     } else {
@@ -942,8 +942,8 @@ void WebGL2RenderingContext::drawBuffers(const Vector<GC3Denum>& buffers)
             synthesizeGLError(GraphicsContextGL::INVALID_VALUE, "drawBuffers", "more than max draw buffers");
             return;
         }
-        for (GC3Dsizei i = 0; i < n; ++i) {
-            if (bufs[i] != GraphicsContextGL::NONE && bufs[i] != static_cast<GC3Denum>(GraphicsContextGL::COLOR_ATTACHMENT0 + i)) {
+        for (GCGLsizei i = 0; i < n; ++i) {
+            if (bufs[i] != GraphicsContextGL::NONE && bufs[i] != static_cast<GCGLenum>(GraphicsContextGL::COLOR_ATTACHMENT0 + i)) {
                 synthesizeGLError(GraphicsContextGL::INVALID_OPERATION, "drawBuffers", "COLOR_ATTACHMENTi or NONE");
                 return;
             }
@@ -952,7 +952,7 @@ void WebGL2RenderingContext::drawBuffers(const Vector<GC3Denum>& buffers)
     }
 }
 
-void WebGL2RenderingContext::clearBufferiv(GC3Denum buffer, GC3Dint drawbuffer, Int32List&&, GC3Duint)
+void WebGL2RenderingContext::clearBufferiv(GCGLenum buffer, GCGLint drawbuffer, Int32List&&, GCGLuint)
 {
     switch (buffer) {
     case GraphicsContextGL::COLOR:
@@ -977,7 +977,7 @@ void WebGL2RenderingContext::clearBufferiv(GC3Denum buffer, GC3Dint drawbuffer,
     }
 }
 
-void WebGL2RenderingContext::clearBufferuiv(GC3Denum buffer, GC3Dint drawbuffer, Uint32List&&, GC3Duint)
+void WebGL2RenderingContext::clearBufferuiv(GCGLenum buffer, GCGLint drawbuffer, Uint32List&&, GCGLuint)
 {
     switch (buffer) {
     case GraphicsContextGL::COLOR:
@@ -996,7 +996,7 @@ void WebGL2RenderingContext::clearBufferuiv(GC3Denum buffer, GC3Dint drawbuffer,
     }
 }
 
-void WebGL2RenderingContext::clearBufferfv(GC3Denum buffer, GC3Dint drawbuffer, Float32List&&, GC3Duint)
+void WebGL2RenderingContext::clearBufferfv(GCGLenum buffer, GCGLint drawbuffer, Float32List&&, GCGLuint)
 {
     switch (buffer) {
     case GraphicsContextGL::COLOR:
@@ -1021,7 +1021,7 @@ void WebGL2RenderingContext::clearBufferfv(GC3Denum buffer, GC3Dint drawbuffer,
     }
 }
 
-void WebGL2RenderingContext::clearBufferfi(GC3Denum buffer, GC3Dint drawbuffer, GC3Dfloat, GC3Dint)
+void WebGL2RenderingContext::clearBufferfi(GCGLenum buffer, GCGLint drawbuffer, GCGLfloat, GCGLint)
 {
     switch (buffer) {
     case GraphicsContextGL::DEPTH_STENCIL:
@@ -1051,29 +1051,29 @@ void WebGL2RenderingContext::deleteQuery(WebGLQuery*)
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] deleteQuery()");
 }
 
-GC3Dboolean WebGL2RenderingContext::isQuery(WebGLQuery*)
+GCGLboolean WebGL2RenderingContext::isQuery(WebGLQuery*)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] isQuery()");
     return false;
 }
 
-void WebGL2RenderingContext::beginQuery(GC3Denum, WebGLQuery&)
+void WebGL2RenderingContext::beginQuery(GCGLenum, WebGLQuery&)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] beginQuery()");
 }
 
-void WebGL2RenderingContext::endQuery(GC3Denum)
+void WebGL2RenderingContext::endQuery(GCGLenum)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] endQuery()");
 }
 
-RefPtr<WebGLQuery> WebGL2RenderingContext::getQuery(GC3Denum, GC3Denum)
+RefPtr<WebGLQuery> WebGL2RenderingContext::getQuery(GCGLenum, GCGLenum)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] getquery()");
     return nullptr;
 }
 
-WebGLAny WebGL2RenderingContext::getQueryParameter(WebGLQuery&, GC3Denum)
+WebGLAny WebGL2RenderingContext::getQueryParameter(WebGLQuery&, GCGLenum)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] getQueryParameter)");
     return nullptr;
@@ -1090,40 +1090,40 @@ void WebGL2RenderingContext::deleteSampler(WebGLSampler*)
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] deleteSampler()");
 }
 
-GC3Dboolean WebGL2RenderingContext::isSampler(WebGLSampler*)
+GCGLboolean WebGL2RenderingContext::isSampler(WebGLSampler*)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] isSampler()");
     return false;
 }
 
-void WebGL2RenderingContext::bindSampler(GC3Duint, WebGLSampler*)
+void WebGL2RenderingContext::bindSampler(GCGLuint, WebGLSampler*)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] bindSampler()");
 }
 
-void WebGL2RenderingContext::samplerParameteri(WebGLSampler&, GC3Denum, GC3Dint)
+void WebGL2RenderingContext::samplerParameteri(WebGLSampler&, GCGLenum, GCGLint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] samplerParameteri()");
 }
 
-void WebGL2RenderingContext::samplerParameterf(WebGLSampler&, GC3Denum, GC3Dfloat)
+void WebGL2RenderingContext::samplerParameterf(WebGLSampler&, GCGLenum, GCGLfloat)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] samplerParameterf()");
 }
 
-WebGLAny WebGL2RenderingContext::getSamplerParameter(WebGLSampler&, GC3Denum)
+WebGLAny WebGL2RenderingContext::getSamplerParameter(WebGLSampler&, GCGLenum)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] getSamplerParameter()");
     return nullptr;
 }
 
-RefPtr<WebGLSync> WebGL2RenderingContext::fenceSync(GC3Denum, GC3Dbitfield)
+RefPtr<WebGLSync> WebGL2RenderingContext::fenceSync(GCGLenum, GCGLbitfield)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] fenceSync()");
     return nullptr;
 }
 
-GC3Dboolean WebGL2RenderingContext::isSync(WebGLSync*)
+GCGLboolean WebGL2RenderingContext::isSync(WebGLSync*)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] isSync()");
     return false;
@@ -1134,7 +1134,7 @@ void WebGL2RenderingContext::deleteSync(WebGLSync*)
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] deleteSync()");
 }
 
-GC3Denum WebGL2RenderingContext::clientWaitSync(WebGLSync&, GC3Dbitfield, GC3Duint64)
+GCGLenum WebGL2RenderingContext::clientWaitSync(WebGLSync&, GCGLbitfield, GCGLuint64)
 {
     // Note: Do not implement this function without consulting webkit-dev and WebGL
     // reviewers beforehand. Apple folks, see <rdar://problem/36666458>.
@@ -1142,12 +1142,12 @@ GC3Denum WebGL2RenderingContext::clientWaitSync(WebGLSync&, GC3Dbitfield, GC3Dui
     return 0;
 }
 
-void WebGL2RenderingContext::waitSync(WebGLSync&, GC3Dbitfield, GC3Dint64)
+void WebGL2RenderingContext::waitSync(WebGLSync&, GCGLbitfield, GCGLint64)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] waitSync()");
 }
 
-WebGLAny WebGL2RenderingContext::getSyncParameter(WebGLSync&, GC3Denum)
+WebGLAny WebGL2RenderingContext::getSyncParameter(WebGLSync&, GCGLenum)
 {
     // Note: Do not implement this function without consulting webkit-dev and WebGL
     // reviewers beforehand. Apple folks, see <rdar://problem/36666458>.
@@ -1166,18 +1166,18 @@ void WebGL2RenderingContext::deleteTransformFeedback(WebGLTransformFeedback*)
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] deleteTransformFeedback()");
 }
 
-GC3Dboolean WebGL2RenderingContext::isTransformFeedback(WebGLTransformFeedback*)
+GCGLboolean WebGL2RenderingContext::isTransformFeedback(WebGLTransformFeedback*)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] isTransformFeedback()");
     return false;
 }
 
-void WebGL2RenderingContext::bindTransformFeedback(GC3Denum, WebGLTransformFeedback*)
+void WebGL2RenderingContext::bindTransformFeedback(GCGLenum, WebGLTransformFeedback*)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] bindTransformFeedback()");
 }
 
-void WebGL2RenderingContext::beginTransformFeedback(GC3Denum)
+void WebGL2RenderingContext::beginTransformFeedback(GCGLenum)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] beginTransformFeedback()");
 }
@@ -1187,12 +1187,12 @@ void WebGL2RenderingContext::endTransformFeedback()
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] endTransformFeedback()");
 }
 
-void WebGL2RenderingContext::transformFeedbackVaryings(WebGLProgram&, const Vector<String>&, GC3Denum)
+void WebGL2RenderingContext::transformFeedbackVaryings(WebGLProgram&, const Vector<String>&, GCGLenum)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] transformFeedbackVaryings()");
 }
 
-RefPtr<WebGLActiveInfo> WebGL2RenderingContext::getTransformFeedbackVarying(WebGLProgram&, GC3Duint)
+RefPtr<WebGLActiveInfo> WebGL2RenderingContext::getTransformFeedbackVarying(WebGLProgram&, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] getTransformFeedbackVarying()");
     return nullptr;
@@ -1208,17 +1208,17 @@ void WebGL2RenderingContext::resumeTransformFeedback()
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] resumeTransformFeedback()");
 }
 
-void WebGL2RenderingContext::bindBufferBase(GC3Denum, GC3Duint, WebGLBuffer*)
+void WebGL2RenderingContext::bindBufferBase(GCGLenum, GCGLuint, WebGLBuffer*)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] bindBufferBase()");
 }
 
-void WebGL2RenderingContext::bindBufferRange(GC3Denum, GC3Duint, WebGLBuffer*, GC3Dint64, GC3Dint64)
+void WebGL2RenderingContext::bindBufferRange(GCGLenum, GCGLuint, WebGLBuffer*, GCGLint64, GCGLint64)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] bindBufferRange()");
 }
 
-WebGLAny WebGL2RenderingContext::getIndexedParameter(GC3Denum target, GC3Duint)
+WebGLAny WebGL2RenderingContext::getIndexedParameter(GCGLenum target, GCGLuint)
 {
     switch (target) {
     case GraphicsContextGL::TRANSFORM_FEEDBACK_BUFFER_BINDING:
@@ -1235,13 +1235,13 @@ WebGLAny WebGL2RenderingContext::getIndexedParameter(GC3Denum target, GC3Duint)
     }
 }
 
-Optional<Vector<GC3Duint>> WebGL2RenderingContext::getUniformIndices(WebGLProgram&, const Vector<String>&)
+Optional<Vector<GCGLuint>> WebGL2RenderingContext::getUniformIndices(WebGLProgram&, const Vector<String>&)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] getUniformIndices()");
     return WTF::nullopt;
 }
 
-WebGLAny WebGL2RenderingContext::getActiveUniforms(WebGLProgram& program, const Vector<GC3Duint>& uniformIndices, GC3Denum pname)
+WebGLAny WebGL2RenderingContext::getActiveUniforms(WebGLProgram& program, const Vector<GCGLuint>& uniformIndices, GCGLenum pname)
 {
     if (isContextLostOrPending() || !validateWebGLObject("getActiveUniforms", &program))
         return nullptr;
@@ -1255,7 +1255,7 @@ WebGLAny WebGL2RenderingContext::getActiveUniforms(WebGLProgram& program, const
     case GraphicsContextGL::UNIFORM_MATRIX_STRIDE:
     case GraphicsContextGL::UNIFORM_IS_ROW_MAJOR:
         {
-            Vector<GC3Dint> params(uniformIndices.size(), 0);
+            Vector<GCGLint> params(uniformIndices.size(), 0);
             m_context->getActiveUniforms(program.object(), uniformIndices, pname, params);
             return WTFMove(params);
         }
@@ -1265,25 +1265,25 @@ WebGLAny WebGL2RenderingContext::getActiveUniforms(WebGLProgram& program, const
     }
 }
 
-GC3Duint WebGL2RenderingContext::getUniformBlockIndex(WebGLProgram&, const String&)
+GCGLuint WebGL2RenderingContext::getUniformBlockIndex(WebGLProgram&, const String&)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] getUniformBlockIndex()");
     return 0;
 }
 
-WebGLAny WebGL2RenderingContext::getActiveUniformBlockParameter(WebGLProgram&, GC3Duint, GC3Denum)
+WebGLAny WebGL2RenderingContext::getActiveUniformBlockParameter(WebGLProgram&, GCGLuint, GCGLenum)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] getActiveUniformBlockParameter()");
     return nullptr;
 }
 
-WebGLAny WebGL2RenderingContext::getActiveUniformBlockName(WebGLProgram&, GC3Duint)
+WebGLAny WebGL2RenderingContext::getActiveUniformBlockName(WebGLProgram&, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] getActiveUniformBlockName()");
     return nullptr;
 }
 
-void WebGL2RenderingContext::uniformBlockBinding(WebGLProgram&, GC3Duint, GC3Duint)
+void WebGL2RenderingContext::uniformBlockBinding(WebGLProgram&, GCGLuint, GCGLuint)
 {
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] uniformBlockBinding()");
 }
@@ -1316,7 +1316,7 @@ void WebGL2RenderingContext::deleteVertexArray(WebGLVertexArrayObject* arrayObje
     arrayObject->deleteObject(graphicsContextGL());
 }
 
-GC3Dboolean WebGL2RenderingContext::isVertexArray(WebGLVertexArrayObject* arrayObject)
+GCGLboolean WebGL2RenderingContext::isVertexArray(WebGLVertexArrayObject* arrayObject)
 {
     if (!arrayObject || isContextLost())
         return false;
@@ -1423,7 +1423,7 @@ Optional<Vector<String>> WebGL2RenderingContext::getSupportedExtensions()
     return result;
 }
 
-static bool validateDefaultFramebufferAttachment(GC3Denum& attachment)
+static bool validateDefaultFramebufferAttachment(GCGLenum& attachment)
 {
     switch (attachment) {
     case GraphicsContextGL::BACK:
@@ -1438,7 +1438,7 @@ static bool validateDefaultFramebufferAttachment(GC3Denum& attachment)
     return false;
 }
 
-WebGLAny WebGL2RenderingContext::getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname)
+WebGLAny WebGL2RenderingContext::getFramebufferAttachmentParameter(GCGLenum target, GCGLenum attachment, GCGLenum pname)
 {
     const char* functionName = "getFramebufferAttachmentParameter";
     if (isContextLostOrPending() || !validateFramebufferTarget(functionName, target))
@@ -1452,7 +1452,7 @@ WebGLAny WebGL2RenderingContext::getFramebufferAttachmentParameter(GC3Denum targ
             synthesizeGLError(GraphicsContextGL::INVALID_ENUM, functionName, "invalid attachment");
             return nullptr;
         }
-        GC3Dint value = 0;
+        GCGLint value = 0;
         m_context->getFramebufferAttachmentParameteriv(target, attachment, pname, &value);
         return value;
     }
@@ -1475,7 +1475,7 @@ WebGLAny WebGL2RenderingContext::getFramebufferAttachmentParameter(GC3Denum targ
     case GraphicsContextGL::FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
     case GraphicsContextGL::FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
     case GraphicsContextGL::FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: {
-        GC3Dint value = 0;
+        GCGLint value = 0;
         m_context->getFramebufferAttachmentParameteriv(target, attachment, pname, &value);
         return value;
     }
@@ -1490,7 +1490,7 @@ WebGLAny WebGL2RenderingContext::getFramebufferAttachmentParameter(GC3Denum targ
         case GraphicsContextGL::FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
         case GraphicsContextGL::FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
         case GraphicsContextGL::FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: {
-            GC3Dint value = 0;
+            GCGLint value = 0;
             m_context->getFramebufferAttachmentParameteriv(target, attachment, pname, &value);
             return value;
         }
@@ -1523,12 +1523,12 @@ WebGLAny WebGL2RenderingContext::getFramebufferAttachmentParameter(GC3Denum targ
     }
 }
 
-bool WebGL2RenderingContext::validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment)
+bool WebGL2RenderingContext::validateFramebufferFuncParameters(const char* functionName, GCGLenum target, GCGLenum attachment)
 {
     return validateFramebufferTarget(functionName, target) && validateNonDefaultFramebufferAttachment(functionName, attachment);
 }
 
-bool WebGL2RenderingContext::validateFramebufferTarget(const char* functionName, GC3Denum target)
+bool WebGL2RenderingContext::validateFramebufferTarget(const char* functionName, GCGLenum target)
 {
     switch (target) {
     case GraphicsContextGL::FRAMEBUFFER:
@@ -1541,7 +1541,7 @@ bool WebGL2RenderingContext::validateFramebufferTarget(const char* functionName,
     return false;
 }
 
-bool WebGL2RenderingContext::validateNonDefaultFramebufferAttachment(const char* functionName, GC3Denum attachment)
+bool WebGL2RenderingContext::validateNonDefaultFramebufferAttachment(const char* functionName, GCGLenum attachment)
 {
     switch (attachment) {
     case GraphicsContextGL::DEPTH_ATTACHMENT:
@@ -1549,7 +1549,7 @@ bool WebGL2RenderingContext::validateNonDefaultFramebufferAttachment(const char*
     case GraphicsContextGL::DEPTH_STENCIL_ATTACHMENT:
         return true;
     default:
-        if (attachment >= GraphicsContextGL::COLOR_ATTACHMENT0 && attachment < static_cast<GC3Denum>(GraphicsContextGL::COLOR_ATTACHMENT0 + getMaxColorAttachments()))
+        if (attachment >= GraphicsContextGL::COLOR_ATTACHMENT0 && attachment < static_cast<GCGLenum>(GraphicsContextGL::COLOR_ATTACHMENT0 + getMaxColorAttachments()))
             return true;
     }
 
@@ -1557,14 +1557,14 @@ bool WebGL2RenderingContext::validateNonDefaultFramebufferAttachment(const char*
     return false;
 }
 
-GC3Dint WebGL2RenderingContext::getMaxDrawBuffers()
+GCGLint WebGL2RenderingContext::getMaxDrawBuffers()
 {
     if (!m_maxDrawBuffers)
         m_context->getIntegerv(GraphicsContextGL::MAX_DRAW_BUFFERS, &m_maxDrawBuffers);
     return m_maxDrawBuffers;
 }
 
-GC3Dint WebGL2RenderingContext::getMaxColorAttachments()
+GCGLint WebGL2RenderingContext::getMaxColorAttachments()
 {
     // DrawBuffers requires MAX_COLOR_ATTACHMENTS == MAX_DRAW_BUFFERS
     if (!m_maxColorAttachments)
@@ -1572,7 +1572,7 @@ GC3Dint WebGL2RenderingContext::getMaxColorAttachments()
     return m_maxColorAttachments;
 }
 
-void WebGL2RenderingContext::renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height)
+void WebGL2RenderingContext::renderbufferStorage(GCGLenum target, GCGLenum internalformat, GCGLsizei width, GCGLsizei height)
 {
     if (isContextLostOrPending())
         return;
@@ -1642,7 +1642,7 @@ void WebGL2RenderingContext::renderbufferStorage(GC3Denum target, GC3Denum inter
     applyStencilTest();
 }
 
-void WebGL2RenderingContext::hint(GC3Denum target, GC3Denum mode)
+void WebGL2RenderingContext::hint(GCGLenum target, GCGLenum mode)
 {
     if (isContextLostOrPending())
         return;
@@ -1660,7 +1660,7 @@ void WebGL2RenderingContext::hint(GC3Denum target, GC3Denum mode)
     m_context->hint(target, mode);
 }
 
-GC3Denum WebGL2RenderingContext::baseInternalFormatFromInternalFormat(GC3Denum internalformat)
+GCGLenum WebGL2RenderingContext::baseInternalFormatFromInternalFormat(GCGLenum internalformat)
 {
     // Handles sized, unsized, and compressed internal formats.
     switch (internalformat) {
@@ -1748,7 +1748,7 @@ GC3Denum WebGL2RenderingContext::baseInternalFormatFromInternalFormat(GC3Denum i
     }
 }
 
-bool WebGL2RenderingContext::isIntegerFormat(GC3Denum internalformat)
+bool WebGL2RenderingContext::isIntegerFormat(GCGLenum internalformat)
 {
     switch (baseInternalFormatFromInternalFormat(internalformat)) {
     case GraphicsContextGL::RED_INTEGER:
@@ -1760,7 +1760,7 @@ bool WebGL2RenderingContext::isIntegerFormat(GC3Denum internalformat)
     return false;
 }
 
-WebGLAny WebGL2RenderingContext::getParameter(GC3Denum pname)
+WebGLAny WebGL2RenderingContext::getParameter(GCGLenum pname)
 {
     if (isContextLostOrPending())
         return nullptr;
@@ -2092,7 +2092,7 @@ WebGLAny WebGL2RenderingContext::getParameter(GC3Denum pname)
     }
 }
 
-bool WebGL2RenderingContext::validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired)
+bool WebGL2RenderingContext::validateIndexArrayConservative(GCGLenum type, unsigned& numElementsRequired)
 {
     // Performs conservative validation by caching a maximum index of
     // the given type per element array buffer. If all of the bound
@@ -2105,7 +2105,7 @@ bool WebGL2RenderingContext::validateIndexArrayConservative(GC3Denum type, unsig
     if (!elementArrayBuffer)
         return false;
     
-    GC3Dsizeiptr numElements = elementArrayBuffer->byteLength();
+    GCGLsizeiptr numElements = elementArrayBuffer->byteLength();
     // The case count==0 is already dealt with in drawElements before validateIndexArrayConservative.
     if (!numElements)
         return false;
@@ -2117,13 +2117,13 @@ bool WebGL2RenderingContext::validateIndexArrayConservative(GC3Denum type, unsig
         // Compute the maximum index in the entire buffer for the given type of index.
         switch (type) {
         case GraphicsContextGL::UNSIGNED_BYTE:
-            maxIndex = getMaxIndex<GC3Dubyte>(buffer, 0, numElements);
+            maxIndex = getMaxIndex<GCGLubyte>(buffer, 0, numElements);
             break;
         case GraphicsContextGL::UNSIGNED_SHORT:
-            maxIndex = getMaxIndex<GC3Dushort>(buffer, 0, numElements / sizeof(GC3Dushort));
+            maxIndex = getMaxIndex<GCGLushort>(buffer, 0, numElements / sizeof(GCGLushort));
             break;
         case GraphicsContextGL::UNSIGNED_INT:
-            maxIndex = getMaxIndex<GC3Duint>(buffer, 0, numElements / sizeof(GC3Duint));
+            maxIndex = getMaxIndex<GCGLuint>(buffer, 0, numElements / sizeof(GCGLuint));
             break;
         default:
             return false;
@@ -2145,7 +2145,7 @@ bool WebGL2RenderingContext::validateIndexArrayConservative(GC3Denum type, unsig
     return true;
 }
 
-bool WebGL2RenderingContext::validateBlendEquation(const char* functionName, GC3Denum mode)
+bool WebGL2RenderingContext::validateBlendEquation(const char* functionName, GCGLenum mode)
 {
     switch (mode) {
     case GraphicsContextGL::FUNC_ADD:
@@ -2160,7 +2160,7 @@ bool WebGL2RenderingContext::validateBlendEquation(const char* functionName, GC3
     }
 }
 
-bool WebGL2RenderingContext::validateCapability(const char* functionName, GC3Denum cap)
+bool WebGL2RenderingContext::validateCapability(const char* functionName, GCGLenum cap)
 {
     switch (cap) {
     case GraphicsContextGL::BLEND:
@@ -2180,7 +2180,7 @@ bool WebGL2RenderingContext::validateCapability(const char* functionName, GC3Den
     }
 }
 
-void WebGL2RenderingContext::compressedTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Dsizei imageSize, GC3Dint64 offset)
+void WebGL2RenderingContext::compressedTexImage2D(GCGLenum target, GCGLint level, GCGLenum internalformat, GCGLsizei width, GCGLsizei height, GCGLint border, GCGLsizei imageSize, GCGLint64 offset)
 {
     UNUSED_PARAM(target);
     UNUSED_PARAM(level);
@@ -2194,7 +2194,7 @@ void WebGL2RenderingContext::compressedTexImage2D(GC3Denum target, GC3Dint level
     LOG(WebGL, "[[ NOT IMPLEMENTED ]] compressedTexImage2D()");
 }
 
-void WebGL2RenderingContext::compressedTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, ArrayBufferView& srcData, GC3Duint srcOffset, GC3Duint srcLengthOverride)
+void WebGL2RenderingContext::compressedTexImage2D(GCGLenum target, GCGLint level, GCGLenum internalformat, GCGLsizei width, GCGLsizei height, GCGLint border, ArrayBufferView& srcData, GCGLuint srcOffset, GCGLuint srcLengthOverride)
 {
     UNUSED_PARAM(target);
     UNUSED_PARAM(level);
index af2c47a..239172d 100644 (file)
@@ -47,26 +47,26 @@ public:
     // Buffer objects
     using WebGLRenderingContextBase::bufferData;
     using WebGLRenderingContextBase::bufferSubData;
-    void bufferData(GC3Denum target, const ArrayBufferView& data, GC3Denum usage, GC3Duint srcOffset, GC3Duint length);
-    void bufferSubData(GC3Denum target, long long offset, const ArrayBufferView& data, GC3Duint srcOffset, GC3Duint length);
-    void copyBufferSubData(GC3Denum readTarget, GC3Denum writeTarget, GC3Dint64 readOffset, GC3Dint64 writeOffset, GC3Dint64 size);
-    void getBufferSubData(GC3Denum target, long long srcByteOffset, RefPtr<ArrayBufferView>&& dstData, GC3Duint dstOffset = 0, GC3Duint length = 0);
+    void bufferData(GCGLenum target, const ArrayBufferView& data, GCGLenum usage, GCGLuint srcOffset, GCGLuint length);
+    void bufferSubData(GCGLenum target, long long offset, const ArrayBufferView& data, GCGLuint srcOffset, GCGLuint length);
+    void copyBufferSubData(GCGLenum readTarget, GCGLenum writeTarget, GCGLint64 readOffset, GCGLint64 writeOffset, GCGLint64 size);
+    void getBufferSubData(GCGLenum target, long long srcByteOffset, RefPtr<ArrayBufferView>&& dstData, GCGLuint dstOffset = 0, GCGLuint length = 0);
     
     // Framebuffer objects
-    WebGLAny getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname) final;
-    void blitFramebuffer(GC3Dint srcX0, GC3Dint srcY0, GC3Dint srcX1, GC3Dint srcY1, GC3Dint dstX0, GC3Dint dstY0, GC3Dint dstX1, GC3Dint dstY1, GC3Dbitfield mask, GC3Denum filter);
-    void framebufferTextureLayer(GC3Denum target, GC3Denum attachment, WebGLTexture*, GC3Dint level, GC3Dint layer);
-    WebGLAny getInternalformatParameter(GC3Denum target, GC3Denum internalformat, GC3Denum pname);
-    void invalidateFramebuffer(GC3Denum target, const Vector<GC3Denum>& attachments);
-    void invalidateSubFramebuffer(GC3Denum target, const Vector<GC3Denum>& attachments, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
-    void readBuffer(GC3Denum src);
+    WebGLAny getFramebufferAttachmentParameter(GCGLenum target, GCGLenum attachment, GCGLenum pname) final;
+    void blitFramebuffer(GCGLint srcX0, GCGLint srcY0, GCGLint srcX1, GCGLint srcY1, GCGLint dstX0, GCGLint dstY0, GCGLint dstX1, GCGLint dstY1, GCGLbitfield mask, GCGLenum filter);
+    void framebufferTextureLayer(GCGLenum target, GCGLenum attachment, WebGLTexture*, GCGLint level, GCGLint layer);
+    WebGLAny getInternalformatParameter(GCGLenum target, GCGLenum internalformat, GCGLenum pname);
+    void invalidateFramebuffer(GCGLenum target, const Vector<GCGLenum>& attachments);
+    void invalidateSubFramebuffer(GCGLenum target, const Vector<GCGLenum>& attachments, GCGLint x, GCGLint y, GCGLsizei width, GCGLsizei height);
+    void readBuffer(GCGLenum src);
     
     // Renderbuffer objects
-    void renderbufferStorageMultisample(GC3Denum target, GC3Dsizei samples, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height);
+    void renderbufferStorageMultisample(GCGLenum target, GCGLsizei samples, GCGLenum internalformat, GCGLsizei width, GCGLsizei height);
     
     // Texture objects
-    void texStorage2D(GC3Denum target, GC3Dsizei levels, GC3Denum internalFormat, GC3Dsizei width, GC3Dsizei height);
-    void texStorage3D(GC3Denum target, GC3Dsizei levels, GC3Denum internalFormat, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth);
+    void texStorage2D(GCGLenum target, GCGLsizei levels, GCGLenum internalFormat, GCGLsizei width, GCGLsizei height);
+    void texStorage3D(GCGLenum target, GCGLsizei levels, GCGLenum internalFormat, GCGLsizei width, GCGLsizei height, GCGLsizei depth);
 
 #if ENABLE(VIDEO)
     using TexImageSource = WTF::Variant<RefPtr<ImageBitmap>, RefPtr<ImageData>, RefPtr<HTMLImageElement>, RefPtr<HTMLCanvasElement>, RefPtr<HTMLVideoElement>>;
@@ -75,64 +75,64 @@ public:
 #endif
 
     using WebGLRenderingContextBase::texImage2D;
-    void texImage2D(GC3Denum target, GC3Dint level, GC3Dint internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, GC3Dint64 pboOffset);
-    ExceptionOr<void> texImage2D(GC3Denum target, GC3Dint level, GC3Dint internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, TexImageSource&&);
-    void texImage2D(GC3Denum target, GC3Dint level, GC3Dint internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&& srcData, GC3Duint srcOffset);
+    void texImage2D(GCGLenum target, GCGLint level, GCGLint internalformat, GCGLsizei width, GCGLsizei height, GCGLint border, GCGLenum format, GCGLenum type, GCGLint64 pboOffset);
+    ExceptionOr<void> texImage2D(GCGLenum target, GCGLint level, GCGLint internalformat, GCGLsizei width, GCGLsizei height, GCGLint border, GCGLenum format, GCGLenum type, TexImageSource&&);
+    void texImage2D(GCGLenum target, GCGLint level, GCGLint internalformat, GCGLsizei width, GCGLsizei height, GCGLint border, GCGLenum format, GCGLenum type, RefPtr<ArrayBufferView>&& srcData, GCGLuint srcOffset);
 
-    void texImage3D(GC3Denum target, GC3Dint level, GC3Dint internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Dint border, GC3Denum format, GC3Denum type, GC3Dint64 pboOffset);
-    ExceptionOr<void> texImage3D(GC3Denum target, GC3Dint level, GC3Dint internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Dint border, GC3Denum format, GC3Denum type, TexImageSource&&);
-    void texImage3D(GC3Denum target, GC3Dint level, GC3Dint internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Dint border, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&& pixels);
-    void texImage3D(GC3Denum target, GC3Dint level, GC3Dint internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Dint border, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&& srcData, GC3Duint srcOffset);
+    void texImage3D(GCGLenum target, GCGLint level, GCGLint internalformat, GCGLsizei width, GCGLsizei height, GCGLsizei depth, GCGLint border, GCGLenum format, GCGLenum type, GCGLint64 pboOffset);
+    ExceptionOr<void> texImage3D(GCGLenum target, GCGLint level, GCGLint internalformat, GCGLsizei width, GCGLsizei height, GCGLsizei depth, GCGLint border, GCGLenum format, GCGLenum type, TexImageSource&&);
+    void texImage3D(GCGLenum target, GCGLint level, GCGLint internalformat, GCGLsizei width, GCGLsizei height, GCGLsizei depth, GCGLint border, GCGLenum format, GCGLenum type, RefPtr<ArrayBufferView>&& pixels);
+    void texImage3D(GCGLenum target, GCGLint level, GCGLint internalformat, GCGLsizei width, GCGLsizei height, GCGLsizei depth, GCGLint border, GCGLenum format, GCGLenum type, RefPtr<ArrayBufferView>&& srcData, GCGLuint srcOffset);
 
     using WebGLRenderingContextBase::texSubImage2D;
-    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, GC3Dint64 pboOffset);
-    ExceptionOr<void> texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, TexImageSource&&);
-    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&& srcData, GC3Duint srcOffset);
+    void texSubImage2D(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLsizei width, GCGLsizei height, GCGLenum format, GCGLenum type, GCGLint64 pboOffset);
+    ExceptionOr<void> texSubImage2D(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLsizei width, GCGLsizei height, GCGLenum format, GCGLenum type, TexImageSource&&);
+    void texSubImage2D(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLsizei width, GCGLsizei height, GCGLenum format, GCGLenum type, RefPtr<ArrayBufferView>&& srcData, GCGLuint srcOffset);
 
-    void texSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Denum format, GC3Denum type, GC3Dint64 pboOffset);
-    void texSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&& pixels, GC3Duint srcOffset);
-    ExceptionOr<void> texSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Denum format, GC3Denum type, TexImageSource&&);
+    void texSubImage3D(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLint zoffset, GCGLsizei width, GCGLsizei height, GCGLsizei depth, GCGLenum format, GCGLenum type, GCGLint64 pboOffset);
+    void texSubImage3D(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLint zoffset, GCGLsizei width, GCGLsizei height, GCGLsizei depth, GCGLenum format, GCGLenum type, RefPtr<ArrayBufferView>&& pixels, GCGLuint srcOffset);
+    ExceptionOr<void> texSubImage3D(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLint zoffset, GCGLsizei width, GCGLsizei height, GCGLsizei depth, GCGLenum format, GCGLenum type, TexImageSource&&);
 
-    void copyTexSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
+    void copyTexSubImage3D(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLint zoffset, GCGLint x, GCGLint y, GCGLsizei width, GCGLsizei height);
 
     using WebGLRenderingContextBase::compressedTexImage2D;
-    void compressedTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Dsizei imageSize, GC3Dint64 offset);
-    void compressedTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, ArrayBufferView& data, GC3Duint srcOffset, GC3Duint srcLengthOverride);
-    void compressedTexImage3D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Dint border, GC3Dsizei imageSize, GC3Dint64 offset);
-    void compressedTexImage3D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Dint border, ArrayBufferView& srcData, GC3Duint srcOffset, GC3Duint srcLengthOverride);
+    void compressedTexImage2D(GCGLenum target, GCGLint level, GCGLenum internalformat, GCGLsizei width, GCGLsizei height, GCGLint border, GCGLsizei imageSize, GCGLint64 offset);
+    void compressedTexImage2D(GCGLenum target, GCGLint level, GCGLenum internalformat, GCGLsizei width, GCGLsizei height, GCGLint border, ArrayBufferView& data, GCGLuint srcOffset, GCGLuint srcLengthOverride);
+    void compressedTexImage3D(GCGLenum target, GCGLint level, GCGLenum internalformat, GCGLsizei width, GCGLsizei height, GCGLsizei depth, GCGLint border, GCGLsizei imageSize, GCGLint64 offset);
+    void compressedTexImage3D(GCGLenum target, GCGLint level, GCGLenum internalformat, GCGLsizei width, GCGLsizei height, GCGLsizei depth, GCGLint border, ArrayBufferView& srcData, GCGLuint srcOffset, GCGLuint srcLengthOverride);
 
     using WebGLRenderingContextBase::compressedTexSubImage2D;
     void compressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, GLintptr offset);
     void compressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, ArrayBufferView& srcData, GLuint srcOffset, GLuint srcLengthOverride);
 
-    void compressedTexSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Denum format, GC3Dsizei imageSize, GC3Dint64 offset);
-    void compressedTexSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Denum format, ArrayBufferView& data, GC3Duint srcOffset, GC3Duint srcLengthOverride);
+    void compressedTexSubImage3D(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLint zoffset, GCGLsizei width, GCGLsizei height, GCGLsizei depth, GCGLenum format, GCGLsizei imageSize, GCGLint64 offset);
+    void compressedTexSubImage3D(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLint zoffset, GCGLsizei width, GCGLsizei height, GCGLsizei depth, GCGLenum format, ArrayBufferView& data, GCGLuint srcOffset, GCGLuint srcLengthOverride);
 
     // Programs and shaders
-    GC3Dint getFragDataLocation(WebGLProgram&, const String& name);
+    GCGLint getFragDataLocation(WebGLProgram&, const String& name);
 
     // Uniforms and attributes
     using Uint32List = TypedList<Uint32Array, uint32_t>;
     using Float32List = TypedList<Float32Array, float>;
-    void uniform1ui(WebGLUniformLocation*, GC3Duint v0);
-    void uniform2ui(WebGLUniformLocation*, GC3Duint v0, GC3Duint v1);
-    void uniform3ui(WebGLUniformLocation*, GC3Duint v0, GC3Duint v1, GC3Duint v2);
-    void uniform4ui(WebGLUniformLocation*, GC3Duint v0, GC3Duint v1, GC3Duint v2, GC3Duint v3);
-    void uniform1uiv(WebGLUniformLocation*, Uint32List&& data, GC3Duint srcOffset, GC3Duint srcLength);
-    void uniform2uiv(WebGLUniformLocation*, Uint32List&& data, GC3Duint srcOffset, GC3Duint srcLength);
-    void uniform3uiv(WebGLUniformLocation*, Uint32List&& data, GC3Duint srcOffset, GC3Duint srcLength);
-    void uniform4uiv(WebGLUniformLocation*, Uint32List&& data, GC3Duint srcOffset, GC3Duint srcLength);
-    void uniformMatrix2x3fv(WebGLUniformLocation*, GC3Dboolean transpose, Float32List&& value, GC3Duint srcOffset, GC3Duint srcLength);
-    void uniformMatrix3x2fv(WebGLUniformLocation*, GC3Dboolean transpose, Float32List&& value, GC3Duint srcOffset, GC3Duint srcLength);
-    void uniformMatrix2x4fv(WebGLUniformLocation*, GC3Dboolean transpose, Float32List&& value, GC3Duint srcOffset, GC3Duint srcLength);
-    void uniformMatrix4x2fv(WebGLUniformLocation*, GC3Dboolean transpose, Float32List&& value, GC3Duint srcOffset, GC3Duint srcLength);
-    void uniformMatrix3x4fv(WebGLUniformLocation*, GC3Dboolean transpose, Float32List&& value, GC3Duint srcOffset, GC3Duint srcLength);
-    void uniformMatrix4x3fv(WebGLUniformLocation*, GC3Dboolean transpose, Float32List&& value, GC3Duint srcOffset, GC3Duint srcLength);
-    void vertexAttribI4i(GC3Duint index, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w);
-    void vertexAttribI4iv(GC3Duint index, Int32List&& v);
-    void vertexAttribI4ui(GC3Duint index, GC3Duint x, GC3Duint y, GC3Duint z, GC3Duint w);
-    void vertexAttribI4uiv(GC3Duint index, Uint32List&& v);
-    void vertexAttribIPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dsizei stride, GC3Dint64 offset);
+    void uniform1ui(WebGLUniformLocation*, GCGLuint v0);
+    void uniform2ui(WebGLUniformLocation*, GCGLuint v0, GCGLuint v1);
+    void uniform3ui(WebGLUniformLocation*, GCGLuint v0, GCGLuint v1, GCGLuint v2);
+    void uniform4ui(WebGLUniformLocation*, GCGLuint v0, GCGLuint v1, GCGLuint v2, GCGLuint v3);
+    void uniform1uiv(WebGLUniformLocation*, Uint32List&& data, GCGLuint srcOffset, GCGLuint srcLength);
+    void uniform2uiv(WebGLUniformLocation*, Uint32List&& data, GCGLuint srcOffset, GCGLuint srcLength);
+    void uniform3uiv(WebGLUniformLocation*, Uint32List&& data, GCGLuint srcOffset, GCGLuint srcLength);
+    void uniform4uiv(WebGLUniformLocation*, Uint32List&& data, GCGLuint srcOffset, GCGLuint srcLength);
+    void uniformMatrix2x3fv(WebGLUniformLocation*, GCGLboolean transpose, Float32List&& value, GCGLuint srcOffset, GCGLuint srcLength);
+    void uniformMatrix3x2fv(WebGLUniformLocation*, GCGLboolean transpose, Float32List&& value, GCGLuint srcOffset, GCGLuint srcLength);
+    void uniformMatrix2x4fv(WebGLUniformLocation*, GCGLboolean transpose, Float32List&& value, GCGLuint srcOffset, GCGLuint srcLength);
+    void uniformMatrix4x2fv(WebGLUniformLocation*, GCGLboolean transpose, Float32List&& value, GCGLuint srcOffset, GCGLuint srcLength);
+    void uniformMatrix3x4fv(WebGLUniformLocation*, GCGLboolean transpose, Float32List&& value, GCGLuint srcOffset, GCGLuint srcLength);
+    void uniformMatrix4x3fv(WebGLUniformLocation*, GCGLboolean transpose, Float32List&& value, GCGLuint srcOffset, GCGLuint srcLength);
+    void vertexAttribI4i(GCGLuint index, GCGLint x, GCGLint y, GCGLint z, GCGLint w);
+    void vertexAttribI4iv(GCGLuint index, Int32List&& v);
+    void vertexAttribI4ui(GCGLuint index, GCGLuint x, GCGLuint y, GCGLuint z, GCGLuint w);
+    void vertexAttribI4uiv(GCGLuint index, Uint32List&& v);
+    void vertexAttribIPointer(GCGLuint index, GCGLint size, GCGLenum type, GCGLsizei stride, GCGLint64 offset);
 
     using WebGLRenderingContextBase::uniform1fv;
     using WebGLRenderingContextBase::uniform2fv;
@@ -160,84 +160,84 @@ public:
     void uniformMatrix4fv(WebGLUniformLocation* location, GLboolean transpose, Float32List data, GLuint srcOffset, GLuint srcLength);
 
     // Writing to the drawing buffer
-    void clear(GC3Dbitfield mask) final;
-    void vertexAttribDivisor(GC3Duint index, GC3Duint divisor);
-    void drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei instanceCount);
-    void drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, GC3Dint64 offset, GC3Dsizei instanceCount);
-    void drawRangeElements(GC3Denum mode, GC3Duint start, GC3Duint end, GC3Dsizei count, GC3Denum type, GC3Dint64 offset);
+    void clear(GCGLbitfield mask) final;
+    void vertexAttribDivisor(GCGLuint index, GCGLuint divisor);
+    void drawArraysInstanced(GCGLenum mode, GCGLint first, GCGLsizei count, GCGLsizei instanceCount);
+    void drawElementsInstanced(GCGLenum mode, GCGLsizei count, GCGLenum type, GCGLint64 offset, GCGLsizei instanceCount);
+    void drawRangeElements(GCGLenum mode, GCGLuint start, GCGLuint end, GCGLsizei count, GCGLenum type, GCGLint64 offset);
     
     // Multiple render targets
-    void drawBuffers(const Vector<GC3Denum>& buffers);
-    void clearBufferiv(GC3Denum buffer, GC3Dint drawbuffer, Int32List&& values, GC3Duint srcOffset);
-    void clearBufferuiv(GC3Denum buffer, GC3Dint drawbuffer, Uint32List&& values, GC3Duint srcOffset);
-    void clearBufferfv(GC3Denum buffer, GC3Dint drawbuffer, Float32List&& values, GC3Duint srcOffset);
-    void clearBufferfi(GC3Denum buffer, GC3Dint drawbuffer, GC3Dfloat depth, GC3Dint stencil);
+    void drawBuffers(const Vector<GCGLenum>& buffers);
+    void clearBufferiv(GCGLenum buffer, GCGLint drawbuffer, Int32List&& values, GCGLuint srcOffset);
+    void clearBufferuiv(GCGLenum buffer, GCGLint drawbuffer, Uint32List&& values, GCGLuint srcOffset);
+    void clearBufferfv(GCGLenum buffer, GCGLint drawbuffer, Float32List&& values, GCGLuint srcOffset);
+    void clearBufferfi(GCGLenum buffer, GCGLint drawbuffer, GCGLfloat depth, GCGLint stencil);
     
     // Query objects
     RefPtr<WebGLQuery> createQuery();
     void deleteQuery(WebGLQuery*);
-    GC3Dboolean isQuery(WebGLQuery*);
-    void beginQuery(GC3Denum target, WebGLQuery&);
-    void endQuery(GC3Denum target);
-    RefPtr<WebGLQuery> getQuery(GC3Denum target, GC3Denum pname);
-    WebGLAny getQueryParameter(WebGLQuery&, GC3Denum pname);
+    GCGLboolean isQuery(WebGLQuery*);
+    void beginQuery(GCGLenum target, WebGLQuery&);
+    void endQuery(GCGLenum target);
+    RefPtr<WebGLQuery> getQuery(GCGLenum target, GCGLenum pname);
+    WebGLAny getQueryParameter(WebGLQuery&, GCGLenum pname);
     
     // Sampler objects
     RefPtr<WebGLSampler> createSampler();
     void deleteSampler(WebGLSampler*);
-    GC3Dboolean isSampler(WebGLSampler*);
-    void bindSampler(GC3Duint unit, WebGLSampler*);
-    void samplerParameteri(WebGLSampler&, GC3Denum pname, GC3Dint param);
-    void samplerParameterf(WebGLSampler&, GC3Denum pname, GC3Dfloat param);
-    WebGLAny getSamplerParameter(WebGLSampler&, GC3Denum pname);
+    GCGLboolean isSampler(WebGLSampler*);
+    void bindSampler(GCGLuint unit, WebGLSampler*);
+    void samplerParameteri(WebGLSampler&, GCGLenum pname, GCGLint param);
+    void samplerParameterf(WebGLSampler&, GCGLenum pname, GCGLfloat param);
+    WebGLAny getSamplerParameter(WebGLSampler&, GCGLenum pname);
     
     // Sync objects
-    RefPtr<WebGLSync> fenceSync(GC3Denum condition, GC3Dbitfield flags);
-    GC3Dboolean isSync(WebGLSync*);
+    RefPtr<WebGLSync> fenceSync(GCGLenum condition, GCGLbitfield flags);
+    GCGLboolean isSync(WebGLSync*);
     void deleteSync(WebGLSync*);
-    GC3Denum clientWaitSync(WebGLSync&, GC3Dbitfield flags, GC3Duint64 timeout);
-    void waitSync(WebGLSync&, GC3Dbitfield flags, GC3Dint64 timeout);
-    WebGLAny getSyncParameter(WebGLSync&, GC3Denum pname);
+    GCGLenum clientWaitSync(WebGLSync&, GCGLbitfield flags, GCGLuint64 timeout);
+    void waitSync(WebGLSync&, GCGLbitfield flags, GCGLint64 timeout);
+    WebGLAny getSyncParameter(WebGLSync&, GCGLenum pname);
     
     // Transform feedback
     RefPtr<WebGLTransformFeedback> createTransformFeedback();
     void deleteTransformFeedback(WebGLTransformFeedback* id);
-    GC3Dboolean isTransformFeedback(WebGLTransformFeedback* id);
-    void bindTransformFeedback(GC3Denum target, WebGLTransformFeedback* id);
-    void beginTransformFeedback(GC3Denum primitiveMode);
+    GCGLboolean isTransformFeedback(WebGLTransformFeedback* id);
+    void bindTransformFeedback(GCGLenum target, WebGLTransformFeedback* id);
+    void beginTransformFeedback(GCGLenum primitiveMode);
     void endTransformFeedback();
-    void transformFeedbackVaryings(WebGLProgram&, const Vector<String>& varyings, GC3Denum bufferMode);
-    RefPtr<WebGLActiveInfo> getTransformFeedbackVarying(WebGLProgram&, GC3Duint index);
+    void transformFeedbackVaryings(WebGLProgram&, const Vector<String>& varyings, GCGLenum bufferMode);
+    RefPtr<WebGLActiveInfo> getTransformFeedbackVarying(WebGLProgram&, GCGLuint index);
     void pauseTransformFeedback();
     void resumeTransformFeedback();
     
     // Uniform buffer objects and transform feedback buffers
-    void bindBufferBase(GC3Denum target, GC3Duint index, WebGLBuffer*);
-    void bindBufferRange(GC3Denum target, GC3Duint index, WebGLBuffer*, GC3Dint64 offset, GC3Dint64 size);
-    WebGLAny getIndexedParameter(GC3Denum target, GC3Duint index);
-    Optional<Vector<GC3Duint>> getUniformIndices(WebGLProgram&, const Vector<String>& uniformNames);
-    WebGLAny getActiveUniforms(WebGLProgram&, const Vector<GC3Duint>& uniformIndices, GC3Denum pname);
-    GC3Duint getUniformBlockIndex(WebGLProgram&, const String& uniformBlockName);
-    WebGLAny getActiveUniformBlockParameter(WebGLProgram&, GC3Duint uniformBlockIndex, GC3Denum pname);
-    WebGLAny getActiveUniformBlockName(WebGLProgram&, GC3Duint uniformBlockIndex);
-    void uniformBlockBinding(WebGLProgram&, GC3Duint uniformBlockIndex, GC3Duint uniformBlockBinding);
+    void bindBufferBase(GCGLenum target, GCGLuint index, WebGLBuffer*);
+    void bindBufferRange(GCGLenum target, GCGLuint index, WebGLBuffer*, GCGLint64 offset, GCGLint64 size);
+    WebGLAny getIndexedParameter(GCGLenum target, GCGLuint index);
+    Optional<Vector<GCGLuint>> getUniformIndices(WebGLProgram&, const Vector<String>& uniformNames);
+    WebGLAny getActiveUniforms(WebGLProgram&, const Vector<GCGLuint>& uniformIndices, GCGLenum pname);
+    GCGLuint getUniformBlockIndex(WebGLProgram&, const String& uniformBlockName);
+    WebGLAny getActiveUniformBlockParameter(WebGLProgram&, GCGLuint uniformBlockIndex, GCGLenum pname);
+    WebGLAny getActiveUniformBlockName(WebGLProgram&, GCGLuint uniformBlockIndex);
+    void uniformBlockBinding(WebGLProgram&, GCGLuint uniformBlockIndex, GCGLuint uniformBlockBinding);
     
     // Vertex array objects
     RefPtr<WebGLVertexArrayObject> createVertexArray();
     void deleteVertexArray(WebGLVertexArrayObject* vertexArray);
-    GC3Dboolean isVertexArray(WebGLVertexArrayObject* vertexArray);
+    GCGLboolean isVertexArray(WebGLVertexArrayObject* vertexArray);
     void bindVertexArray(WebGLVertexArrayObject* vertexArray);
     
     WebGLExtension* getExtension(const String&) final;
     Optional<Vector<String>> getSupportedExtensions() final;
-    WebGLAny getParameter(GC3Denum pname) final;
+    WebGLAny getParameter(GCGLenum pname) final;
 
     using WebGLRenderingContextBase::readPixels;
     void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLintptr offset);
     void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, ArrayBufferView& dstData, GLuint dstOffset);
 
-    void renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height) final;
-    void hint(GC3Denum target, GC3Denum mode) final;
+    void renderbufferStorage(GCGLenum target, GCGLenum internalformat, GCGLsizei width, GCGLsizei height) final;
+    void hint(GCGLenum target, GCGLenum mode) final;
 
 private:
     WebGL2RenderingContext(CanvasBase&, GraphicsContextGLAttributes);
@@ -246,20 +246,20 @@ private:
     bool isWebGL2() const final { return true; }
 
     void initializeVertexArrayObjects() final;
-    GC3Dint getMaxDrawBuffers() final;
-    GC3Dint getMaxColorAttachments() final;
-    bool validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired) final;
-    bool validateBlendEquation(const char* functionName, GC3Denum mode) final;
-    bool validateCapability(const char* functionName, GC3Denum cap) final;
-    bool validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment) final;
-    bool validateFramebufferTarget(const char* functionName, GC3Denum target);
-    bool validateNonDefaultFramebufferAttachment(const char* functionName, GC3Denum attachment);
+    GCGLint getMaxDrawBuffers() final;
+    GCGLint getMaxColorAttachments() final;
+    bool validateIndexArrayConservative(GCGLenum type, unsigned& numElementsRequired) final;
+    bool validateBlendEquation(const char* functionName, GCGLenum mode) final;
+    bool validateCapability(const char* functionName, GCGLenum cap) final;
+    bool validateFramebufferFuncParameters(const char* functionName, GCGLenum target, GCGLenum attachment) final;
+    bool validateFramebufferTarget(const char* functionName, GCGLenum target);
+    bool validateNonDefaultFramebufferAttachment(const char* functionName, GCGLenum attachment);
     
-    GC3Denum baseInternalFormatFromInternalFormat(GC3Denum internalformat);
-    bool isIntegerFormat(GC3Denum internalformat);
+    GCGLenum baseInternalFormatFromInternalFormat(GCGLenum internalformat);
+    bool isIntegerFormat(GCGLenum internalformat);
     void initializeShaderExtensions();
 
-    bool validateTexStorageFuncParameters(GC3Denum target, GC3Dsizei levels, GC3Denum internalFormat, GC3Dsizei width, GC3Dsizei height, const char* functionName);
+    bool validateTexStorageFuncParameters(GCGLenum target, GCGLsizei levels, GCGLenum internalFormat, GCGLsizei width, GCGLsizei height, const char* functionName);
 };
 
 } // namespace WebCore
index 6f43c04..ae69542 100644 (file)
@@ -35,16 +35,16 @@ namespace WebCore {
 
 class WebGLActiveInfo : public RefCounted<WebGLActiveInfo> {
 public:
-    static Ref<WebGLActiveInfo> create(const String& name, GC3Denum type, GC3Dint size)
+    static Ref<WebGLActiveInfo> create(const String& name, GCGLenum type, GCGLint size)
     {
         return adoptRef(*new WebGLActiveInfo(name, type, size));
     }
     String name() const { return m_name; }
-    GC3Denum type() const { return m_type; }
-    GC3Dint size() const { return m_size; }
+    GCGLenum type() const { return m_type; }
+    GCGLint size() const { return m_size; }
 
 private:
-    WebGLActiveInfo(const String& name, GC3Denum type, GC3Dint size)
+    WebGLActiveInfo(const String& name, GCGLenum type, GCGLint size)
         : m_name(name)
         , m_type(type)
         , m_size(size)
@@ -54,8 +54,8 @@ private:
         ASSERT(size);
     }
     String m_name;
-    GC3Denum m_type;
-    GC3Dint m_size;
+    GCGLenum m_type;
+    GCGLint m_size;
 };
 
 } // namespace WebCore
index b8ee25f..5e91526 100644 (file)
@@ -51,12 +51,12 @@ WebGLBuffer::~WebGLBuffer()
     deleteObject(0);
 }
 
-void WebGLBuffer::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, Platform3DObject object)
+void WebGLBuffer::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
 {
     context3d->deleteBuffer(object);
 }
 
-bool WebGLBuffer::associateBufferDataImpl(const void* data, GC3Dsizeiptr byteLength)
+bool WebGLBuffer::associateBufferDataImpl(const void* data, GCGLsizeiptr byteLength)
 {
     if (byteLength < 0)
         return false;
@@ -102,7 +102,7 @@ bool WebGLBuffer::associateBufferDataImpl(const void* data, GC3Dsizeiptr byteLen
     }
 }
 
-bool WebGLBuffer::associateBufferData(GC3Dsizeiptr size)
+bool WebGLBuffer::associateBufferData(GCGLsizeiptr size)
 {
     return associateBufferDataImpl(nullptr, size);
 }
@@ -121,15 +121,15 @@ bool WebGLBuffer::associateBufferData(ArrayBufferView* array)
     return associateBufferDataImpl(array->baseAddress(), array->byteLength());
 }
 
-bool WebGLBuffer::associateBufferSubDataImpl(GC3Dintptr offset, const void* data, GC3Dsizeiptr byteLength)
+bool WebGLBuffer::associateBufferSubDataImpl(GCGLintptr offset, const void* data, GCGLsizeiptr byteLength)
 {
     if (!data || offset < 0 || byteLength < 0)
         return false;
 
     if (byteLength) {
-        Checked<GC3Dintptr, RecordOverflow> checkedBufferOffset(offset);
-        Checked<GC3Dsizeiptr, RecordOverflow> checkedDataLength(byteLength);
-        Checked<GC3Dintptr, RecordOverflow> checkedBufferMax = checkedBufferOffset + checkedDataLength;
+        Checked<GCGLintptr, RecordOverflow> checkedBufferOffset(offset);
+        Checked<GCGLsizeiptr, RecordOverflow> checkedDataLength(byteLength);
+        Checked<GCGLintptr, RecordOverflow> checkedBufferMax = checkedBufferOffset + checkedDataLength;
         if (checkedBufferMax.hasOverflowed() || offset > m_byteLength || checkedBufferMax.unsafeGet() > m_byteLength)
             return false;
     }
@@ -161,34 +161,34 @@ bool WebGLBuffer::associateBufferSubDataImpl(GC3Dintptr offset, const void* data
     }
 }
 
-bool WebGLBuffer::associateBufferSubData(GC3Dintptr offset, ArrayBuffer* array)
+bool WebGLBuffer::associateBufferSubData(GCGLintptr offset, ArrayBuffer* array)
 {
     if (!array)
         return false;
     return associateBufferSubDataImpl(offset, array->data(), array->byteLength());
 }
 
-bool WebGLBuffer::associateBufferSubData(GC3Dintptr offset, ArrayBufferView* array)
+bool WebGLBuffer::associateBufferSubData(GCGLintptr offset, ArrayBufferView* array)
 {
     if (!array)
         return false;
     return associateBufferSubDataImpl(offset, array->baseAddress(), array->byteLength());
 }
 
-bool WebGLBuffer::associateCopyBufferSubData(const WebGLBuffer& readBuffer, GC3Dintptr readOffset, GC3Dintptr writeOffset, GC3Dsizeiptr size)
+bool WebGLBuffer::associateCopyBufferSubData(const WebGLBuffer& readBuffer, GCGLintptr readOffset, GCGLintptr writeOffset, GCGLsizeiptr size)
 {
     if (readOffset < 0 || writeOffset < 0 || size < 0)
         return false;
 
     if (size) {
-        Checked<GC3Dintptr, RecordOverflow> checkedReadBufferOffset(readOffset);
-        Checked<GC3Dsizeiptr, RecordOverflow> checkedDataLength(size);
-        Checked<GC3Dintptr, RecordOverflow> checkedReadBufferMax = checkedReadBufferOffset + checkedDataLength;
+        Checked<GCGLintptr, RecordOverflow> checkedReadBufferOffset(readOffset);
+        Checked<GCGLsizeiptr, RecordOverflow> checkedDataLength(size);
+        Checked<GCGLintptr, RecordOverflow> checkedReadBufferMax = checkedReadBufferOffset + checkedDataLength;
         if (checkedReadBufferMax.hasOverflowed() || readOffset > readBuffer.byteLength() || checkedReadBufferMax.unsafeGet() > readBuffer.byteLength())
             return false;
 
-        Checked<GC3Dintptr, RecordOverflow> checkedWriteBufferOffset(writeOffset);
-        Checked<GC3Dintptr, RecordOverflow> checkedWriteBufferMax = checkedWriteBufferOffset + checkedDataLength;
+        Checked<GCGLintptr, RecordOverflow> checkedWriteBufferOffset(writeOffset);
+        Checked<GCGLintptr, RecordOverflow> checkedWriteBufferMax = checkedWriteBufferOffset + checkedDataLength;
         if (checkedWriteBufferMax.hasOverflowed() || writeOffset > m_byteLength || checkedWriteBufferMax.unsafeGet() > m_byteLength)
             return false;
     }
@@ -226,12 +226,12 @@ void WebGLBuffer::disassociateBufferData()
     clearCachedMaxIndices();
 }
 
-GC3Dsizeiptr WebGLBuffer::byteLength() const
+GCGLsizeiptr WebGLBuffer::byteLength() const
 {
     return m_byteLength;
 }
 
-Optional<unsigned> WebGLBuffer::getCachedMaxIndex(GC3Denum type)
+Optional<unsigned> WebGLBuffer::getCachedMaxIndex(GCGLenum type)
 {
     for (auto& cache : m_maxIndexCache) {
         if (cache.type == type)
@@ -240,7 +240,7 @@ Optional<unsigned> WebGLBuffer::getCachedMaxIndex(GC3Denum type)
     return WTF::nullopt;
 }
 
-void WebGLBuffer::setCachedMaxIndex(GC3Denum type, unsigned value)
+void WebGLBuffer::setCachedMaxIndex(GCGLenum type, unsigned value)
 {
     for (auto& cache : m_maxIndexCache) {
         if (cache.type == type) {
@@ -253,7 +253,7 @@ void WebGLBuffer::setCachedMaxIndex(GC3Denum type, unsigned value)
     m_nextAvailableCacheEntry = (m_nextAvailableCacheEntry + 1) % WTF_ARRAY_LENGTH(m_maxIndexCache);
 }
 
-void WebGLBuffer::setTarget(GC3Denum target, bool forWebGL2)
+void WebGLBuffer::setTarget(GCGLenum target, bool forWebGL2)
 {
     // In WebGL, a buffer is bound to one target in its lifetime
     if (m_target)
index bd43cdd..9afd857 100644 (file)
@@ -42,38 +42,38 @@ public:
     static Ref<WebGLBuffer> create(WebGLRenderingContextBase&);
     virtual ~WebGLBuffer();
 
-    bool associateBufferData(GC3Dsizeiptr size);
+    bool associateBufferData(GCGLsizeiptr size);
     bool associateBufferData(JSC::ArrayBuffer*);
     bool associateBufferData(JSC::ArrayBufferView*);
-    bool associateBufferSubData(GC3Dintptr offset, JSC::ArrayBuffer*);
-    bool associateBufferSubData(GC3Dintptr offset, JSC::ArrayBufferView*);
-    bool associateCopyBufferSubData(const WebGLBuffer& readBuffer, GC3Dintptr readOffset, GC3Dintptr writeOffset, GC3Dsizeiptr);
+    bool associateBufferSubData(GCGLintptr offset, JSC::ArrayBuffer*);
+    bool associateBufferSubData(GCGLintptr offset, JSC::ArrayBufferView*);
+    bool associateCopyBufferSubData(const WebGLBuffer& readBuffer, GCGLintptr readOffset, GCGLintptr writeOffset, GCGLsizeiptr);
 
     void disassociateBufferData();
 
-    GC3Dsizeiptr byteLength() const;
+    GCGLsizeiptr byteLength() const;
     const RefPtr<JSC::ArrayBuffer> elementArrayBuffer() const { return m_elementArrayBuffer; }
 
     // Gets the cached max index for the given type if one has been set.
-    Optional<unsigned> getCachedMaxIndex(GC3Denum type);
+    Optional<unsigned> getCachedMaxIndex(GCGLenum type);
     // Sets the cached max index for the given type.
-    void setCachedMaxIndex(GC3Denum type, unsigned value);
+    void setCachedMaxIndex(GCGLenum type, unsigned value);
 
-    GC3Denum getTarget() const { return m_target; }
-    void setTarget(GC3Denum, bool forWebGL2);
+    GCGLenum getTarget() const { return m_target; }
+    void setTarget(GCGLenum, bool forWebGL2);
 
     bool hasEverBeenBound() const { return object() && m_target; }
 
 protected:
     WebGLBuffer(WebGLRenderingContextBase&);
 
-    void deleteObjectImpl(GraphicsContextGLOpenGL*, Platform3DObject) override;
+    void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) override;
 
 private:
-    GC3Denum m_target { 0 };
+    GCGLenum m_target { 0 };
 
     RefPtr<JSC::ArrayBuffer> m_elementArrayBuffer;
-    GC3Dsizeiptr m_byteLength { 0 };
+    GCGLsizeiptr m_byteLength { 0 };
 
     // Optimization for index validation. For each type of index
     // (i.e., UNSIGNED_SHORT), cache the maximum index in the
@@ -83,7 +83,7 @@ private:
     // draw call as long as all bound array buffers are at least
     // that size.
     struct MaxIndexCacheEntry {
-        GC3Denum type;
+        GCGLenum type;
         unsigned maxIndex;
     };
     // OpenGL ES 2.0 only has two valid index types (UNSIGNED_BYTE
@@ -95,9 +95,9 @@ private:
     void clearCachedMaxIndices();
 
     // Helper function called by the three associateBufferData().
-    bool associateBufferDataImpl(const void* data, GC3Dsizeiptr byteLength);
+    bool associateBufferDataImpl(const void* data, GCGLsizeiptr byteLength);
     // Helper function called by the two associateBufferSubData().
-    bool associateBufferSubDataImpl(GC3Dintptr offset, const void* data, GC3Dsizeiptr byteLength);
+    bool associateBufferSubDataImpl(GCGLintptr offset, const void* data, GCGLsizeiptr byteLength);
 };
 
 } // namespace WebCore
index ce345e6..23e13dd 100644 (file)
@@ -55,12 +55,12 @@ bool WebGLDrawBuffers::supported(WebGLRenderingContextBase& context)
 #endif
 }
 
-void WebGLDrawBuffers::drawBuffersWEBGL(const Vector<GC3Denum>& buffers)
+void WebGLDrawBuffers::drawBuffersWEBGL(const Vector<GCGLenum>& buffers)
 {
     if (m_context.isContextLost())
         return;
-    GC3Dsizei n = buffers.size();
-    const GC3Denum* bufs = buffers.data();
+    GCGLsizei n = buffers.size();
+    const GCGLenum* bufs = buffers.data();
     if (!m_context.m_framebufferBinding) {
         if (n != 1) {
             m_context.synthesizeGLError(GraphicsContextGL::INVALID_VALUE, "drawBuffersWEBGL", "more than one buffer");
@@ -71,7 +71,7 @@ void WebGLDrawBuffers::drawBuffersWEBGL(const Vector<GC3Denum>& buffers)
             return;
         }
         // Because the backbuffer is simulated on all current WebKit ports, we need to change BACK to COLOR_ATTACHMENT0.
-        GC3Denum value = (bufs[0] == GraphicsContextGL::BACK) ? GraphicsContextGL::COLOR_ATTACHMENT0 : GraphicsContextGL::NONE;
+        GCGLenum value = (bufs[0] == GraphicsContextGL::BACK) ? GraphicsContextGL::COLOR_ATTACHMENT0 : GraphicsContextGL::NONE;
         m_context.graphicsContextGL()->getExtensions().drawBuffersEXT(1, &value);
         m_context.setBackDrawBuffer(bufs[0]);
     } else {
@@ -79,8 +79,8 @@ void WebGLDrawBuffers::drawBuffersWEBGL(const Vector<GC3Denum>& buffers)
             m_context.synthesizeGLError(GraphicsContextGL::INVALID_VALUE, "drawBuffersWEBGL", "more than max draw buffers");
             return;
         }
-        for (GC3Dsizei i = 0; i < n; ++i) {
-            if (bufs[i] != GraphicsContextGL::NONE && bufs[i] != static_cast<GC3Denum>(ExtensionsGL::COLOR_ATTACHMENT0_EXT + i)) {
+        for (GCGLsizei i = 0; i < n; ++i) {
+            if (bufs[i] != GraphicsContextGL::NONE && bufs[i] != static_cast<GCGLenum>(ExtensionsGL::COLOR_ATTACHMENT0_EXT + i)) {
                 m_context.synthesizeGLError(GraphicsContextGL::INVALID_OPERATION, "drawBuffersWEBGL", "COLOR_ATTACHMENTi_EXT or NONE");
                 return;
             }
@@ -95,14 +95,14 @@ bool WebGLDrawBuffers::satisfiesWebGLRequirements(WebGLRenderingContextBase& web
     GraphicsContextGLOpenGL* context = webglContext.graphicsContextGL();
 
     // This is called after we make sure GL_EXT_draw_buffers is supported.
-    GC3Dint maxDrawBuffers = 0;
-    GC3Dint maxColorAttachments = 0;
+    GCGLint maxDrawBuffers = 0;
+    GCGLint maxColorAttachments = 0;
     context->getIntegerv(ExtensionsGL::MAX_DRAW_BUFFERS_EXT, &maxDrawBuffers);
     context->getIntegerv(ExtensionsGL::MAX_COLOR_ATTACHMENTS_EXT, &maxColorAttachments);
     if (maxDrawBuffers < 4 || maxColorAttachments < 4)
         return false;
 
-    Platform3DObject fbo = context->createFramebuffer();
+    PlatformGLObject fbo = context->createFramebuffer();
     context->bindFramebuffer(GraphicsContextGL::FRAMEBUFFER, fbo);
 
     const unsigned char buffer[4] = { 0, 0, 0, 0 }; // textures are required to be initialized for other ports.
@@ -110,24 +110,24 @@ bool WebGLDrawBuffers::satisfiesWebGLRequirements(WebGLRenderingContextBase& web
         || context->getExtensions().supports("GL_ARB_depth_texture");
     bool supportsDepthStencil = (context->getExtensions().supports("GL_EXT_packed_depth_stencil")
         || context->getExtensions().supports("GL_OES_packed_depth_stencil"));
-    Platform3DObject depthStencil = 0;
+    PlatformGLObject depthStencil = 0;
     if (supportsDepthStencil) {
         depthStencil = context->createTexture();
         context->bindTexture(GraphicsContextGL::TEXTURE_2D, depthStencil);
         context->texImage2D(GraphicsContextGL::TEXTURE_2D, 0, GraphicsContextGL::DEPTH_STENCIL, 1, 1, 0, GraphicsContextGL::DEPTH_STENCIL, GraphicsContextGL::UNSIGNED_INT_24_8, buffer);
     }
-    Platform3DObject depth = 0;
+    PlatformGLObject depth = 0;
     if (supportsDepth) {
         depth = context->createTexture();
         context->bindTexture(GraphicsContextGL::TEXTURE_2D, depth);
         context->texImage2D(GraphicsContextGL::TEXTURE_2D, 0, GraphicsContextGL::DEPTH_COMPONENT, 1, 1, 0, GraphicsContextGL::DEPTH_COMPONENT, GraphicsContextGL::UNSIGNED_INT, buffer);
     }
 
-    Vector<Platform3DObject> colors;
+    Vector<PlatformGLObject> colors;
     bool ok = true;
-    GC3Dint maxAllowedBuffers = std::min(maxDrawBuffers, maxColorAttachments);
-    for (GC3Dint i = 0; i < maxAllowedBuffers; ++i) {
-        Platform3DObject color = context->createTexture();
+    GCGLint maxAllowedBuffers = std::min(maxDrawBuffers, maxColorAttachments);
+    for (GCGLint i = 0; i < maxAllowedBuffers; ++i) {
+        PlatformGLObject color = context->createTexture();
         colors.append(color);
         context->bindTexture(GraphicsContextGL::TEXTURE_2D, color);
         context->texImage2D(GraphicsContextGL::TEXTURE_2D, 0, GraphicsContextGL::RGBA, 1, 1, 0, GraphicsContextGL::RGBA, GraphicsContextGL::UNSIGNED_BYTE, buffer);
index d7e49d3..22cc015 100644 (file)
@@ -40,7 +40,7 @@ public:
 
     ExtensionName getName() const override;
 
-    void drawBuffersWEBGL(const Vector<GC3Denum>& buffers);
+    void drawBuffersWEBGL(const Vector<GCGLenum>& buffers);
 
 private:
     static bool satisfiesWebGLRequirements(WebGLRenderingContextBase&);
index b9369f8..b967f83 100644 (file)
@@ -43,17 +43,17 @@ namespace {
 
     private:
         WebGLRenderbufferAttachment(WebGLRenderbuffer*);
-        GC3Dsizei getWidth() const override;
-        GC3Dsizei getHeight() const override;
-        GC3Denum getFormat() const override;
+        GCGLsizei getWidth() const override;
+        GCGLsizei getHeight() const override;
+        GCGLenum getFormat() const override;
         WebGLSharedObject* getObject() const override;
         bool isSharedObject(WebGLSharedObject*) const override;
         bool isValid() const override;
         bool isInitialized() const override;
         void setInitialized() override;
         void onDetached(GraphicsContextGLOpenGL*) override;
-        void attach(GraphicsContextGLOpenGL*, GC3Denum attachment) override;
-        void unattach(GraphicsContextGLOpenGL*, GC3Denum attachment) override;
+        void attach(GraphicsContextGLOpenGL*, GCGLenum attachment) override;
+        void unattach(GraphicsContextGLOpenGL*, GCGLenum attachment) override;
 
         WebGLRenderbufferAttachment() { };
 
@@ -70,17 +70,17 @@ namespace {
     {
     }
 
-    GC3Dsizei WebGLRenderbufferAttachment::getWidth() const
+    GCGLsizei WebGLRenderbufferAttachment::getWidth() const
     {
         return m_renderbuffer->getWidth();
     }
 
-    GC3Dsizei WebGLRenderbufferAttachment::getHeight() const
+    GCGLsizei WebGLRenderbufferAttachment::getHeight() const
     {
         return m_renderbuffer->getHeight();
     }
 
-    GC3Denum WebGLRenderbufferAttachment::getFormat() const
+    GCGLenum WebGLRenderbufferAttachment::getFormat() const
     {
         return m_renderbuffer->getInternalFormat();
     }
@@ -116,13 +116,13 @@ namespace {
         m_renderbuffer->onDetached(context);
     }
 
-    void WebGLRenderbufferAttachment::attach(GraphicsContextGLOpenGL* context, GC3Denum attachment)
+    void WebGLRenderbufferAttachment::attach(GraphicsContextGLOpenGL* context, GCGLenum attachment)
     {
-        Platform3DObject object = objectOrZero(m_renderbuffer.get());
+        PlatformGLObject object = objectOrZero(m_renderbuffer.get());
         context->framebufferRenderbuffer(GraphicsContextGL::FRAMEBUFFER, attachment, GraphicsContextGL::RENDERBUFFER, object);
     }
 
-    void WebGLRenderbufferAttachment::unattach(GraphicsContextGLOpenGL* context, GC3Denum attachment)
+    void WebGLRenderbufferAttachment::unattach(GraphicsContextGLOpenGL* context, GCGLenum attachment)
     {
 #if !USE(ANGLE)
         if (attachment == GraphicsContextGL::DEPTH_STENCIL_ATTACHMENT) {
@@ -135,52 +135,52 @@ namespace {
 
     class WebGLTextureAttachment : public WebGLFramebuffer::WebGLAttachment {
     public:
-        static Ref<WebGLFramebuffer::WebGLAttachment> create(WebGLTexture*, GC3Denum target, GC3Dint level);
+        static Ref<WebGLFramebuffer::WebGLAttachment> create(WebGLTexture*, GCGLenum target, GCGLint level);
 
     private:
-        WebGLTextureAttachment(WebGLTexture*, GC3Denum target, GC3Dint level);
-        GC3Dsizei getWidth() const override;
-        GC3Dsizei getHeight() const override;
-        GC3Denum getFormat() const override;
+        WebGLTextureAttachment(WebGLTexture*, GCGLenum target, GCGLint level);
+        GCGLsizei getWidth() const override;
+        GCGLsizei getHeight() const override;
+        GCGLenum getFormat() const override;
         WebGLSharedObject* getObject() const override;
         bool isSharedObject(WebGLSharedObject*) const override;
         bool isValid() const override;
         bool isInitialized() const override;
         void setInitialized() override;
         void onDetached(GraphicsContextGLOpenGL*) override;
-        void attach(GraphicsContextGLOpenGL*, GC3Denum attachment) override;
-        void unattach(GraphicsContextGLOpenGL*, GC3Denum attachment) override;
+        void attach(GraphicsContextGLOpenGL*, GCGLenum attachment) override;
+        void unattach(GraphicsContextGLOpenGL*, GCGLenum attachment) override;
 
         WebGLTextureAttachment() { };
 
         RefPtr<WebGLTexture> m_texture;
-        GC3Denum m_target;
-        GC3Dint m_level;
+        GCGLenum m_target;
+        GCGLint m_level;
     };
 
-    Ref<WebGLFramebuffer::WebGLAttachment> WebGLTextureAttachment::create(WebGLTexture* texture, GC3Denum target, GC3Dint level)
+    Ref<WebGLFramebuffer::WebGLAttachment> WebGLTextureAttachment::create(WebGLTexture* texture, GCGLenum target, GCGLint level)
     {
         return adoptRef(*new WebGLTextureAttachment(texture, target, level));
     }
 
-    WebGLTextureAttachment::WebGLTextureAttachment(WebGLTexture* texture, GC3Denum target, GC3Dint level)
+    WebGLTextureAttachment::WebGLTextureAttachment(WebGLTexture* texture, GCGLenum target, GCGLint level)
         : m_texture(texture)
         , m_target(target)
         , m_level(level)
     {
     }
 
-    GC3Dsizei WebGLTextureAttachment::getWidth() const
+    GCGLsizei WebGLTextureAttachment::getWidth() const
     {
         return m_texture->getWidth(m_target, m_level);
     }
 
-    GC3Dsizei WebGLTextureAttachment::getHeight() const
+    GCGLsizei WebGLTextureAttachment::getHeight() const
     {
         return m_texture->getHeight(m_target, m_level);
     }
 
-    GC3Denum WebGLTextureAttachment::getFormat() const
+    GCGLenum WebGLTextureAttachment::getFormat() const
     {
         return m_texture->getInternalFormat(m_target, m_level);
     }
@@ -216,13 +216,13 @@ namespace {
         m_texture->onDetached(context);
     }
 
-    void WebGLTextureAttachment::attach(GraphicsContextGLOpenGL* context, GC3Denum attachment)
+    void WebGLTextureAttachment::attach(GraphicsContextGLOpenGL* context, GCGLenum attachment)
     {
-        Platform3DObject object = objectOrZero(m_texture.get());
+        PlatformGLObject object = objectOrZero(m_texture.get());
         context->framebufferTexture2D(GraphicsContextGL::FRAMEBUFFER, attachment, m_target, object, m_level);
     }
 
-    void WebGLTextureAttachment::unattach(GraphicsContextGLOpenGL* context, GC3Denum attachment)
+    void WebGLTextureAttachment::unattach(GraphicsContextGLOpenGL* context, GCGLenum attachment)
     {
 #if !USE(ANGLE)
         if (attachment == GraphicsContextGL::DEPTH_STENCIL_ATTACHMENT) {
@@ -233,11 +233,11 @@ namespace {
             context->framebufferTexture2D(GraphicsContextGL::FRAMEBUFFER, attachment, m_target, 0, m_level);
     }
 
-    bool isAttachmentComplete(WebGLFramebuffer::WebGLAttachment* attachedObject, GC3Denum attachment, const char** reason)
+    bool isAttachmentComplete(WebGLFramebuffer::WebGLAttachment* attachedObject, GCGLenum attachment, const char** reason)
     {
         ASSERT(attachedObject && attachedObject->isValid());
         ASSERT(reason);
-        GC3Denum format = attachedObject->getFormat();
+        GCGLenum format = attachedObject->getFormat();
         unsigned need = GraphicsContextGLOpenGL::getClearBitsByAttachmentType(attachment);
         unsigned have = GraphicsContextGLOpenGL::getClearBitsByFormat(format);
 
@@ -280,7 +280,7 @@ WebGLFramebuffer::~WebGLFramebuffer()
     deleteObject(0);
 }
 
-void WebGLFramebuffer::setAttachmentForBoundFramebuffer(GC3Denum attachment, GC3Denum texTarget, WebGLTexture* texture, GC3Dint level)
+void WebGLFramebuffer::setAttachmentForBoundFramebuffer(GCGLenum attachment, GCGLenum texTarget, WebGLTexture* texture, GCGLint level)
 {
     ASSERT(isBound());
     removeAttachmentFromBoundFramebuffer(attachment);
@@ -293,7 +293,7 @@ void WebGLFramebuffer::setAttachmentForBoundFramebuffer(GC3Denum attachment, GC3
     }
 }
 
-void WebGLFramebuffer::setAttachmentForBoundFramebuffer(GC3Denum attachment, WebGLRenderbuffer* renderbuffer)
+void WebGLFramebuffer::setAttachmentForBoundFramebuffer(GCGLenum attachment, WebGLRenderbuffer* renderbuffer)
 {
     ASSERT(isBound());
     removeAttachmentFromBoundFramebuffer(attachment);
@@ -306,7 +306,7 @@ void WebGLFramebuffer::setAttachmentForBoundFramebuffer(GC3Denum attachment, Web
     }
 }
 
-void WebGLFramebuffer::attach(GC3Denum attachment, GC3Denum attachmentPoint)
+void WebGLFramebuffer::attach(GCGLenum attachment, GCGLenum attachmentPoint)
 {
     ASSERT(isBound());
     RefPtr<WebGLAttachment> attachmentObject = getAttachment(attachment);
@@ -314,7 +314,7 @@ void WebGLFramebuffer::attach(GC3Denum attachment, GC3Denum attachmentPoint)
         attachmentObject->attach(context()->graphicsContextGL(), attachmentPoint);
 }
 
-WebGLSharedObject* WebGLFramebuffer::getAttachmentObject(GC3Denum attachment) const
+WebGLSharedObject* WebGLFramebuffer::getAttachmentObject(GCGLenum attachment) const
 {
     if (!object())
         return 0;
@@ -322,13 +322,13 @@ WebGLSharedObject* WebGLFramebuffer::getAttachmentObject(GC3Denum attachment) co
     return attachmentObject ? attachmentObject->getObject() : 0;
 }
 
-WebGLFramebuffer::WebGLAttachment* WebGLFramebuffer::getAttachment(GC3Denum attachment) const
+WebGLFramebuffer::WebGLAttachment* WebGLFramebuffer::getAttachment(GCGLenum attachment) const
 {
     const AttachmentMap::const_iterator it = m_attachments.find(attachment);
     return (it != m_attachments.end()) ? it->value.get() : 0;
 }
 
-void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(GC3Denum attachment)
+void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(GCGLenum attachment)
 {
     ASSERT(isBound());
     if (!object())
@@ -370,7 +370,7 @@ void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(WebGLSharedObject* a
         for (auto& entry : m_attachments) {
             RefPtr<WebGLAttachment> attachmentObject = entry.value.get();
             if (attachmentObject->isSharedObject(attachment)) {
-                GC3Denum attachmentType = entry.key;
+                GCGLenum attachmentType = entry.key;
                 attachmentObject->unattach(context()->graphicsContextGL(), attachmentType);
                 removeAttachmentFromBoundFramebuffer(attachmentType);
                 checkMore = true;
@@ -380,7 +380,7 @@ void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(WebGLSharedObject* a
     } while (checkMore);
 }
 
-GC3Dsizei WebGLFramebuffer::getColorBufferWidth() const
+GCGLsizei WebGLFramebuffer::getColorBufferWidth() const
 {
     if (!object())
         return 0;
@@ -391,7 +391,7 @@ GC3Dsizei WebGLFramebuffer::getColorBufferWidth() const
     return attachment->getWidth();
 }
 
-GC3Dsizei WebGLFramebuffer::getColorBufferHeight() const
+GCGLsizei WebGLFramebuffer::getColorBufferHeight() const
 {
     if (!object())
         return 0;
@@ -402,7 +402,7 @@ GC3Dsizei WebGLFramebuffer::getColorBufferHeight() const
     return attachment->getHeight();
 }
 
-GC3Denum WebGLFramebuffer::getColorBufferFormat() const
+GCGLenum WebGLFramebuffer::getColorBufferFormat() const
 {
     if (!object())
         return 0;
@@ -412,10 +412,10 @@ GC3Denum WebGLFramebuffer::getColorBufferFormat() const
     return attachment->getFormat();
 }
 
-GC3Denum WebGLFramebuffer::checkStatus(const char** reason) const
+GCGLenum WebGLFramebuffer::checkStatus(const char** reason) const
 {
     unsigned int count = 0;
-    GC3Dsizei width = 0, height = 0;
+    GCGLsizei width = 0, height = 0;
     bool haveDepth = false;
     bool haveStencil = false;
     bool haveDepthStencil = false;
@@ -427,7 +427,7 @@ GC3Denum WebGLFramebuffer::checkStatus(const char** reason) const
             *reason = "attachment is not valid";
             return GraphicsContextGL::FRAMEBUFFER_UNSUPPORTED;
         }
-        GC3Denum attachmentFormat = attachment->getFormat();
+        GCGLenum attachmentFormat = attachment->getFormat();
 
         // Attaching an SRGB_EXT format attachment to a framebuffer is invalid.
         if (attachmentFormat == ExtensionsGL::SRGB_EXT)
@@ -490,7 +490,7 @@ bool WebGLFramebuffer::hasStencilBuffer() const
     return attachment && attachment->isValid();
 }
 
-void WebGLFramebuffer::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, Platform3DObject object)
+void WebGLFramebuffer::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
 {
     for (auto& attachment : m_attachments.values())
         attachment->onDetached(context3d);
@@ -501,10 +501,10 @@ void WebGLFramebuffer::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, Plat
 bool WebGLFramebuffer::initializeAttachments(GraphicsContextGLOpenGL* g3d, const char** reason)
 {
     ASSERT(object());
-    GC3Dbitfield mask = 0;
+    GCGLbitfield mask = 0;
 
     for (auto& entry : m_attachments) {
-        GC3Denum attachmentType = entry.key;
+        GCGLenum attachmentType = entry.key;
         RefPtr<WebGLAttachment> attachment = entry.value.get();
         if (!attachment->isInitialized())
             mask |= GraphicsContextGLOpenGL::getClearBitsByAttachmentType(attachmentType);
@@ -523,12 +523,12 @@ bool WebGLFramebuffer::initializeAttachments(GraphicsContextGLOpenGL* g3d, const
     bool initDepth = mask & GraphicsContextGL::DEPTH_BUFFER_BIT;
     bool initStencil = mask & GraphicsContextGL::STENCIL_BUFFER_BIT;
 
-    GC3Dfloat colorClearValue[] = {0, 0, 0, 0}, depthClearValue = 0;
-    GC3Dint stencilClearValue = 0;
-    GC3Dboolean colorMask[] = {0, 0, 0, 0}, depthMask = 0;
-    GC3Duint stencilMask = 0xffffffff;
-    GC3Dboolean isScissorEnabled = 0;
-    GC3Dboolean isDitherEnabled = 0;
+    GCGLfloat colorClearValue[] = {0, 0, 0, 0}, depthClearValue = 0;
+    GCGLint stencilClearValue = 0;
+    GCGLboolean colorMask[] = {0, 0, 0, 0}, depthMask = 0;
+    GCGLuint stencilMask = 0xffffffff;
+    GCGLboolean isScissorEnabled = 0;
+    GCGLboolean isDitherEnabled = 0;
     if (initColor) {
         g3d->getFloatv(GraphicsContextGL::COLOR_CLEAR_VALUE, colorClearValue);
         g3d->getBooleanv(GraphicsContextGL::COLOR_WRITEMASK, colorMask);
@@ -543,7 +543,7 @@ bool WebGLFramebuffer::initializeAttachments(GraphicsContextGLOpenGL* g3d, const
     }
     if (initStencil) {
         g3d->getIntegerv(GraphicsContextGL::STENCIL_CLEAR_VALUE, &stencilClearValue);
-        g3d->getIntegerv(GraphicsContextGL::STENCIL_WRITEMASK, reinterpret_cast<GC3Dint*>(&stencilMask));
+        g3d->getIntegerv(GraphicsContextGL::STENCIL_WRITEMASK, reinterpret_cast<GCGLint*>(&stencilMask));
         g3d->clearStencil(0);
         g3d->stencilMask(0xffffffff);
     }
@@ -576,9 +576,9 @@ bool WebGLFramebuffer::initializeAttachments(GraphicsContextGLOpenGL* g3d, const
         g3d->disable(GraphicsContextGL::DITHER);
 
     for (AttachmentMap::iterator it = m_attachments.begin(); it != m_attachments.end(); ++it) {
-        GC3Denum attachmentType = it->key;
+        GCGLenum attachmentType = it->key;
         auto attachment = it->value;
-        GC3Dbitfield bits = GraphicsContextGLOpenGL::getClearBitsByAttachmentType(attachmentType);
+        GCGLbitfield bits = GraphicsContextGLOpenGL::getClearBitsByAttachmentType(attachmentType);
         if (bits & mask)
             attachment->setInitialized();
     }
@@ -590,7 +590,7 @@ bool WebGLFramebuffer::isBound() const
     return (context()->m_framebufferBinding.get() == this) || (context()->m_readFramebufferBinding.get() == this);
 }
 
-void WebGLFramebuffer::drawBuffers(const Vector<GC3Denum>& bufs)
+void WebGLFramebuffer::drawBuffers(const Vector<GCGLenum>& bufs)
 {
     m_drawBuffers = bufs;
     m_filteredDrawBuffers.resize(m_drawBuffers.size());
@@ -629,7 +629,7 @@ void WebGLFramebuffer::drawBuffersIfNecessary(bool force)
     }
 }
 
-GC3Denum WebGLFramebuffer::getDrawBuffer(GC3Denum drawBuffer)
+GCGLenum WebGLFramebuffer::getDrawBuffer(GCGLenum drawBuffer)
 {
     int index = static_cast<int>(drawBuffer - ExtensionsGL::DRAW_BUFFER0_EXT);
     ASSERT(index >= 0);
index 8b4b95a..b0aeeb6 100644 (file)
@@ -44,17 +44,17 @@ public:
     public:
         virtual ~WebGLAttachment();
 
-        virtual GC3Dsizei getWidth() const = 0;
-        virtual GC3Dsizei getHeight() const = 0;
-        virtual GC3Denum getFormat() const = 0;
+        virtual GCGLsizei getWidth() const = 0;
+        virtual GCGLsizei getHeight() const = 0;
+        virtual GCGLenum getFormat() const = 0;
         virtual WebGLSharedObject* getObject() const = 0;
         virtual bool isSharedObject(WebGLSharedObject*) const = 0;
         virtual bool isValid() const = 0;
         virtual bool isInitialized() const = 0;
         virtual void setInitialized() = 0;
         virtual void onDetached(GraphicsContextGLOpenGL*) = 0;
-        virtual void attach(GraphicsContextGLOpenGL*, GC3Denum attachment) = 0;
-        virtual void unattach(GraphicsContextGLOpenGL*, GC3Denum attachment) = 0;
+        virtual void attach(GraphicsContextGLOpenGL*, GCGLenum attachment) = 0;
+        virtual void unattach(GraphicsContextGLOpenGL*, GCGLenum attachment) = 0;
 
     protected:
         WebGLAttachment();
@@ -64,17 +64,17 @@ public:
 
     static Ref<WebGLFramebuffer> create(WebGLRenderingContextBase&);
 
-    void setAttachmentForBoundFramebuffer(GC3Denum attachment, GC3Denum texTarget, WebGLTexture*, GC3Dint level);
-    void setAttachmentForBoundFramebuffer(GC3Denum attachment, WebGLRenderbuffer*);
+    void setAttachmentForBoundFramebuffer(GCGLenum attachment, GCGLenum texTarget, WebGLTexture*, GCGLint level);
+    void setAttachmentForBoundFramebuffer(GCGLenum attachment, WebGLRenderbuffer*);
     // If an object is attached to the currently bound framebuffer, remove it.
     void removeAttachmentFromBoundFramebuffer(WebGLSharedObject*);
     // If a given attachment point for the currently bound framebuffer is not null, remove the attached object.
-    void removeAttachmentFromBoundFramebuffer(GC3Denum);
-    WebGLSharedObject* getAttachmentObject(GC3Denum) const;
+    void removeAttachmentFromBoundFramebuffer(GCGLenum);
+    WebGLSharedObject* getAttachmentObject(GCGLenum) const;
 
-    GC3Denum getColorBufferFormat() const;
-    GC3Dsizei getColorBufferWidth() const;
-    GC3Dsizei getColorBufferHeight() const;
+    GCGLenum getColorBufferFormat() const;
+    GCGLsizei getColorBufferWidth() const;
+    GCGLsizei getColorBufferHeight() const;
 
     // This should always be called before drawArray, drawElements, clear,
     // readPixels, copyTexImage2D, copyTexSubImage2D if this framebuffer is
@@ -88,7 +88,7 @@ public:
     // FRAMEBUFFER_COMPLETE is returned, it is still possible for
     // glCheckFramebufferStatus() to return FRAMEBUFFER_UNSUPPORTED,
     // depending on hardware implementation.
-    GC3Denum checkStatus(const char** reason) const;
+    GCGLenum checkStatus(const char** reason) const;
 
     bool hasEverBeenBound() const { return object() && m_hasEverBeenBound; }
 
@@ -97,17 +97,17 @@ public:
     bool hasStencilBuffer() const;
 
     // Wrapper for drawBuffersEXT/drawBuffersARB to work around a driver bug.
-    void drawBuffers(const Vector<GC3Denum>& bufs);
+    void drawBuffers(const Vector<GCGLenum>& bufs);
 
-    GC3Denum getDrawBuffer(GC3Denum);
+    GCGLenum getDrawBuffer(GCGLenum);
 
 protected:
     WebGLFramebuffer(WebGLRenderingContextBase&);
 
-    void deleteObjectImpl(GraphicsContextGLOpenGL*, Platform3DObject) override;
+    void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) override;
 
 private:
-    WebGLAttachment* getAttachment(GC3Denum) const;
+    WebGLAttachment* getAttachment(GCGLenum) const;
 
     // Return false if framebuffer is incomplete.
     bool initializeAttachments(GraphicsContextGLOpenGL*, const char** reason);
@@ -116,19 +116,19 @@ private:
     bool isBound() const;
 
     // attach 'attachment' at 'attachmentPoint'.
-    void attach(GC3Denum attachment, GC3Denum attachmentPoint);
+    void attach(GCGLenum attachment, GCGLenum attachmentPoint);
 
     // Check if a new drawBuffers call should be issued. This is called when we add or remove an attachment.
     void drawBuffersIfNecessary(bool force);
 
-    typedef WTF::HashMap<GC3Denum, RefPtr<WebGLAttachment>> AttachmentMap;
+    typedef WTF::HashMap<GCGLenum, RefPtr<WebGLAttachment>> AttachmentMap;
 
     AttachmentMap m_attachments;
 
     bool m_hasEverBeenBound;
 
-    Vector<GC3Denum> m_drawBuffers;
-    Vector<GC3Denum> m_filteredDrawBuffers;
+    Vector<GCGLenum> m_drawBuffers;
+    Vector<GCGLenum> m_filteredDrawBuffers;
 };
 
 } // namespace WebCore
index af2849c..54c987a 100644 (file)
@@ -37,7 +37,7 @@
 
 namespace WebCore {
 
-void WebGLObject::setObject(Platform3DObject object)
+void WebGLObject::setObject(PlatformGLObject object)
 {
     ASSERT(!m_object);
     ASSERT(!m_deleted);
index 4924ff8..8380831 100644 (file)
@@ -27,7 +27,7 @@
 
 #if ENABLE(WEBGL)
 
-#include "GraphicsTypes3D.h"
+#include "GraphicsTypesGL.h"
 #include <wtf/RefCounted.h>
 
 namespace WebCore {
@@ -40,7 +40,7 @@ class WebGLObject : public RefCounted<WebGLObject> {
 public:
     virtual ~WebGLObject() = default;
 
-    Platform3DObject object() const { return m_object; }
+    PlatformGLObject object() const { return m_object; }
 
     // deleteObject may not always delete the OpenGL resource.  For programs and
     // shaders, deletion is delayed until they are no longer attached.
@@ -62,10 +62,10 @@ protected:
     WebGLObject() = default;
 
     // setObject should be only called once right after creating a WebGLObject.
-    void setObject(Platform3DObject);
+    void setObject(PlatformGLObject);
 
     // deleteObjectImpl should be only called once to delete the OpenGL resource.
-    virtual void deleteObjectImpl(GraphicsContextGLOpenGL*, Platform3DObject) = 0;
+    virtual void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) = 0;
 
     virtual bool hasGroupOrContext() const = 0;
 
@@ -74,12 +74,12 @@ protected:
     virtual GraphicsContextGLOpenGL* getAGraphicsContextGL() const = 0;
 
 private:
-    Platform3DObject m_object { 0 };
+    PlatformGLObject m_object { 0 };
     unsigned m_attachmentCount { 0 };
     bool m_deleted { false };
 };
 
-inline Platform3DObject objectOrZero(WebGLObject* object)
+inline PlatformGLObject objectOrZero(WebGLObject* object)
 {
     return object ? object->object() : 0;
 }
index 3efeffb..1681d7f 100644 (file)
@@ -93,7 +93,7 @@ void WebGLProgram::contextDestroyed()
     ContextDestructionObserver::contextDestroyed();
 }
 
-void WebGLProgram::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, Platform3DObject obj)
+void WebGLProgram::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject obj)
 {
     context3d->deleteProgram(obj);
     if (m_vertexShader) {
@@ -112,7 +112,7 @@ unsigned WebGLProgram::numActiveAttribLocations()
     return m_activeAttribLocations.size();
 }
 
-GC3Dint WebGLProgram::getActiveAttribLocation(GC3Duint index)
+GCGLint WebGLProgram::getActiveAttribLocation(GCGLuint index)
 {
     cacheInfoIfNeeded();
     if (index >= numActiveAttribLocations())
@@ -148,7 +148,7 @@ void WebGLProgram::increaseLinkCount()
     m_infoValid = false;
 }
 
-WebGLShader* WebGLProgram::getAttachedShader(GC3Denum type)
+WebGLShader* WebGLProgram::getAttachedShader(GCGLenum type)
 {
     switch (type) {
     case GraphicsContextGL::VERTEX_SHADER:
@@ -204,7 +204,7 @@ void WebGLProgram::cacheActiveAttribLocations(GraphicsContextGLOpenGL* context3d
 {
     m_activeAttribLocations.clear();
 
-    GC3Dint numAttribs = 0;
+    GCGLint numAttribs = 0;
     context3d->getProgramiv(object(), GraphicsContextGL::ACTIVE_ATTRIBUTES, &numAttribs);
     m_activeAttribLocations.resize(static_cast<size_t>(numAttribs));
     for (int i = 0; i < numAttribs; ++i) {
@@ -225,7 +225,7 @@ void WebGLProgram::cacheInfoIfNeeded()
     GraphicsContextGLOpenGL* context = getAGraphicsContextGL();
     if (!context)
         return;
-    GC3Dint linkStatus = 0;
+    GCGLint linkStatus = 0;
     context->getProgramiv(object(), GraphicsContextGL::LINK_STATUS, &linkStatus);
     m_linkStatus = linkStatus;
     if (m_linkStatus)
index 89b460c..8c8ad28 100644 (file)
@@ -51,7 +51,7 @@ public:
     void contextDestroyed() final;
 
     unsigned numActiveAttribLocations();
-    GC3Dint getActiveAttribLocation(GC3Duint index);
+    GCGLint getActiveAttribLocation(GCGLuint index);
 
     bool isUsingVertexAttrib0();
 
@@ -66,22 +66,22 @@ public:
     // Also, we invalidate the cached program info.
     void increaseLinkCount();
 
-    WebGLShader* getAttachedShader(GC3Denum);
+    WebGLShader* getAttachedShader(GCGLenum);
     bool attachShader(WebGLShader*);
     bool detachShader(WebGLShader*);
 
 protected:
     WebGLProgram(WebGLRenderingContextBase&);
 
-    void deleteObjectImpl(GraphicsContextGLOpenGL*, Platform3DObject) override;
+    void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) override;
 
 private:
     void cacheActiveAttribLocations(GraphicsContextGLOpenGL*);
     void cacheInfoIfNeeded();
 
-    Vector<GC3Dint> m_activeAttribLocations;
+    Vector<GCGLint> m_activeAttribLocations;
 
-    GC3Dint m_linkStatus { 0 };
+    GCGLint m_linkStatus { 0 };
 
     // This is used to track whether a WebGLUniformLocation belongs to this program or not.
     unsigned m_linkCount { 0 };
index cb64452..01dde7f 100644 (file)
@@ -49,7 +49,7 @@ WebGLQuery::WebGLQuery(WebGLRenderingContextBase& ctx)
     // FIXME: Call createQuery from GraphicsContextGLOpenGL.
 }
 
-void WebGLQuery::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, Platform3DObject object)
+void WebGLQuery::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
 {
     UNUSED_PARAM(context3d);
     UNUSED_PARAM(object);
index 087c041..556d399 100644 (file)
@@ -38,7 +38,7 @@ public:
 
 protected:
     explicit WebGLQuery(WebGLRenderingContextBase&);
-    void deleteObjectImpl(GraphicsContextGLOpenGL*, Platform3DObject) override;
+    void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) override;
 };
 
 } // namespace WebCore
index 06ee07b..a5dc164 100644 (file)
@@ -56,7 +56,7 @@ WebGLRenderbuffer::WebGLRenderbuffer(WebGLRenderingContextBase& ctx)
     setObject(ctx.graphicsContextGL()->createRenderbuffer());
 }
 
-void WebGLRenderbuffer::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, Platform3DObject object)
+void WebGLRenderbuffer::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
 {
     context3d->deleteRenderbuffer(object);
 }
index c28027e..31e9102 100644 (file)
@@ -37,20 +37,20 @@ public:
 
     static Ref<WebGLRenderbuffer> create(WebGLRenderingContextBase&);
 
-    void setInternalFormat(GC3Denum internalformat)
+    void setInternalFormat(GCGLenum internalformat)
     {
         m_internalFormat = internalformat;
         m_initialized = false;
     }
-    GC3Denum getInternalFormat() const { return m_internalFormat; }
+    GCGLenum getInternalFormat() const { return m_internalFormat; }
 
-    void setSize(GC3Dsizei width, GC3Dsizei height)
+    void setSize(GCGLsizei width, GCGLsizei height)
     {
         m_width = width;
         m_height = height;
     }
-    GC3Dsizei getWidth() const { return m_width; }
-    GC3Dsizei getHeight() const { return m_height; }
+    GCGLsizei getWidth() const { return m_width; }
+    GCGLsizei getHeight() const { return m_height; }
 
     void setIsValid(bool isValid) { m_isValid = isValid; }
     bool isValid() const { return m_isValid; }
@@ -65,14 +65,14 @@ public:
 protected:
     WebGLRenderbuffer(WebGLRenderingContextBase&);
 
-    void deleteObjectImpl(GraphicsContextGLOpenGL*, Platform3DObject) override;
+    void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) override;
 
 private:
     bool isRenderbuffer() const override { return true; }
 
-    GC3Denum m_internalFormat;
+    GCGLenum m_internalFormat;
     bool m_initialized;
-    GC3Dsizei m_width, m_height;
+    GCGLsizei m_width, m_height;
     bool m_isValid; // This is only false if internalFormat is DEPTH_STENCIL and packed_depth_stencil is not supported.
 
     bool m_hasEverBeenBound;
index 2843d46..75850dd 100644 (file)
@@ -245,7 +245,7 @@ Optional<Vector<String>> WebGLRenderingContext::getSupportedExtensions()
     return result;
 }
 
-WebGLAny WebGLRenderingContext::getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname)
+WebGLAny WebGLRenderingContext::getFramebufferAttachmentParameter(GCGLenum target, GCGLenum attachment, GCGLenum pname)
 {
     if (isContextLostOrPending() || !validateFramebufferFuncParameters("getFramebufferAttachmentParameter", target, attachment))
         return nullptr;
@@ -274,7 +274,7 @@ WebGLAny WebGLRenderingContext::getFramebufferAttachmentParameter(GC3Denum targe
         case GraphicsContextGL::FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
         case GraphicsContextGL::FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
         case ExtensionsGL::FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: {
-            GC3Dint value = 0;
+            GCGLint value = 0;
             m_context->getFramebufferAttachmentParameteriv(target, attachment, pname, &value);
             return value;
         }
@@ -295,7 +295,7 @@ WebGLAny WebGLRenderingContext::getFramebufferAttachmentParameter(GC3Denum targe
                 return nullptr;
             }
             RefPtr<WebGLRenderbuffer> renderBuffer = reinterpret_cast<WebGLRenderbuffer*>(object.get());
-            GC3Denum renderBufferFormat = renderBuffer->getInternalFormat();
+            GCGLenum renderBufferFormat = renderBuffer->getInternalFormat();
             ASSERT(renderBufferFormat != ExtensionsGL::SRGB_EXT && renderBufferFormat != ExtensionsGL::SRGB_ALPHA_EXT);
             if (renderBufferFormat == ExtensionsGL::SRGB8_ALPHA8_EXT)
                 return static_cast<unsigned>(ExtensionsGL::SRGB_EXT);
@@ -308,7 +308,7 @@ WebGLAny WebGLRenderingContext::getFramebufferAttachmentParameter(GC3Denum targe
     }
 }
 
-bool WebGLRenderingContext::validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment)
+bool WebGLRenderingContext::validateFramebufferFuncParameters(const char* functionName, GCGLenum target, GCGLenum attachment)
 {
     if (target != GraphicsContextGL::FRAMEBUFFER) {
         synthesizeGLError(GraphicsContextGL::INVALID_ENUM, functionName, "invalid target");
@@ -325,14 +325,14 @@ bool WebGLRenderingContext::validateFramebufferFuncParameters(const char* functi
     default:
         if (m_webglDrawBuffers
             && attachment >= GraphicsContextGL::COLOR_ATTACHMENT0
-            && attachment < static_cast<GC3Denum>(GraphicsContextGL::COLOR_ATTACHMENT0 + getMaxColorAttachments()))
+            && attachment < static_cast<GCGLenum>(GraphicsContextGL::COLOR_ATTACHMENT0 + getMaxColorAttachments()))
             return true;
         synthesizeGLError(GraphicsContextGL::INVALID_ENUM, functionName, "invalid attachment");
         return false;
     }
 }
     
-void WebGLRenderingContext::renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height)
+void WebGLRenderingContext::renderbufferStorage(GCGLenum target, GCGLenum internalformat, GCGLsizei width, GCGLsizei height)
 {
     if (isContextLostOrPending())
         return;
@@ -376,7 +376,7 @@ void WebGLRenderingContext::renderbufferStorage(GC3Denum target, GC3Denum intern
     applyStencilTest();
 }
 
-void WebGLRenderingContext::hint(GC3Denum target, GC3Denum mode)
+void WebGLRenderingContext::hint(GCGLenum target, GCGLenum mode)
 {
     if (isContextLostOrPending())
         return;
@@ -397,7 +397,7 @@ void WebGLRenderingContext::hint(GC3Denum target, GC3Denum mode)
     m_context->hint(target, mode);
 }
     
-void WebGLRenderingContext::clear(GC3Dbitfield mask)
+void WebGLRenderingContext::clear(GCGLbitfield mask)
 {
     if (isContextLostOrPending())
         return;
@@ -415,7 +415,7 @@ void WebGLRenderingContext::clear(GC3Dbitfield mask)
     markContextChangedAndNotifyCanvasObserver();
 }
 
-WebGLAny WebGLRenderingContext::getParameter(GC3Denum pname)
+WebGLAny WebGLRenderingContext::getParameter(GCGLenum pname)
 {
     if (isContextLostOrPending())
         return nullptr;
@@ -649,8 +649,8 @@ WebGLAny WebGLRenderingContext::getParameter(GC3Denum pname)
     default:
         if (m_webglDrawBuffers
             && pname >= ExtensionsGL::DRAW_BUFFER0_EXT
-            && pname < static_cast<GC3Denum>(ExtensionsGL::DRAW_BUFFER0_EXT + getMaxDrawBuffers())) {
-            GC3Dint value = GraphicsContextGL::NONE;
+            && pname < static_cast<GCGLenum>(ExtensionsGL::DRAW_BUFFER0_EXT + getMaxDrawBuffers())) {
+            GCGLint value = GraphicsContextGL::NONE;
             if (m_framebufferBinding)
                 value = m_framebufferBinding->getDrawBuffer(pname);
             else // emulated backbuffer
@@ -662,7 +662,7 @@ WebGLAny WebGLRenderingContext::getParameter(GC3Denum pname)
     }
 }
 
-GC3Dint WebGLRenderingContext::getMaxDrawBuffers()
+GCGLint WebGLRenderingContext::getMaxDrawBuffers()
 {
     if (!supportsDrawBuffers())
         return 0;
@@ -674,7 +674,7 @@ GC3Dint WebGLRenderingContext::getMaxDrawBuffers()
     return std::min(m_maxDrawBuffers, m_maxColorAttachments);
 }
 
-GC3Dint WebGLRenderingContext::getMaxColorAttachments()
+GCGLint WebGLRenderingContext::getMaxColorAttachments()
 {
     if (!supportsDrawBuffers())
         return 0;
@@ -683,7 +683,7 @@ GC3Dint WebGLRenderingContext::getMaxColorAttachments()
     return m_maxColorAttachments;
 }
     
-bool WebGLRenderingContext::validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired)
+bool WebGLRenderingContext::validateIndexArrayConservative(GCGLenum type, unsigned& numElementsRequired)
 {
     // Performs conservative validation by caching a maximum index of
     // the given type per element array buffer. If all of the bound
@@ -696,7 +696,7 @@ bool WebGLRenderingContext::validateIndexArrayConservative(GC3Denum type, unsign
     if (!elementArrayBuffer)
         return false;
     
-    GC3Dsizeiptr numElements = elementArrayBuffer->byteLength();
+    GCGLsizeiptr numElements = elementArrayBuffer->byteLength();
     // The case count==0 is already dealt with in drawElements before validateIndexArrayConservative.
     if (!numElements)
         return false;
@@ -708,24 +708,24 @@ bool WebGLRenderingContext::validateIndexArrayConservative(GC3Denum type, unsign
         // Compute the maximum index in the entire buffer for the given type of index.
         switch (type) {
         case GraphicsContextGL::UNSIGNED_BYTE: {
-            const GC3Dubyte* p = static_cast<const GC3Dubyte*>(buffer->data());
-            for (GC3Dsizeiptr i = 0; i < numElements; i++)
+            const GCGLubyte* p = static_cast<const GCGLubyte*>(buffer->data());
+            for (GCGLsizeiptr i = 0; i < numElements; i++)
                 maxIndex = maxIndex ? std::max(maxIndex.value(), static_cast<unsigned>(p[i])) : static_cast<unsigned>(p[i]);
             break;
         }
         case GraphicsContextGL::UNSIGNED_SHORT: {
-            numElements /= sizeof(GC3Dushort);
-            const GC3Dushort* p = static_cast<const GC3Dushort*>(buffer->data());
-            for (GC3Dsizeiptr i = 0; i < numElements; i++)
+            numElements /= sizeof(GCGLushort);
+            const GCGLushort* p = static_cast<const GCGLushort*>(buffer->data());
+            for (GCGLsizeiptr i = 0; i < numElements; i++)
                 maxIndex = maxIndex ? std::max(maxIndex.value(), static_cast<unsigned>(p[i])) : static_cast<unsigned>(p[i]);
             break;
         }
         case GraphicsContextGL::UNSIGNED_INT: {
             if (!m_oesElementIndexUint)
                 return false;
-            numElements /= sizeof(GC3Duint);
-            const GC3Duint* p = static_cast<const GC3Duint*>(buffer->data());
-            for (GC3Dsizeiptr i = 0; i < numElements; i++)
+            numElements /= sizeof(GCGLuint);
+            const GCGLuint* p = static_cast<const GCGLuint*>(buffer->data());
+            for (GCGLsizeiptr i = 0; i < numElements; i++)
                 maxIndex = maxIndex ? std::max(maxIndex.value(), static_cast<unsigned>(p[i])) : static_cast<unsigned>(p[i]);
             break;
         }
@@ -748,7 +748,7 @@ bool WebGLRenderingContext::validateIndexArrayConservative(GC3Denum type, unsign
     return true;
 }
 
-bool WebGLRenderingContext::validateBlendEquation(const char* functionName, GC3Denum mode)
+bool WebGLRenderingContext::validateBlendEquation(const char* functionName, GCGLenum mode)
 {
     switch (mode) {
     case GraphicsContextGL::FUNC_ADD:
@@ -768,7 +768,7 @@ bool WebGLRenderingContext::validateBlendEquation(const char* functionName, GC3D
     }
 }
 
-bool WebGLRenderingContext::validateCapability(const char* functionName, GC3Denum cap)
+bool WebGLRenderingContext::validateCapability(const char* functionName, GCGLenum cap)
 {
     switch (cap) {
     case GraphicsContextGL::BLEND:
index e8e3688..3550c40 100644 (file)
@@ -41,21 +41,21 @@ public:
     bool isWebGL1() const final { return true; }
 
     WebGLExtension* getExtension(const String&) final;
-    WebGLAny getParameter(GC3Denum pname) final;
+    WebGLAny getParameter(GCGLenum pname) final;
     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;
-    bool validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment) final;
-    void hint(GC3Denum target, GC3Denum mode) final;
-    void clear(GC3Dbitfield mask) final;
+    WebGLAny getFramebufferAttachmentParameter(GCGLenum target, GCGLenum attachment, GCGLenum pname) final;
+    void renderbufferStorage(GCGLenum target, GCGLenum internalformat, GCGLsizei width, GCGLsizei height) final;
+    bool validateFramebufferFuncParameters(const char* functionName, GCGLenum target, GCGLenum attachment) final;
+    void hint(GCGLenum target, GCGLenum mode) final;
+    void clear(GCGLbitfield mask) final;
 
-    GC3Dint getMaxDrawBuffers() final;
-    GC3Dint getMaxColorAttachments() final;
+    GCGLint getMaxDrawBuffers() final;
+    GCGLint getMaxColorAttachments() final;
     void initializeVertexArrayObjects() final;
-    bool validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired) final;
-    bool validateBlendEquation(const char* functionName, GC3Denum mode) final;
-    bool validateCapability(const char* functionName, GC3Denum cap) final;
+    bool validateIndexArrayConservative(GCGLenum type, unsigned& numElementsRequired) final;
+    bool validateBlendEquation(const char* functionName, GCGLenum mode) final;
+    bool validateCapability(const char* functionName, GCGLenum cap) final;
 
 private:
     WebGLRenderingContext(CanvasBase&, GraphicsContextGLAttributes);
index 0c2fc84..17eaa5d 100644 (file)
@@ -122,7 +122,7 @@ static const Seconds checkContextLossHandlingDelay { 3_s };
 
 namespace {
     
-    GC3Dint clamp(GC3Dint value, GC3Dint min, GC3Dint max)
+    GCGLint clamp(GCGLint value, GCGLint min, GCGLint max)
     {
         if (value < min)
             value = min;
@@ -339,19 +339,19 @@ namespace {
 } // namespace anonymous
 
 // Returns false if no clipping is necessary, i.e., x, y, width, height stay the same.
-static bool clip2D(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height,
-    GC3Dsizei sourceWidth, GC3Dsizei sourceHeight,
-    GC3Dint* clippedX, GC3Dint* clippedY, GC3Dsizei* clippedWidth, GC3Dsizei*clippedHeight)
+static bool clip2D(GCGLint x, GCGLint y, GCGLsizei width, GCGLsizei height,
+    GCGLsizei sourceWidth, GCGLsizei sourceHeight,
+    GCGLint* clippedX, GCGLint* clippedY, GCGLsizei* clippedWidth, GCGLsizei*clippedHeight)
 {
     ASSERT(clippedX && clippedY && clippedWidth && clippedHeight);
 
-    GC3Dint left = std::max(x, 0);
-    GC3Dint top = std::max(y, 0);
-    GC3Dint right = 0;
-    GC3Dint bottom = 0;
+    GCGLint left = std::max(x, 0);
+    GCGLint top = std::max(y, 0);
+    GCGLint right = 0;
+    GCGLint bottom = 0;
 
-    Checked<GC3Dint, RecordOverflow> checkedInputRight = Checked<GC3Dint>(x) + Checked<GC3Dsizei>(width);
-    Checked<GC3Dint, RecordOverflow> checkedInputBottom = Checked<GC3Dint>(y) + Checked<GC3Dsizei>(height);
+    Checked<GCGLint, RecordOverflow> checkedInputRight = Checked<GCGLint>(x) + Checked<GCGLsizei>(width);
+    Checked<GCGLint, RecordOverflow> checkedInputBottom = Checked<GCGLint>(y) + Checked<GCGLsizei>(height);
     if (!checkedInputRight.hasOverflowed() && !checkedInputBottom.hasOverflowed()) {
         right = std::min(checkedInputRight.unsafeGet(), sourceWidth);
         bottom = std::min(checkedInputBottom.unsafeGet(), sourceHeight);
@@ -415,10 +415,10 @@ private:
         saveBlendValue(GraphicsContextGL::BLEND_DST_ALPHA, m_savedBlend.dstAlpha);
         saveBlendValue(GraphicsContextGL::BLEND, m_savedBlend.enabled);
 
-        static const GC3Dfloat red = 111.0 / 255.0;
-        static const GC3Dfloat green = 168.0 / 255.0;
-        static const GC3Dfloat blue = 220.0 / 255.0;
-        static const GC3Dfloat alpha = 2.0 / 3.0;
+        static const GCGLfloat red = 111.0 / 255.0;
+        static const GCGLfloat green = 168.0 / 255.0;
+        static const GCGLfloat blue = 220.0 / 255.0;
+        static const GCGLfloat alpha = 2.0 / 3.0;
 
         m_context.enable(GraphicsContextGL::BLEND);
         m_context.blendColor(red, green, blue, alpha);
@@ -447,14 +447,14 @@ private:
     }
 
     template <typename T>
-    void saveBlendValue(GC3Denum attachment, T& destination)
+    void saveBlendValue(GCGLenum attachment, T& destination)
     {
         WebGLAny param = m_context.getParameter(attachment);
         if (WTF::holds_alternative<T>(param))
             destination = WTF::get<T>(param);
     }
 
-    bool hasBufferBinding(GC3Denum pname)
+    bool hasBufferBinding(GCGLenum pname)
     {
         WebGLAny binding = m_context.getParameter(pname);
         if (pname == GraphicsContextGL::FRAMEBUFFER_BINDING)
@@ -464,7 +464,7 @@ private:
         return false;
     }
 
-    bool hasFramebufferParameterAttachment(GC3Denum attachment)
+    bool hasFramebufferParameterAttachment(GCGLenum attachment)
     {
         WebGLAny attachmentParameter = m_context.getFramebufferAttachmentParameter(GraphicsContextGL::FRAMEBUFFER, attachment, GraphicsContextGL::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE);
         if (!WTF::holds_alternative<unsigned>(attachmentParameter))
@@ -746,14 +746,14 @@ void WebGLRenderingContextBase::initializeNewContext()
     m_clearStencil = 0;
     m_colorMask[0] = m_colorMask[1] = m_colorMask[2] = m_colorMask[3] = true;
 
-    GC3Dint numCombinedTextureImageUnits = 0;
+    GCGLint numCombinedTextureImageUnits = 0;
     m_context->getIntegerv(GraphicsContextGL::MAX_COMBINED_TEXTURE_IMAGE_UNITS, &numCombinedTextureImageUnits);
     m_textureUnits.clear();
     m_textureUnits.resize(numCombinedTextureImageUnits);
-    for (GC3Dint i = 0; i < numCombinedTextureImageUnits; ++i)
+    for (GCGLint i = 0; i < numCombinedTextureImageUnits; ++i)
         m_unrenderableTextureUnits.add(i);
 
-    GC3Dint numVertexAttribs = 0;
+    GCGLint numVertexAttribs = 0;
     m_context->getIntegerv(GraphicsContextGL::MAX_VERTEX_ATTRIBS, &numVertexAttribs);
     m_maxVertexAttribs = numVertexAttribs;
     
@@ -806,7 +806,7 @@ void WebGLRenderingContextBase::setupFlags()
     m_isRobustnessEXTSupported = m_context->getExtensions().isEnabled("GL_EXT_robustness");
 }
 
-void WebGLRenderingContextBase::addCompressedTextureFormat(GC3Denum format)
+void WebGLRenderingContextBase::addCompressedTextureFormat(GCGLenum format)
 {
     if (!m_compressedTextureFormats.contains(format))
         m_compressedTextureFormats.append(format);
@@ -937,7 +937,7 @@ void WebGLRenderingContextBase::markContextChangedAndNotifyCanvasObserver()
         canvas->notifyObserversCanvasChanged(FloatRect(FloatPoint(0, 0), clampedCanvasSize()));
 }
 
-bool WebGLRenderingContextBase::clearIfComposited(GC3Dbitfield mask)
+bool WebGLRenderingContextBase::clearIfComposited(GCGLbitfield mask)
 {
     if (isContextLostOrPending())
         return false;
@@ -962,7 +962,7 @@ bool WebGLRenderingContextBase::clearIfComposited(GC3Dbitfield mask)
     } else
         m_context->clearColor(0, 0, 0, 0);
     m_context->colorMask(true, true, true, true);
-    GC3Dbitfield clearMask = GraphicsContextGL::COLOR_BUFFER_BIT;
+    GCGLbitfield clearMask = GraphicsContextGL::COLOR_BUFFER_BIT;
     if (contextAttributes->depth) {
         if (!combinedClear || !m_depthMask || !(mask & GraphicsContextGL::DEPTH_BUFFER_BIT))
             m_context->clearDepth(1.0f);
@@ -1062,9 +1062,9 @@ void WebGLRenderingContextBase::reshape(int width, int height)
 
     // This is an approximation because at WebGLRenderingContext level we don't
     // know if the underlying FBO uses textures or renderbuffers.
-    GC3Dint maxSize = std::min(m_maxTextureSize, m_maxRenderbufferSize);
-    GC3Dint maxWidth = std::min(maxSize, m_maxViewportDims[0]);
-    GC3Dint maxHeight = std::min(maxSize, m_maxViewportDims[1]);
+    GCGLint maxSize = std::min(m_maxTextureSize, m_maxRenderbufferSize);
+    GCGLint maxWidth = std::min(maxSize, m_maxViewportDims[0]);
+    GCGLint maxHeight = std::min(maxSize, m_maxViewportDims[1]);
     width = clamp(width, 1, maxWidth);
     height = clamp(height, 1, maxHeight);
 
@@ -1108,29 +1108,29 @@ int WebGLRenderingContextBase::drawingBufferHeight() const
     return m_context->getInternalFramebufferSize().height();
 }
 
-unsigned WebGLRenderingContextBase::sizeInBytes(GC3Denum type)
+unsigned WebGLRenderingContextBase::sizeInBytes(GCGLenum type)
 {
     switch (type) {
     case GraphicsContextGL::BYTE:
-        return sizeof(GC3Dbyte);
+        return sizeof(GCGLbyte);
     case GraphicsContextGL::UNSIGNED_BYTE:
-        return sizeof(GC3Dubyte);
+        return sizeof(GCGLubyte);
     case GraphicsContextGL::SHORT:
-        return sizeof(GC3Dshort);
+        return sizeof(GCGLshort);
     case GraphicsContextGL::UNSIGNED_SHORT:
-        return sizeof(GC3Dushort);
+        return sizeof(GCGLushort);
     case GraphicsContextGL::INT:
-        return sizeof(GC3Dint);
+        return sizeof(GCGLint);
     case GraphicsContextGL::UNSIGNED_INT:
-        return sizeof(GC3Duint);
+        return sizeof(GCGLuint);
     case GraphicsContextGL::FLOAT:
-        return sizeof(GC3Dfloat);
+        return sizeof(GCGLfloat);
     }
     ASSERT_NOT_REACHED();
     return 0;
 }
 
-void WebGLRenderingContextBase::activeTexture(GC3Denum texture)
+void WebGLRenderingContextBase::activeTexture(GCGLenum texture)
 {
     if (isContextLostOrPending())
         return;
@@ -1154,7 +1154,7 @@ void WebGLRenderingContextBase::attachShader(WebGLProgram* program, WebGLShader*
     shader->onAttached();
 }
 
-void WebGLRenderingContextBase::bindAttribLocation(WebGLProgram* program, GC3Duint index, const String& name)
+void WebGLRenderingContextBase::bindAttribLocation(WebGLProgram* program, GCGLuint index, const String& name)
 {
     if (isContextLostOrPending() || !validateWebGLObject("bindAttribLocation", program))
         return;
@@ -1188,7 +1188,7 @@ bool WebGLRenderingContextBase::checkObjectToBeBound(const char* functionName, W
     return true;
 }
 
-void WebGLRenderingContextBase::bindBuffer(GC3Denum target, WebGLBuffer* buffer)
+void WebGLRenderingContextBase::bindBuffer(GCGLenum target, WebGLBuffer* buffer)
 {
     bool deleted;
     if (!checkObjectToBeBound("bindBuffer", buffer, deleted))
@@ -1244,7 +1244,7 @@ void WebGLRenderingContextBase::bindBuffer(GC3Denum target, WebGLBuffer* buffer)
         buffer->setTarget(target, isWebGL2());
 }
 
-void WebGLRenderingContextBase::bindFramebuffer(GC3Denum target, WebGLFramebuffer* buffer)
+void WebGLRenderingContextBase::bindFramebuffer(GCGLenum target, WebGLFramebuffer* buffer)
 {
     bool deleted;
     if (!checkObjectToBeBound("bindFramebuffer", buffer, deleted))
@@ -1280,7 +1280,7 @@ void WebGLRenderingContextBase::bindFramebuffer(GC3Denum target, WebGLFramebuffe
     applyStencilTest();
 }
 
-void WebGLRenderingContextBase::bindRenderbuffer(GC3Denum target, WebGLRenderbuffer* renderBuffer)
+void WebGLRenderingContextBase::bindRenderbuffer(GCGLenum target, WebGLRenderbuffer* renderBuffer)
 {
     bool deleted;
     if (!checkObjectToBeBound("bindRenderbuffer", renderBuffer, deleted))
@@ -1297,7 +1297,7 @@ void WebGLRenderingContextBase::bindRenderbuffer(GC3Denum target, WebGLRenderbuf
         renderBuffer->setHasEverBeenBound();
 }
 
-void WebGLRenderingContextBase::bindTexture(GC3Denum target, WebGLTexture* texture)
+void WebGLRenderingContextBase::bindTexture(GCGLenum target, WebGLTexture* texture)
 {
     bool deleted;
     if (!checkObjectToBeBound("bindTexture", texture, deleted))
@@ -1308,7 +1308,7 @@ void WebGLRenderingContextBase::bindTexture(GC3Denum target, WebGLTexture* textu
         synthesizeGLError(GraphicsContextGL::INVALID_OPERATION, "bindTexture", "textures can not be used with multiple targets");
         return;
     }
-    GC3Dint maxLevel = 0;
+    GCGLint maxLevel = 0;
     auto& textureUnit = m_textureUnits[m_activeTextureUnit];
     if (target == GraphicsContextGL::TEXTURE_2D) {
         textureUnit.texture2DBinding = texture;
@@ -1342,21 +1342,21 @@ void WebGLRenderingContextBase::bindTexture(GC3Denum target, WebGLTexture* textu
     // been removed.
 }
 
-void WebGLRenderingContextBase::blendColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha)
+void WebGLRenderingContextBase::blendColor(GCGLfloat red, GCGLfloat green, GCGLfloat blue, GCGLfloat alpha)
 {
     if (isContextLostOrPending())
         return;
     m_context->blendColor(red, green, blue, alpha);
 }
 
-void WebGLRenderingContextBase::blendEquation(GC3Denum mode)
+void WebGLRenderingContextBase::blendEquation(GCGLenum mode)
 {
     if (isContextLostOrPending() || !validateBlendEquation("blendEquation", mode))
         return;
     m_context->blendEquation(mode);
 }
 
-void WebGLRenderingContextBase::blendEquationSeparate(GC3Denum modeRGB, GC3Denum modeAlpha)
+void WebGLRenderingContextBase::blendEquationSeparate(GCGLenum modeRGB, GCGLenum modeAlpha)
 {
     if (isContextLostOrPending() || !validateBlendEquation("blendEquation", modeRGB) || !validateBlendEquation("blendEquation", modeAlpha))
         return;
@@ -1364,14 +1364,14 @@ void WebGLRenderingContextBase::blendEquationSeparate(GC3Denum modeRGB, GC3Denum
 }
 
 
-void WebGLRenderingContextBase::blendFunc(GC3Denum sfactor, GC3Denum dfactor)
+void WebGLRenderingContextBase::blendFunc(GCGLenum sfactor, GCGLenum dfactor)
 {
     if (isContextLostOrPending() || !validateBlendFuncFactors("blendFunc", sfactor, dfactor))
         return;
     m_context->blendFunc(sfactor, dfactor);
 }
 
-void WebGLRenderingContextBase::blendFuncSeparate(GC3Denum srcRGB, GC3Denum dstRGB, GC3Denum srcAlpha, GC3Denum dstAlpha)
+void WebGLRenderingContextBase::blendFuncSeparate(GCGLenum srcRGB, GCGLenum dstRGB, GCGLenum srcAlpha, GCGLenum dstAlpha)
 {
     // Note: Alpha does not have the same restrictions as RGB.
     if (isContextLostOrPending() || !validateBlendFuncFactors("blendFunc", srcRGB, dstRGB))
@@ -1379,7 +1379,7 @@ void WebGLRenderingContextBase::blendFuncSeparate(GC3Denum srcRGB, GC3Denum dstR
     m_context->blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
-void WebGLRenderingContextBase::bufferData(GC3Denum target, long long size, GC3Denum usage)
+void WebGLRenderingContextBase::bufferData(GCGLenum target, long long size, GCGLenum usage)
 {
     if (isContextLostOrPending())
         return;
@@ -1394,20 +1394,20 @@ void WebGLRenderingContextBase::bufferData(GC3Denum target, long long size, GC3D
         synthesizeGLError(GraphicsContextGL::INVALID_VALUE, "bufferData", "size == 0");
         return;
     }
-    if (!buffer->associateBufferData(static_cast<GC3Dsizeiptr>(size))) {
+    if (!buffer->associateBufferData(static_cast<GCGLsizeiptr>(size))) {
         synthesizeGLError(GraphicsContextGL::INVALID_VALUE, "bufferData", "invalid buffer");
         return;
     }
 
     m_context->moveErrorsToSyntheticErrorList();
-    m_context->bufferData(target, static_cast<GC3Dsizeiptr>(size), usage);
+    m_context->bufferData(target, static_cast<GCGLsizeiptr>(size), usage);
     if (m_context->moveErrorsToSyntheticErrorList()) {
         // The bufferData function failed. Tell the buffer it doesn't have the data it thinks it does.
         buffer->disassociateBufferData();
     }
 }
 
-void WebGLRenderingContextBase::bufferData(GC3Denum target, Optional<BufferDataSource>&& data, GC3Denum usage)
+void WebGLRenderingContextBase::bufferData(GCGLenum target, Optional<BufferDataSource>&& data, GCGLenum usage)
 {
     if (isContextLostOrPending())
         return;
@@ -1434,7 +1434,7 @@ void WebGLRenderingContextBase::bufferData(GC3Denum target, Optional<BufferDataS
     }, data.value());
 }
 
-void WebGLRenderingContextBase::bufferSubData(GC3Denum target, long long offset, Optional<BufferDataSource>&& data)
+void WebGLRenderingContextBase::bufferSubData(GCGLenum target, long long offset, Optional<BufferDataSource>&& data)
 {
     if (isContextLostOrPending())
         return;
@@ -1449,13 +1449,13 @@ void WebGLRenderingContextBase::bufferSubData(GC3Denum target, long long offset,
         return;
 
     WTF::visit([&](auto& data) {
-        if (!buffer->associateBufferSubData(static_cast<GC3Dintptr>(offset), data.get())) {
+        if (!buffer->associateBufferSubData(static_cast<GCGLintptr>(offset), data.get())) {
             this->synthesizeGLError(GraphicsContextGL::INVALID_VALUE, "bufferSubData", "offset out of range");
             return;
         }
 
         m_context->moveErrorsToSyntheticErrorList();
-        m_context->bufferSubData(target, static_cast<GC3Dintptr>(offset), data->byteLength(), data->data());
+        m_context->bufferSubData(target, static_cast<GCGLintptr>(offset), data->byteLength(), data->data());
         if (m_context->moveErrorsToSyntheticErrorList()) {
             // The bufferSubData function failed. Tell the buffer it doesn't have the data it thinks it does.
             buffer->disassociateBufferData();
@@ -1463,7 +1463,7 @@ void WebGLRenderingContextBase::bufferSubData(GC3Denum target, long long offset,
     }, data.value());
 }
 
-GC3Denum WebGLRenderingContextBase::checkFramebufferStatus(GC3Denum target)
+GCGLenum WebGLRenderingContextBase::checkFramebufferStatus(GCGLenum target)
 {
     if (isContextLostOrPending())
         return GraphicsContextGL::FRAMEBUFFER_UNSUPPORTED;
@@ -1483,7 +1483,7 @@ GC3Denum WebGLRenderingContextBase::checkFramebufferStatus(GC3Denum target)
     if (!targetFramebuffer || !targetFramebuffer->object())
         return GraphicsContextGL::FRAMEBUFFER_COMPLETE;
     const char* reason = "framebuffer incomplete";
-    GC3Denum result = targetFramebuffer->checkStatus(&reason);
+    GCGLenum result = targetFramebuffer->checkStatus(&reason);
     if (result != GraphicsContextGL::FRAMEBUFFER_COMPLETE) {
         String str = "WebGL: checkFramebufferStatus:" + String(reason);
         printToConsole(MessageLevel::Warning, str);
@@ -1493,7 +1493,7 @@ GC3Denum WebGLRenderingContextBase::checkFramebufferStatus(GC3Denum target)
     return result;
 }
 
-void WebGLRenderingContextBase::clearColor(GC3Dfloat r, GC3Dfloat g, GC3Dfloat b, GC3Dfloat a)
+void WebGLRenderingContextBase::clearColor(GCGLfloat r, GCGLfloat g, GCGLfloat b, GCGLfloat a)
 {
     if (isContextLostOrPending())
         return;
@@ -1512,7 +1512,7 @@ void WebGLRenderingContextBase::clearColor(GC3Dfloat r, GC3Dfloat g, GC3Dfloat b
     m_context->clearColor(r, g, b, a);
 }
 
-void WebGLRenderingContextBase::clearDepth(GC3Dfloat depth)
+void WebGLRenderingContextBase::clearDepth(GCGLfloat depth)
 {
     if (isContextLostOrPending())
         return;
@@ -1520,7 +1520,7 @@ void WebGLRenderingContextBase::clearDepth(GC3Dfloat depth)
     m_context->clearDepth(depth);
 }
 
-void WebGLRenderingContextBase::clearStencil(GC3Dint s)
+void WebGLRenderingContextBase::clearStencil(GCGLint s)
 {
     if (isContextLostOrPending())
         return;
@@ -1528,7 +1528,7 @@ void WebGLRenderingContextBase::clearStencil(GC3Dint s)
     m_context->clearStencil(s);
 }
 
-void WebGLRenderingContextBase::colorMask(GC3Dboolean red, GC3Dboolean green, GC3Dboolean blue, GC3Dboolean alpha)
+void WebGLRenderingContextBase::colorMask(GCGLboolean red, GCGLboolean green, GCGLboolean blue, GCGLboolean alpha)
 {
     if (isContextLostOrPending())
         return;
@@ -1544,7 +1544,7 @@ void WebGLRenderingContextBase::compileShader(WebGLShader* shader)
     if (isContextLostOrPending() || !validateWebGLObject("compileShader", shader))
         return;
     m_context->compileShader(objectOrZero(shader));
-    GC3Dint value;
+    GCGLint value;
     m_context->getShaderiv(objectOrZero(shader), GraphicsContextGL::COMPILE_STATUS, &value);
     shader->setValid(value);
 
@@ -1558,7 +1558,7 @@ void WebGLRenderingContextBase::compileShader(WebGLShader* shader)
     }
 }
 
-void WebGLRenderingContextBase::compressedTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, ArrayBufferView& data)
+void WebGLRenderingContextBase::compressedTexImage2D(GCGLenum target, GCGLint level, GCGLenum internalformat, GCGLsizei width, GCGLsizei height, GCGLint border, ArrayBufferView& data)
 {
     if (isContextLostOrPending())
         return;
@@ -1596,7 +1596,7 @@ void WebGLRenderingContextBase::compressedTexImage2D(GC3Denum target, GC3Dint le
     tex->setCompressed();
 }
 
-void WebGLRenderingContextBase::compressedTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, ArrayBufferView& data)
+void WebGLRenderingContextBase::compressedTexSubImage2D(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLsizei width, GCGLsizei height, GCGLenum format, ArrayBufferView& data)
 {
     if (isContextLostOrPending())
         return;
@@ -1625,7 +1625,7 @@ void WebGLRenderingContextBase::compressedTexSubImage2D(GC3Denum target, GC3Dint
     tex->setCompressed();
 }
 
-bool WebGLRenderingContextBase::validateSettableTexInternalFormat(const char* functionName, GC3Denum internalFormat)
+bool WebGLRenderingContextBase::validateSettableTexInternalFormat(const char* functionName, GCGLenum internalFormat)
 {
     switch (internalFormat) {
     case GraphicsContextGL::DEPTH_COMPONENT:
@@ -1643,7 +1643,7 @@ bool WebGLRenderingContextBase::validateSettableTexInternalFormat(const char* fu
     }
 }
 
-void WebGLRenderingContextBase::copyTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)
+void WebGLRenderingContextBase::copyTexSubImage2D(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLint x, GCGLint y, GCGLsizei width, GCGLsizei height)
 {
     if (isContextLostOrPending())
         return;
@@ -1663,7 +1663,7 @@ void WebGLRenderingContextBase::copyTexSubImage2D(GC3Denum target, GC3Dint level
         synthesizeGLError(GraphicsContextGL::INVALID_VALUE, "copyTexSubImage2D", "rectangle out of range");
         return;
     }
-    GC3Denum internalFormat = tex->getInternalFormat(target, level);
+    GCGLenum internalFormat = tex->getInternalFormat(target, level);
     if (!validateSettableTexInternalFormat("copyTexSubImage2D", internalFormat))
         return;
     if (!isTexInternalFormatColorBufferCombinationValid(internalFormat, getBoundFramebufferColorFormat())) {
@@ -1677,11 +1677,11 @@ void WebGLRenderingContextBase::copyTexSubImage2D(GC3Denum target, GC3Dint level
     }
     clearIfComposited();
 
-    GC3Dint clippedX, clippedY;
-    GC3Dsizei clippedWidth, clippedHeight;
+    GCGLint clippedX, clippedY;
+    GCGLsizei clippedWidth, clippedHeight;
     if (clip2D(x, y, width, height, getBoundFramebufferWidth(), getBoundFramebufferHeight(), &clippedX, &clippedY, &clippedWidth, &clippedHeight)) {
-        GC3Denum format;
-        GC3Denum type;
+        GCGLenum format;
+        GCGLenum type;
         if (!GraphicsContextGLOpenGL::possibleFormatAndTypeForInternalFormat(tex->getInternalFormat(target, level), format, type)) {
             synthesizeGLError(GraphicsContextGL::INVALID_ENUM, "copyTexSubImage2D", "Texture has unknown internal format");
             return;
@@ -1689,7 +1689,7 @@ void WebGLRenderingContextBase::copyTexSubImage2D(GC3Denum target, GC3Dint level
         UniqueArray<unsigned char> zero;
         if (width && height) {
             unsigned size;
-            GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_unpackAlignment, &size, nullptr);
+            GCGLenum error = m_context->computeImageSizeInBytes(format, type, width, height, m_unpackAlignment, &size, nullptr);
             if (error != GraphicsContextGL::NO_ERROR) {
                 synthesizeGLError(error, "copyTexSubImage2D", "bad dimensions");
                 return;
@@ -1756,7 +1756,7 @@ RefPtr<WebGLRenderbuffer> WebGLRenderingContextBase::createRenderbuffer()
     return buffer;
 }
 
-RefPtr<WebGLShader> WebGLRenderingContextBase::createShader(GC3Denum type)
+RefPtr<WebGLShader> WebGLRenderingContextBase::createShader(GCGLenum type)
 {
     if (isContextLostOrPending())
         return nullptr;
@@ -1770,7 +1770,7 @@ RefPtr<WebGLShader> WebGLRenderingContextBase::createShader(GC3Denum type)
     return shader;
 }
 
-void WebGLRenderingContextBase::cullFace(GC3Denum mode)
+void WebGLRenderingContextBase::cullFace(GCGLenum mode)
 {
     if (isContextLostOrPending())
         return;
@@ -1871,14 +1871,14 @@ void WebGLRenderingContextBase::deleteTexture(WebGLTexture* texture)
         m_framebufferBinding->removeAttachmentFromBoundFramebuffer(texture);
 }
 
-void WebGLRenderingContextBase::depthFunc(GC3Denum func)
+void WebGLRenderingContextBase::depthFunc(GCGLenum func)
 {
     if (isContextLostOrPending())
         return;
     m_context->depthFunc(func);
 }
 
-void WebGLRenderingContextBase::depthMask(GC3Dboolean flag)
+void WebGLRenderingContextBase::depthMask(GCGLboolean flag)
 {
     if (isContextLostOrPending())
         return;
@@ -1886,7 +1886,7 @@ void WebGLRenderingContextBase::depthMask(GC3Dboolean flag)
     m_context->depthMask(flag);
 }
 
-void WebGLRenderingContextBase::depthRange(GC3Dfloat zNear, GC3Dfloat zFar)
+void WebGLRenderingContextBase::depthRange(GCGLfloat zNear, GCGLfloat zFar)
 {
     if (isContextLostOrPending())
         return;
@@ -1909,7 +1909,7 @@ void WebGLRenderingContextBase::detachShader(WebGLProgram* program, WebGLShader*
     shader->onDetached(graphicsContextGL());
 }
 
-void WebGLRenderingContextBase::disable(GC3Denum cap)
+void WebGLRenderingContextBase::disable(GCGLenum cap)
 {
     if (isContextLostOrPending() || !validateCapability("disable", cap))
         return;
@@ -1923,7 +1923,7 @@ void WebGLRenderingContextBase::disable(GC3Denum cap)
     m_context->disable(cap);
 }
 
-void WebGLRenderingContextBase::disableVertexAttribArray(GC3Duint index)
+void WebGLRenderingContextBase::disableVertexAttribArray(GCGLuint index)
 {
     if (isContextLostOrPending())
         return;
@@ -1939,7 +1939,7 @@ void WebGLRenderingContextBase::disableVertexAttribArray(GC3Duint index)
         m_context->disableVertexAttribArray(index);
 }
 
-bool WebGLRenderingContextBase::validateNPOTTextureLevel(GC3Dsizei width, GC3Dsizei height, GC3Dint level, const char* functionName)
+bool WebGLRenderingContextBase::validateNPOTTextureLevel(GCGLsizei width, GCGLsizei height, GCGLint level, const char* functionName)
 {
     if (!isGLES2NPOTStrict() && level && WebGLTexture::isNPOT(width, height)) {
         synthesizeGLError(GraphicsContextGL::INVALID_VALUE, functionName, "level > 0 not power of 2");
@@ -1949,7 +1949,7 @@ bool WebGLRenderingContextBase::validateNPOTTextureLevel(GC3Dsizei width, GC3Dsi
     return true;
 }
 
-bool WebGLRenderingContextBase::validateElementArraySize(GC3Dsizei count, GC3Denum type, GC3Dintptr offset)
+bool WebGLRenderingContextBase::validateElementArraySize(GCGLsizei count, GCGLenum type, GCGLintptr offset)
 {
     RefPtr<WebGLBuffer> elementArrayBuffer = m_boundVertexArrayObject->getElementArrayBuffer();
     
@@ -1967,7 +1967,7 @@ bool WebGLRenderingContextBase::validateElementArraySize(GC3Dsizei count, GC3Den
         // Make uoffset an element offset.
         offset /= 4;
 
-        GC3Dsizeiptr n = elementArrayBuffer->byteLength() / 4;
+        GCGLsizeiptr n = elementArrayBuffer->byteLength() / 4;
         if (offset > n || count > n - offset)
             return false;
     } else if (type == GraphicsContextGL::UNSIGNED_SHORT) {
@@ -1978,18 +1978,18 @@ bool WebGLRenderingContextBase::validateElementArraySize(GC3Dsizei count, GC3Den
         // Make uoffset an element offset.
         offset /= 2;
 
-        GC3Dsizeiptr n = elementArrayBuffer->byteLength() / 2;
+        GCGLsizeiptr n = elementArrayBuffer->byteLength() / 2;
         if (offset > n || count > n - offset)
             return false;
     } else if (type == GraphicsContextGL::UNSIGNED_BYTE) {
-        GC3Dsizeiptr n = elementArrayBuffer->byteLength();
+        GCGLsizeiptr n = elementArrayBuffer->byteLength();
         if (offset > n || count > n - offset)
             return false;
     }
     return true;
 }
 
-bool WebGLRenderingContextBase::validateIndexArrayPrecise(GC3Dsizei count, GC3Denum type, GC3Dintptr offset, unsigned& numElementsRequired)
+bool WebGLRenderingContextBase::validateIndexArrayPrecise(GCGLsizei count, GCGLenum type, GCGLintptr offset, unsigned& numElementsRequired)
 {
     ASSERT(count >= 0 && offset >= 0);
     unsigned maxIndex = 0;
@@ -2010,13 +2010,13 @@ bool WebGLRenderingContextBase::validateIndexArrayPrecise(GC3Dsizei count, GC3De
 
     switch (type) {
     case GraphicsContextGL::UNSIGNED_INT:
-        maxIndex = getMaxIndex<GC3Duint>(buffer, offset, count);
+        maxIndex = getMaxIndex<GCGLuint>(buffer, offset, count);
         break;
     case GraphicsContextGL::UNSIGNED_SHORT:
-        maxIndex = getMaxIndex<GC3Dushort>(buffer, offset, count);
+        maxIndex = getMaxIndex<GCGLushort>(buffer, offset, count);
         break;
     case GraphicsContextGL::UNSIGNED_BYTE:
-        maxIndex = getMaxIndex<GC3Dubyte>(buffer, offset, count);
+        maxIndex = getMaxIndex<GCGLubyte>(buffer, offset, count);
         break;
     }
 
@@ -2119,7 +2119,7 @@ bool WebGLRenderingContextBase::validateWebGLObject(const char* functionName, We
     return true;
 }
 
-bool WebGLRenderingContextBase::validateDrawArrays(const char* functionName, GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primitiveCount)
+bool WebGLRenderingContextBase::validateDrawArrays(const char* functionName, GCGLenum mode, GCGLint first, GCGLsizei count, GCGLsizei primitiveCount)
 {
     if (isContextLostOrPending() || !validateDrawMode(functionName, mode))
         return false;
@@ -2143,8 +2143,8 @@ bool WebGLRenderingContextBase::validateDrawArrays(const char* functionName, GC3
     }
 
     // Ensure we have a valid rendering state.
-    Checked<GC3Dint, RecordOverflow> checkedSum = Checked<GC3Dint, RecordOverflow>(first) + Checked<GC3Dint, RecordOverflow>(count);
-    Checked<GC3Dint, RecordOverflow> checkedPrimitiveCount(primitiveCount);
+    Checked<GCGLint, RecordOverflow> checkedSum = Checked<GCGLint, RecordOverflow>(first) + Checked<GCGLint, RecordOverflow>(count);
+    Checked<GCGLint, RecordOverflow> checkedPrimitiveCount(primitiveCount);
     if (checkedSum.hasOverflowed() || checkedPrimitiveCount.hasOverflowed() || !validateVertexAttributes(checkedSum.unsafeGet(), checkedPrimitiveCount.unsafeGet())) {
         synthesizeGLError(GraphicsContextGL::INVALID_OPERATION, functionName, "attempt to access out of bounds arrays");
         return false;
@@ -2163,7 +2163,7 @@ bool WebGLRenderingContextBase::validateDrawArrays(const char* functionName, GC3
     return true;
 }
 
-bool WebGLRenderingContextBase::validateDrawElements(const char* functionName, GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, unsigned& numElements, GC3Dsizei primitiveCount)
+bool WebGLRenderingContextBase::validateDrawElements(const char* functionName, GCGLenum mode, GCGLsizei count, GCGLenum type, long long offset, unsigned& numElements, GCGLsizei primitiveCount)
 {
     if (isContextLostOrPending() || !validateDrawMode(functionName, mode))
         return false;
@@ -2206,22 +2206,22 @@ bool WebGLRenderingContextBase::validateDrawElements(const char* functionName, G
     }
 
     // Ensure we have a valid rendering state.
-    if (!validateElementArraySize(count, type, static_cast<GC3Dintptr>(offset))) {
+    if (!validateElementArraySize(count, type, static_cast<GCGLintptr>(offset))) {
         synthesizeGLError(GraphicsContextGL::INVALID_OPERATION, functionName, "request out of bounds for current ELEMENT_ARRAY_BUFFER");
         return false;
     }
     if (!count)
         return false;
     
-    Checked<GC3Dint, RecordOverflow> checkedCount(count);
-    Checked<GC3Dint, RecordOverflow> checkedPrimitiveCount(primitiveCount);
+    Checked<GCGLint, RecordOverflow> checkedCount(count);
+    Checked<GCGLint, RecordOverflow> checkedPrimitiveCount(primitiveCount);
     if (checkedCount.hasOverflowed() || checkedPrimitiveCount.hasOverflowed()) {
         synthesizeGLError(GraphicsContextGL::INVALID_OPERATION, functionName, "attempt to access out of bounds arrays");
         return false;
     }
     
     if (!validateIndexArrayConservative(type, numElements) || !validateVertexAttributes(numElements, checkedPrimitiveCount.unsafeGet())) {
-        if (!validateIndexArrayPrecise(checkedCount.unsafeGet(), type, static_cast<GC3Dintptr>(offset), numElements) || !validateVertexAttributes(numElements, checkedPrimitiveCount.unsafeGet())) {
+        if (!validateIndexArrayPrecise(checkedCount.unsafeGet(), type, static_cast<GCGLintptr>(offset), numElements) || !validateVertexAttributes(numElements, checkedPrimitiveCount.unsafeGet())) {
             synthesizeGLError(GraphicsContextGL::INVALID_OPERATION, functionName, "attempt to access out of bounds arrays");
             return false;
         }
@@ -2241,7 +2241,7 @@ bool WebGLRenderingContextBase::validateDrawElements(const char* functionName, G
     return true;
 }
 
-void WebGLRenderingContextBase::drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count)
+void WebGLRenderingContextBase::drawArrays(GCGLenum mode, GCGLint first, GCGLsizei count)
 {
     if (!validateDrawArrays("drawArrays", mode, first, count, 0))
         return;
@@ -2279,22 +2279,22 @@ void WebGLRenderingContextBase::drawArrays(GC3Denum mode, GC3Dint first, GC3Dsiz
 }
 
 #if USE(OPENGL) && ENABLE(WEBGL2)
-static GC3Duint getRestartIndex(GC3Denum type)
+static GCGLuint getRestartIndex(GCGLenum type)
 {
     switch (type) {
     case GraphicsContextGL::UNSIGNED_BYTE:
-        return std::numeric_limits<GC3Dubyte>::max();
+        return std::numeric_limits<GCGLubyte>::max();
     case GraphicsContextGL::UNSIGNED_SHORT:
-        return std::numeric_limits<GC3Dushort>::max();
+        return std::numeric_limits<GCGLushort>::max();
     case GraphicsContextGL::UNSIGNED_INT:
-        return std::numeric_limits<GC3Duint>::max();
+        return std::numeric_limits<GCGLuint>::max();
     }
 
     return 0;
 }
 #endif
 
-void WebGLRenderingContextBase::drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset)
+void WebGLRenderingContextBase::drawElements(GCGLenum mode, GCGLsizei count, GCGLenum type, long long offset)
 {
     unsigned numElements = 0;
     if (!validateDrawElements("drawElements", mode, count, type, offset, numElements, 0))
@@ -2308,7 +2308,7 @@ void WebGLRenderingContextBase::drawElements(GC3Denum mode, GC3Dsizei count, GC3
     bool vertexAttrib0Simulated = false;
     if (!isGLES2Compliant()) {
         if (!numElements)
-            validateIndexArrayPrecise(count, type, static_cast<GC3Dintptr>(offset), numElements);
+            validateIndexArrayPrecise(count, type, static_cast<GCGLintptr>(offset), numElements);
         auto simulateVertexAttrib0Status = simulateVertexAttrib0(numElements);
         if (!simulateVertexAttrib0Status) {
             // We were unable to simulate the attribute buffer.
@@ -2330,7 +2330,7 @@ void WebGLRenderingContextBase::drawElements(GC3Denum mode, GC3Dsizei count, GC3
     {
         InspectorScopedShaderProgramHighlight scopedHighlight(*this, m_currentProgram.get());
 
-        m_context->drawElements(mode, count, type, static_cast<GC3Dintptr>(offset));
+        m_context->drawElements(mode, count, type, static_cast<GCGLintptr>(offset));
     }
 
     if (!isGLES2Compliant() && vertexAttrib0Simulated)
@@ -2340,7 +2340,7 @@ void WebGLRenderingContextBase::drawElements(GC3Denum mode, GC3Dsizei count, GC3
     markContextChangedAndNotifyCanvasObserver();
 }
 
-void WebGLRenderingContextBase::enable(GC3Denum cap)
+void WebGLRenderingContextBase::enable(GCGLenum cap)
 {
     if (isContextLostOrPending() || !validateCapability("enable", cap))
         return;
@@ -2354,7 +2354,7 @@ void WebGLRenderingContextBase::enable(GC3Denum cap)
     m_context->enable(cap);
 }
 
-void WebGLRenderingContextBase::enableVertexAttribArray(GC3Duint index)
+void WebGLRenderingContextBase::enableVertexAttribArray(GCGLuint index)
 {
     if (isContextLostOrPending())
         return;
@@ -2383,7 +2383,7 @@ void WebGLRenderingContextBase::flush()
     m_context->flush();
 }
 
-void WebGLRenderingContextBase::framebufferRenderbuffer(GC3Denum target, GC3Denum attachment, GC3Denum renderbuffertarget, WebGLRenderbuffer* buffer)
+void WebGLRenderingContextBase::framebufferRenderbuffer(GCGLenum target, GCGLenum attachment, GCGLenum renderbuffertarget, WebGLRenderbuffer* buffer)
 {
     if (isContextLostOrPending() || !validateFramebufferFuncParameters("framebufferRenderbuffer", target, attachment))
         return;
@@ -2409,7 +2409,7 @@ void WebGLRenderingContextBase::framebufferRenderbuffer(GC3Denum target, GC3Denu
         synthesizeGLError(GraphicsContextGL::INVALID_OPERATION, "framebufferRenderbuffer", "no framebuffer bound");
         return;
     }
-    Platform3DObject bufferObject = objectOrZero(buffer);
+    PlatformGLObject bufferObject = objectOrZero(buffer);
 #if !USE(ANGLE)
     if (attachment == GraphicsContextGL::DEPTH_STENCIL_ATTACHMENT) {
         m_context->framebufferRenderbuffer(target, GraphicsContextGL::DEPTH_ATTACHMENT, renderbuffertarget, bufferObject);
@@ -2421,7 +2421,7 @@ void WebGLRenderingContextBase::framebufferRenderbuffer(GC3Denum target, GC3Denu
     applyStencilTest();
 }
 
-void WebGLRenderingContextBase::framebufferTexture2D(GC3Denum target, GC3Denum attachment, GC3Denum textarget, WebGLTexture* texture, GC3Dint level)
+void WebGLRenderingContextBase::framebufferTexture2D(GCGLenum target, GCGLenum attachment, GCGLenum textarget, WebGLTexture* texture, GCGLint level)
 {
     if (isContextLostOrPending() || !validateFramebufferFuncParameters("framebufferTexture2D", target, attachment))
         return;
@@ -2443,7 +2443,7 @@ void WebGLRenderingContextBase::framebufferTexture2D(GC3Denum target, GC3Denum a
         synthesizeGLError(GraphicsContextGL::INVALID_OPERATION, "framebufferTexture2D", "no framebuffer bound");
         return;
     }
-    Platform3DObject textureObject = objectOrZero(texture);
+    PlatformGLObject textureObject = objectOrZero(texture);
 
 #if !USE_ANGLE
     if (attachment == GraphicsContextGL::DEPTH_STENCIL_ATTACHMENT) {
@@ -2457,14 +2457,14 @@ void WebGLRenderingContextBase::framebufferTexture2D(GC3Denum target, GC3Denum a
     applyStencilTest();
 }
 
-void WebGLRenderingContextBase::frontFace(GC3Denum mode)
+void WebGLRenderingContextBase::frontFace(GCGLenum mode)
 {
     if (isContextLostOrPending())
         return;
     m_context->frontFace(mode);
 }
 
-void WebGLRenderingContextBase::generateMipmap(GC3Denum target)
+void WebGLRenderingContextBase::generateMipmap(GCGLenum target)
 {
     if (isContextLostOrPending())
         return;
@@ -2500,7 +2500,7 @@ void WebGLRenderingContextBase::generateMipmap(GC3Denum target)
     tex->generateMipmapLevelInfo();
 }
 
-RefPtr<WebGLActiveInfo> WebGLRenderingContextBase::getActiveAttrib(WebGLProgram* program, GC3Duint index)
+RefPtr<WebGLActiveInfo> WebGLRenderingContextBase::getActiveAttrib(WebGLProgram* program, GCGLuint index)
 {
     if (isContextLostOrPending() || !validateWebGLObject("getActiveAttrib", program))
         return nullptr;
@@ -2513,7 +2513,7 @@ RefPtr<WebGLActiveInfo> WebGLRenderingContextBase::getActiveAttrib(WebGLProgram*
     return WebGLActiveInfo::create(info.name, info.type, info.size);
 }
 
-RefPtr<WebGLActiveInfo> WebGLRenderingContextBase::getActiveUniform(WebGLProgram* program, GC3Duint index)
+RefPtr<WebGLActiveInfo> WebGLRenderingContextBase::getActiveUniform(WebGLProgram* program, GCGLuint index)
 {
     if (isContextLostOrPending() || !validateWebGLObject("getActiveUniform", program))
         return nullptr;
@@ -2534,7 +2534,7 @@ Optional<Vector<RefPtr<WebGLShader>>> WebGLRenderingContextBase::getAttachedShad
     if (isContextLostOrPending() || !validateWebGLObject("getAttachedShaders", program))
         return WTF::nullopt;
 
-    const GC3Denum shaderTypes[] = {
+    const GCGLenum shaderTypes[] = {
         GraphicsContextGL::VERTEX_SHADER,
         GraphicsContextGL::FRAGMENT_SHADER
     };
@@ -2547,7 +2547,7 @@ Optional<Vector<RefPtr<WebGLShader>>> WebGLRenderingContextBase::getAttachedShad
     return shaderObjects;
 }
 
-GC3Dint WebGLRenderingContextBase::getAttribLocation(WebGLProgram* program, const String& name)
+GCGLint WebGLRenderingContextBase::getAttribLocation(WebGLProgram* program, const String& name)
 {
     if (isContextLostOrPending() || !validateWebGLObject("getAttribLocation", program))
         return -1;
@@ -2564,7 +2564,7 @@ GC3Dint WebGLRenderingContextBase::getAttribLocation(WebGLProgram* program, cons
     return m_context->getAttribLocation(objectOrZero(program), name);
 }
 
-WebGLAny WebGLRenderingContextBase::getBufferParameter(GC3Denum target, GC3Denum pname)
+WebGLAny WebGLRenderingContextBase::getBufferParameter(GCGLenum target, GCGLenum pname)
 {
     if (isContextLostOrPending())
         return nullptr;
@@ -2595,7 +2595,7 @@ WebGLAny WebGLRenderingContextBase::getBufferParameter(GC3Denum target, GC3Denum
         return nullptr;
     }
 
-    GC3Dint value = 0;
+    GCGLint value = 0;
     m_context->getBufferParameteriv(target, pname, &value);
     if (pname == GraphicsContextGL::BUFFER_SIZE)
         return value;
@@ -2619,19 +2619,19 @@ Optional<WebGLContextAttributes> WebGLRenderingContextBase::getContextAttributes
     return attributes;
 }
 
-GC3Denum WebGLRenderingContextBase::getError()
+GCGLenum WebGLRenderingContextBase::getError()
 {
     if (m_isPendingPolicyResolution)
         return GraphicsContextGL::NO_ERROR;
     return m_context->getError();
 }
 
-WebGLAny WebGLRenderingContextBase::getProgramParameter(WebGLProgram* program, GC3Denum pname)
+WebGLAny WebGLRenderingContextBase::getProgramParameter(WebGLProgram* program, GCGLenum pname)
 {
     if (isContextLostOrPending() || !validateWebGLObject("getProgramParameter", program))
         return nullptr;
 
-    GC3Dint value = 0;
+    GCGLint value = 0;
     switch (pname) {
     case GraphicsContextGL::DELETE_STATUS:
         return program->isDeleted();
@@ -2664,7 +2664,7 @@ String WebGLRenderingContextBase::getProgramInfoLog(WebGLProgram* program)
     return ensureNotNull(m_context->getProgramInfoLog(objectOrZero(program)));
 }
 
-WebGLAny WebGLRenderingContextBase::getRenderbufferParameter(GC3Denum target, GC3Denum pname)
+WebGLAny WebGLRenderingContextBase::getRenderbufferParameter(GCGLenum target, GCGLenum pname)
 {
     if (isContextLostOrPending())
         return nullptr;
@@ -2709,7 +2709,7 @@ WebGLAny WebGLRenderingContextBase::getRenderbufferParameter(GC3Denum target, GC
         return value;
     }
 
-    GC3Dint value = 0;
+    GCGLint value = 0;
     switch (pname) {
     case GraphicsContextGL::RENDERBUFFER_WIDTH:
     case GraphicsContextGL::RENDERBUFFER_HEIGHT:
@@ -2729,11 +2729,11 @@ WebGLAny WebGLRenderingContextBase::getRenderbufferParameter(GC3Denum target, GC
     }
 }
 
-WebGLAny WebGLRenderingContextBase::getShaderParameter(WebGLShader* shader, GC3Denum pname)
+WebGLAny WebGLRenderingContextBase::getShaderParameter(WebGLShader* shader, GCGLenum pname)
 {
     if (isContextLostOrPending() || !validateWebGLObject("getShaderParameter", shader))
         return nullptr;
-    GC3Dint value = 0;
+    GCGLint value = 0;
     switch (pname) {
     case GraphicsContextGL::DELETE_STATUS:
         return shader->isDeleted();
@@ -2756,7 +2756,7 @@ String WebGLRenderingContextBase::getShaderInfoLog(WebGLShader* shader)
     return ensureNotNull(m_context->getShaderInfoLog(objectOrZero(shader)));
 }
 
-RefPtr<WebGLShaderPrecisionFormat> WebGLRenderingContextBase::getShaderPrecisionFormat(GC3Denum shaderType, GC3Denum precisionType)
+RefPtr<WebGLShaderPrecisionFormat> WebGLRenderingContextBase::getShaderPrecisionFormat(GCGLenum shaderType, GCGLenum precisionType)
 {
     if (isContextLostOrPending())
         return nullptr;
@@ -2781,8 +2781,8 @@ RefPtr<WebGLShaderPrecisionFormat> WebGLRenderingContextBase::getShaderPrecision
         return nullptr;
     }
 
-    GC3Dint range[2] = {0, 0};
-    GC3Dint precision = 0;
+    GCGLint range[2] = {0, 0};
+    GCGLint precision = 0;
     m_context->getShaderPrecisionFormat(shaderType, precisionType, range, &precision);
     return WebGLShaderPrecisionFormat::create(range[0], range[1], precision);
 }
@@ -2794,15 +2794,15 @@ String WebGLRenderingContextBase::getShaderSource(WebGLShader* shader)
     return ensureNotNull(shader->getSource());
 }
 
-WebGLAny WebGLRenderingContextBase::getTexParameter(GC3Denum target, GC3Denum pname)
+WebGLAny WebGLRenderingContextBase::getTexParameter(GCGLenum target, GCGLenum pname)
 {
     if (isContextLostOrPending())
         return nullptr;
     auto tex = validateTextureBinding("getTexParameter", target, false);
     if (!tex)
         return nullptr;
-    GC3Dint value = 0;
-    GC3Dfloat fValue = 0;
+    GCGLint value = 0;
+    GCGLfloat fValue = 0;
     switch (pname) {
     case GraphicsContextGL::TEXTURE_MAG_FILTER:
     case GraphicsContextGL::TEXTURE_MIN_FILTER:
@@ -2831,9 +2831,9 @@ WebGLAny WebGLRenderingContextBase::getUniform(WebGLProgram* program, const WebG
         synthesizeGLError(GraphicsContextGL::INVALID_OPERATION, "getUniform", "no uniformlocation or not valid for this program");
         return nullptr;
     }
-    GC3Dint location = uniformLocation->location();
+    GCGLint location = uniformLocation->location();
 
-    GC3Denum baseType;
+    GCGLenum baseType;
     unsigned length;
     switch (uniformLocation->type()) {
     case GraphicsContextGL::BOOL:
@@ -2908,9 +2908,9 @@ WebGLAny WebGLRenderingContextBase::getUniform(WebGLProgram* program, const WebG
     }
     switch (baseType) {
     case GraphicsContextGL::FLOAT: {
-        GC3Dfloat value[16] = {0};
+        GCGLfloat value[16] = {0};
         if (m_isRobustnessEXTSupported)
-            m_context->getExtensions().getnUniformfvEXT(objectOrZero(program), location, 16 * sizeof(GC3Dfloat), value);
+            m_context->getExtensions().getnUniformfvEXT(objectOrZero(program), location, 16 * sizeof(GCGLfloat), value);
         else
             m_context->getUniformfv(objectOrZero(program), location, value);
         if (length == 1)
@@ -2918,9 +2918,9 @@ WebGLAny WebGLRenderingContextBase::getUniform(WebGLProgram* program, const WebG
         return Float32Array::tryCreate(value, length);
     }
     case GraphicsContextGL::INT: {
-        GC3Dint value[4] = {0};
+        GCGLint value[4] = {0};
         if (m_isRobustnessEXTSupported)
-            m_context->getExtensions().getnUniformivEXT(objectOrZero(program), location, 4 * sizeof(GC3Dint), value);
+            m_context->getExtensions().getnUniformivEXT(objectOrZero(program), location, 4 * sizeof(GCGLint), value);
         else
             m_context->getUniformiv(objectOrZero(program), location, value);
         if (length == 1)
@@ -2928,9 +2928,9 @@ WebGLAny WebGLRenderingContextBase::getUniform(WebGLProgram* program, const WebG
         return Int32Array::tryCreate(value, length);
     }
     case GraphicsContextGL::BOOL: {
-        GC3Dint value[4] = {0};
+        GCGLint value[4] = {0};
         if (m_isRobustnessEXTSupported)
-            m_context->getExtensions().getnUniformivEXT(objectOrZero(program), location, 4 * sizeof(GC3Dint), value);
+            m_context->getExtensions().getnUniformivEXT(objectOrZero(program), location, 4 * sizeof(GCGLint), value);
         else
             m_context->getUniformiv(objectOrZero(program), location, value);
         if (length > 1) {
@@ -2964,17 +2964,17 @@ RefPtr<WebGLUniformLocation> WebGLRenderingContextBase::getUniformLocation(WebGL
         synthesizeGLError(GraphicsContextGL::INVALID_OPERATION, "getUniformLocation", "program not linked");
         return nullptr;
     }
-    GC3Dint uniformLocation = m_context->getUniformLocation(objectOrZero(program), name);
+    GCGLint uniformLocation = m_context->getUniformLocation(objectOrZero(program), name);
     if (uniformLocation == -1)
         return nullptr;
 
-    GC3Dint activeUniforms = 0;
+    GCGLint activeUniforms = 0;
 #if USE(ANGLE)
     m_context->getProgramiv(objectOrZero(program), GraphicsContextGL::ACTIVE_UNIFORMS, &activeUniforms);
 #else
     m_context->getNonBuiltInActiveSymbolCount(objectOrZero(program), GraphicsContextGL::ACTIVE_UNIFORMS, &activeUniforms);
 #endif
-    for (GC3Dint i = 0; i < activeUniforms; i++) {
+    for (GCGLint i = 0; i < activeUniforms; i++) {
         GraphicsContextGL::ActiveInfo info;
         if (!m_context->getActiveUniform(objectOrZero(program), i, info))
             return nullptr;
@@ -2982,7 +2982,7 @@ RefPtr<WebGLUniformLocation> WebGLRenderingContextBase::getUniformLocation(WebGL
         if (info.name.endsWith("[0]"))
             info.name = info.name.left(info.name.length() - 3);
         // If it's an array, we need to iterate through each element, appending "[index]" to the name.
-        for (GC3Dint index = 0; index < info.size; ++index) {
+        for (GCGLint index = 0; index < info.size; ++index) {
             String uniformName = makeString(info.name, '[', index, ']');
 
             if (name == uniformName || name == info.name)
@@ -2992,7 +2992,7 @@ RefPtr<WebGLUniformLocation> WebGLRenderingContextBase::getUniformLocation(WebGL
     return nullptr;
 }
 
-WebGLAny WebGLRenderingContextBase::getVertexAttrib(GC3Duint index, GC3Denum pname)
+WebGLAny WebGLRenderingContextBase::getVertexAttrib(GCGLuint index, GCGLenum pname)
 {
     if (isContextLostOrPending())
         return nullptr;
@@ -3032,7 +3032,7 @@ WebGLAny WebGLRenderingContextBase::getVertexAttrib(GC3Duint index, GC3Denum pna
     }
 }
 
-long long WebGLRenderingContextBase::getVertexAttribOffset(GC3Duint index, GC3Denum pname)
+long long WebGLRenderingContextBase::getVertexAttribOffset(GCGLuint index, GCGLenum pname)
 {
     if (isContextLostOrPending())
         return 0;
@@ -3073,7 +3073,7 @@ bool WebGLRenderingContextBase::extensionIsEnabled(const String& name)
     return false;
 }
 
-GC3Dboolean WebGLRenderingContextBase::isBuffer(WebGLBuffer* buffer)
+GCGLboolean WebGLRenderingContextBase::isBuffer(WebGLBuffer* buffer)
 {
     if (!buffer || isContextLostOrPending())
         return 0;
@@ -3110,7 +3110,7 @@ bool WebGLRenderingContextBase::isContextLostOrPending()
     return m_contextLost || m_isPendingPolicyResolution;
 }
 
-GC3Dboolean WebGLRenderingContextBase::isEnabled(GC3Denum cap)
+GCGLboolean WebGLRenderingContextBase::isEnabled(GCGLenum cap)
 {
     if (isContextLostOrPending() || !validateCapability("isEnabled", cap))
         return 0;
@@ -3119,7 +3119,7 @@ GC3Dboolean WebGLRenderingContextBase::isEnabled(GC3Denum cap)
     return m_context->isEnabled(cap);
 }
 
-GC3Dboolean WebGLRenderingContextBase::isFramebuffer(WebGLFramebuffer* framebuffer)
+GCGLboolean WebGLRenderingContextBase::isFramebuffer(WebGLFramebuffer* framebuffer)
 {
     if (!framebuffer || isContextLostOrPending())
         return 0;
@@ -3130,7 +3130,7 @@ GC3Dboolean WebGLRenderingContextBase::isFramebuffer(WebGLFramebuffer* framebuff
     return m_context->isFramebuffer(framebuffer->object());
 }
 
-GC3Dboolean WebGLRenderingContextBase::isProgram(WebGLProgram* program)
+GCGLboolean WebGLRenderingContextBase::isProgram(WebGLProgram* program)
 {
     if (!program || isContextLostOrPending())
         return 0;
@@ -3138,7 +3138,7 @@ GC3Dboolean WebGLRenderingContextBase::isProgram(WebGLProgram* program)
     return m_context->isProgram(program->object());
 }
 
-GC3Dboolean WebGLRenderingContextBase::isRenderbuffer(WebGLRenderbuffer* renderbuffer)
+GCGLboolean WebGLRenderingContextBase::isRenderbuffer(WebGLRenderbuffer* renderbuffer)
 {
     if (!renderbuffer || isContextLostOrPending())
         return 0;
@@ -3149,7 +3149,7 @@ GC3Dboolean WebGLRenderingContextBase::isRenderbuffer(WebGLRenderbuffer* renderb
     return m_context->isRenderbuffer(renderbuffer->object());
 }
 
-GC3Dboolean WebGLRenderingContextBase::isShader(WebGLShader* shader)
+GCGLboolean WebGLRenderingContextBase::isShader(WebGLShader* shader)
 {
     if (!shader || isContextLostOrPending())
         return 0;
@@ -3157,7 +3157,7 @@ GC3Dboolean WebGLRenderingContextBase::isShader(WebGLShader* shader)
     return m_context->isShader(shader->object());
 }
 
-GC3Dboolean WebGLRenderingContextBase::isTexture(WebGLTexture* texture)
+GCGLboolean WebGLRenderingContextBase::isTexture(WebGLTexture* texture)
 {
     if (!texture || isContextLostOrPending())
         return 0;
@@ -3168,7 +3168,7 @@ GC3Dboolean WebGLRenderingContextBase::isTexture(WebGLTexture* texture)
     return m_context->isTexture(texture->object());
 }
 
-void WebGLRenderingContextBase::lineWidth(GC3Dfloat width)
+void WebGLRenderingContextBase::lineWidth(GCGLfloat width)
 {
     if (isContextLostOrPending())
         return;
@@ -3207,7 +3207,7 @@ bool WebGLRenderingContextBase::linkProgramWithoutInvalidatingAttribLocations(We
     return true;
 }
 
-void WebGLRenderingContextBase::pixelStorei(GC3Denum pname, GC3Dint param)
+void WebGLRenderingContextBase::pixelStorei(GCGLenum pname, GCGLint param)
 {
     if (isContextLostOrPending())
         return;
@@ -3220,7 +3220,7 @@ void WebGLRenderingContextBase::pixelStorei(GC3Denum pname, GC3Dint param)
         break;
     case GraphicsContextGL::UNPACK_COLORSPACE_CONVERSION_WEBGL:
         if (param == GraphicsContextGL::BROWSER_DEFAULT_WEBGL || param == GraphicsContextGL::NONE)
-            m_unpackColorspaceConversion = static_cast<GC3Denum>(param);
+            m_unpackColorspaceConversion = static_cast<GCGLenum>(param);
         else {
             synthesizeGLError(GraphicsContextGL::INVALID_VALUE, "pixelStorei", "invalid parameter for UNPACK_COLORSPACE_CONVERSION_WEBGL");
             return;
@@ -3245,7 +3245,7 @@ void WebGLRenderingContextBase::pixelStorei(GC3Denum pname, GC3Dint param)
     }
 }
 
-void WebGLRenderingContextBase::polygonOffset(GC3Dfloat factor, GC3Dfloat units)
+void WebGLRenderingContextBase::polygonOffset(GCGLfloat factor, GCGLfloat units)
 {
     if (isContextLostOrPending())
         return;
@@ -3262,7 +3262,7 @@ enum class InternalFormatTheme {
     UnsignedInteger
 };
 
-static InternalFormatTheme internalFormatTheme(GC3Denum internalFormat)
+static InternalFormatTheme internalFormatTheme(GCGLenum internalFormat)
 {
     switch (internalFormat) {
     case GraphicsContextGL::RGB:
@@ -3331,7 +3331,7 @@ static InternalFormatTheme internalFormatTheme(GC3Denum internalFormat)
     }
 }
 
-static int numberOfComponentsForFormat(GC3Denum format)
+static int numberOfComponentsForFormat(GCGLenum format)
 {
     switch (format) {
     case GraphicsContextGL::RED:
@@ -3351,7 +3351,7 @@ static int numberOfComponentsForFormat(GC3Denum format)
     }
 }
 
-static int numberOfComponentsForInternalFormat(GC3Denum internalFormat)
+static int numberOfComponentsForInternalFormat(GCGLenum internalFormat)
 {
     switch (internalFormat) {
     case GraphicsContextGL::LUMINANCE:
@@ -3423,7 +3423,7 @@ static int numberOfComponentsForInternalFormat(GC3Denum internalFormat)
     }
 }
 
-void WebGLRenderingContextBase::readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, ArrayBufferView& pixels)
+void WebGLRenderingContextBase::readPixels(GCGLint x, GCGLint y, GCGLsizei width, GCGLsizei height, GCGLenum format, GCGLenum type, ArrayBufferView& pixels)
 {
     if (isContextLostOrPending())
         return;
@@ -3431,7 +3431,7 @@ void WebGLRenderingContextBase::readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width
     // taint the origin using the WebGL API.
     ASSERT(canvasBase().originClean());
 
-    GC3Denum internalFormat = 0;
+    GCGLenum internalFormat = 0;
     if (m_framebufferBinding) {
         const char* reason = "framebuffer incomplete";
         if (!m_framebufferBinding->onAccess(graphicsContextGL(), &reason)) {
@@ -3574,7 +3574,7 @@ void WebGLRenderingContextBase::readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width
     unsigned totalBytesRequired = 0;
     unsigned padding = 0;
     if (!m_isRobustnessEXTSupported) {
-        GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_packAlignment, &totalBytesRequired, &padding);
+        GCGLenum error = m_context->computeImageSizeInBytes(format, type, width, height, m_packAlignment, &totalBytesRequired, &padding);
         if (error != GraphicsContextGL::NO_ERROR) {
             synthesizeGLError(error, "readPixels", "invalid dimensions");
             return;
@@ -3601,14 +3601,14 @@ void WebGLRenderingContextBase::releaseShaderCompiler()
     m_context->releaseShaderCompiler();
 }
 
-void WebGLRenderingContextBase::sampleCoverage(GC3Dfloat value, GC3Dboolean invert)
+void WebGLRenderingContextBase::sampleCoverage(GCGLfloat value, GCGLboolean invert)
 {
     if (isContextLostOrPending())
         return;
     m_context->sampleCoverage(value, invert);
 }
 
-void WebGLRenderingContextBase::scissor(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)
+void WebGLRenderingContextBase::scissor(GCGLint x, GCGLint y, GCGLsizei width, GCGLsizei height)
 {
     if (isContextLostOrPending())
         return;
@@ -3632,7 +3632,7 @@ void WebGLRenderingContextBase::shaderSource(WebGLShader* shader, const String&
     shader->setSource(string);
 }
 
-void WebGLRenderingContextBase::stencilFunc(GC3Denum func, GC3Dint ref, GC3Duint mask)
+void WebGLRenderingContextBase::stencilFunc(GCGLenum func, GCGLint ref, GCGLuint mask)
 {
     if (isContextLostOrPending())
         return;
@@ -3645,7 +3645,7 @@ void WebGLRenderingContextBase::stencilFunc(GC3Denum func, GC3Dint ref, GC3Duint
     m_context->stencilFunc(func, ref, mask);
 }
 
-void WebGLRenderingContextBase::stencilFuncSeparate(GC3Denum face, GC3Denum func, GC3Dint ref, GC3Duint mask)
+void WebGLRenderingContextBase::stencilFuncSeparate(GCGLenum face, GCGLenum func, GCGLint ref, GCGLuint mask)
 {
     if (isContextLostOrPending())
         return;
@@ -3673,7 +3673,7 @@ void WebGLRenderingContextBase::stencilFuncSeparate(GC3Denum face, GC3Denum func
     m_context->stencilFuncSeparate(face, func, ref, mask);
 }
 
-void WebGLRenderingContextBase::stencilMask(GC3Duint mask)
+void WebGLRenderingContextBase::stencilMask(GCGLuint mask)
 {
     if (isContextLostOrPending())
         return;
@@ -3682,7 +3682,7 @@ void WebGLRenderingContextBase::stencilMask(GC3Duint mask)
     m_context->stencilMask(mask);
 }
 
-void WebGLRenderingContextBase::stencilMaskSeparate(GC3Denum face, GC3Duint mask)
+void WebGLRenderingContextBase::stencilMaskSeparate(GCGLenum face, GCGLuint mask)
 {
     if (isContextLostOrPending())
         return;
@@ -3704,21 +3704,21 @@ void WebGLRenderingContextBase::stencilMaskSeparate(GC3Denum face, GC3Duint mask
     m_context->stencilMaskSeparate(face, mask);
 }
 
-void WebGLRenderingContextBase::stencilOp(GC3Denum fail, GC3Denum zfail, GC3Denum zpass)
+void WebGLRenderingContextBase::stencilOp(GCGLenum fail, GCGLenum zfail, GCGLenum zpass)
 {
     if (isContextLostOrPending())
         return;
     m_context->stencilOp(fail, zfail, zpass);
 }
 
-void WebGLRenderingContextBase::stencilOpSeparate(GC3Denum face, GC3Denum fail, GC3Denum zfail, GC3Denum zpass)
+void WebGLRenderingContextBase::stencilOpSeparate(GCGLenum face, GCGLenum fail, GCGLenum zfail, GCGLenum zpass)
 {
     if (isContextLostOrPending())
         return;
     m_context->stencilOpSeparate(face, fail, zfail, zpass);
 }
 
-void WebGLRenderingContextBase::texImage2DBase(GC3Denum target, GC3Dint level, GC3Denum internalFormat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels)
+void WebGLRenderingContextBase::texImage2DBase(GCGLenum target, GCGLint level, GCGLenum internalFormat, GCGLsizei width, GCGLsizei height, GCGLint border, GCGLenum format, GCGLenum type, const void* pixels)
 {
     // FIXME: For now we ignore any errors returned.
     auto tex = validateTextureBinding("texImage2D", target, true);
@@ -3742,7 +3742,7 @@ void WebGLRenderingContextBase::texImage2DBase(GC3Denum target, GC3Dint level, G
     tex->setLevelInfo(target, level, internalFormat, width, height, type);
 }
 
-void WebGLRenderingContextBase::texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image* image, GraphicsContextGL::DOMSource domSource, bool flipY, bool premultiplyAlpha)
+void WebGLRenderingContextBase::texImage2DImpl(GCGLenum target, GCGLint level, GCGLenum internalformat, GCGLenum format, GCGLenum type, Image* image, GraphicsContextGL::DOMSource domSource, bool flipY, bool premultiplyAlpha)
 {
     Vector<uint8_t> data;
     GraphicsContextGLOpenGL::ImageExtractor imageExtractor(image, domSource, premultiplyAlpha, m_unpackColorspaceConversion == GraphicsContextGL::NONE);
@@ -3771,7 +3771,7 @@ void WebGLRenderingContextBase::texImage2DImpl(GC3Denum target, GC3Dint level, G
         m_context->pixelStorei(GraphicsContextGL::UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
-bool WebGLRenderingContextBase::validateTexFunc(const char* functionName, TexFuncValidationFunctionType functionType, TexFuncValidationSourceType sourceType, GC3Denum target, GC3Dint level, GC3Denum internalFormat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, GC3Dint xoffset, GC3Dint yoffset)
+bool WebGLRenderingContextBase::validateTexFunc(const char* functionName, TexFuncValidationFunctionType functionType, TexFuncValidationSourceType sourceType, GCGLenum target, GCGLint level, GCGLenum internalFormat, GCGLsizei width, GCGLsizei height, GCGLint border, GCGLenum format, GCGLenum type, GCGLint xoffset, GCGLint yoffset)
 {
     if (!validateTexFuncParameters(functionName, functionType, target, level, internalFormat, width, height, border, format, type))
         return false;
@@ -3816,7 +3816,7 @@ bool WebGLRenderingContextBase::validateTexFunc(const char* functionName, TexFun
     return true;
 }
 
-void WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalFormat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&& pixels)
+void WebGLRenderingContextBase::texImage2D(GCGLenum target, GCGLint level, GCGLenum internalFormat, GCGLsizei width, GCGLsizei height, GCGLint border, GCGLenum format, GCGLenum type, RefPtr<ArrayBufferView>&& pixels)
 {
     if (isContextLostOrPending() || !validateTexFuncData("texImage2D", level, width, height, internalFormat, format, type, pixels.get(), NullAllowed)
         || !validateTexFunc("texImage2D", TexImage, SourceArrayBufferView, target, level, internalFormat, width, height, border, format, type, 0, 0))
@@ -3841,7 +3841,7 @@ void WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3De
         m_context->pixelStorei(GraphicsContextGL::UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
-void WebGLRenderingContextBase::texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image* image, GraphicsContextGL::DOMSource domSource, bool flipY, bool premultiplyAlpha)
+void WebGLRenderingContextBase::texSubImage2DImpl(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLenum format, GCGLenum type, Image* image, GraphicsContextGL::DOMSource domSource, bool flipY, bool premultiplyAlpha)
 {
     Vector<uint8_t> data;
     GraphicsContextGLOpenGL::ImageExtractor imageExtractor(image, domSource, premultiplyAlpha, m_unpackColorspaceConversion == GraphicsContextGL::NONE);
@@ -3872,7 +3872,7 @@ void WebGLRenderingContextBase::texSubImage2DImpl(GC3Denum target, GC3Dint level
         m_context->pixelStorei(GraphicsContextGL::UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
-void WebGLRenderingContextBase::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&& pixels)
+void WebGLRenderingContextBase::texSubImage2D(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLsizei width, GCGLsizei height, GCGLenum format, GCGLenum type, RefPtr<ArrayBufferView>&& pixels)
 {
     if (isContextLostOrPending())
         return;
@@ -3881,7 +3881,7 @@ void WebGLRenderingContextBase::texSubImage2D(GC3Denum target, GC3Dint level, GC
     if (!texture)
         return;
 
-    GC3Denum internalFormat = texture->getInternalFormat(target, level);
+    GCGLenum internalFormat = texture->getInternalFormat(target, level);
     if (!internalFormat) {
         synthesizeGLError(GraphicsContextGL::INVALID_VALUE, "texSubImage2D", "invalid texture target or level");
         return;
@@ -3911,7 +3911,7 @@ void WebGLRenderingContextBase::texSubImage2D(GC3Denum target, GC3Dint level, GC
         m_context->pixelStorei(GraphicsContextGL::UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
-ExceptionOr<void> WebGLRenderingContextBase::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Optional<TexImageSource>&& source)
+ExceptionOr<void> WebGLRenderingContextBase::texSubImage2D(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLenum format, GCGLenum type, Optional<TexImageSource>&& source)
 {
     if (!source) {
         synthesizeGLError(GraphicsContextGL::INVALID_VALUE, "texSubImage2D", "source is null");
@@ -3926,7 +3926,7 @@ ExceptionOr<void> WebGLRenderingContextBase::texSubImage2D(GC3Denum target, GC3D
         if (!texture)
             return { };
 
-        GC3Denum internalFormat = texture->getInternalFormat(target, level);
+        GCGLenum internalFormat = texture->getInternalFormat(target, level);
         if (!internalFormat) {
             synthesizeGLError(GraphicsContextGL::INVALID_VALUE, "texSubImage2D", "invalid texture target or level");
             return { };
@@ -3948,7 +3948,7 @@ ExceptionOr<void> WebGLRenderingContextBase::texSubImage2D(GC3Denum target, GC3D
         if (!texture)
             return { };
 
-        GC3Denum internalFormat = texture->getInternalFormat(target, level);
+        GCGLenum internalFormat = texture->getInternalFormat(target, level);
         if (!internalFormat) {
             synthesizeGLError(GraphicsContextGL::INVALID_VALUE, "texSubImage2D", "invalid texture target or level");
             return { };
@@ -3998,7 +3998,7 @@ ExceptionOr<void> WebGLRenderingContextBase::texSubImage2D(GC3Denum target, GC3D
         if (!texture)
             return { };
 
-        GC3Denum internalFormat = texture->getInternalFormat(target, level);
+        GCGLenum internalFormat = texture->getInternalFormat(target, level);
         if (!internalFormat) {
             synthesizeGLError(GraphicsContextGL::INVALID_VALUE, "texSubImage2D", "invalid texture target or level");
             return { };
@@ -4022,7 +4022,7 @@ ExceptionOr<void> WebGLRenderingContextBase::texSubImage2D(GC3Denum target, GC3D
         if (!texture)
             return { };
 
-        GC3Denum internalFormat = texture->getInternalFormat(target, level);
+        GCGLenum internalFormat = texture->getInternalFormat(target, level);
         if (!internalFormat) {
             synthesizeGLError(GraphicsContextGL::INVALID_VALUE, "texSubImage2D", "invalid texture target or level");
             return { };
@@ -4052,7 +4052,7 @@ ExceptionOr<void> WebGLRenderingContextBase::texSubImage2D(GC3Denum target, GC3D
         if (!texture)
             return { };
 
-        GC3Denum internalFormat = texture->getInternalFormat(target, level);
+        GCGLenum internalFormat = texture->getInternalFormat(target, level);
         if (!internalFormat) {
             synthesizeGLError(GraphicsContextGL::INVALID_VALUE, "texSubImage2D", "invalid texture target or level");
             return { };
@@ -4073,7 +4073,7 @@ ExceptionOr<void> WebGLRenderingContextBase::texSubImage2D(GC3Denum target, GC3D
     return WTF::visit(visitor, source.value());
 }
 
-bool WebGLRenderingContextBase::validateArrayBufferType(const char* functionName, GC3Denum type, Optional<JSC::TypedArrayType> arrayType)
+bool WebGLRenderingContextBase::validateArrayBufferType(const char* functionName, GCGLenum type, Optional<JSC::TypedArrayType> arrayType)
 {
 #define TYPE_VALIDATION_CASE(arrayTypeMacro) if (arrayType && arrayType.value() != JSC::arrayTypeMacro) { \
             synthesizeGLError(GraphicsContextGL::INVALID_OPERATION, functionName, "ArrayBufferView not " #arrayTypeMacro); \
@@ -4115,7 +4115,7 @@ bool WebGLRenderingContextBase::validateArrayBufferType(const char* functionName
     return true;
 }
 
-bool WebGLRenderingContextBase::validateTexFuncData(const char* functionName, GC3Dint level, GC3Dsizei width, GC3Dsizei height, GC3Denum internalFormat, GC3Denum format, GC3Denum type, ArrayBufferView* pixels, NullDisposition disposition)
+bool WebGLRenderingContextBase::validateTexFuncData(const char* functionName, GCGLint level, GCGLsizei width, GCGLsizei height, GCGLenum internalFormat, GCGLenum format, GCGLenum type, ArrayBufferView* pixels, NullDisposition disposition)
 {
     if (!pixels) {
         if (disposition == NullAllowed)
@@ -4132,7 +4132,7 @@ bool WebGLRenderingContextBase::validateTexFuncData(const char* functionName, GC
         return false;
     
     unsigned totalBytesRequired;
-    GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_unpackAlignment, &totalBytesRequired, nullptr);
+    GCGLenum error = m_context->computeImageSizeInBytes(format, type, width, height, m_unpackAlignment, &totalBytesRequired, nullptr);
     if (error != GraphicsContextGL::NO_ERROR) {
         synthesizeGLError(error, functionName, "invalid texture dimensions");
         return false;
@@ -4146,10 +4146,10 @@ bool WebGLRenderingContextBase::validateTexFuncData(const char* functionName, GC
 
 bool WebGLRenderingContextBase::validateTexFuncParameters(const char* functionName,
     TexFuncValidationFunctionType functionType,
-    GC3Denum target, GC3Dint level,
-    GC3Denum internalformat,
-    GC3Dsizei width, GC3Dsizei height, GC3Dint border,
-    GC3Denum format, GC3Denum type)
+    GCGLenum target, GCGLint level,
+    GCGLenum internalformat,
+    GCGLsizei width, GCGLsizei height, GCGLint border,
+    GCGLenum format, GCGLenum type)
 {
     // We absolutely have to validate the format and type combination.
     // The texImage2D entry points taking HTMLImage, etc. will produce
@@ -4162,7 +4162,7 @@ bool WebGLRenderingContextBase::validateTexFuncParameters(const char* functionNa
         return false;
     }
     
-    GC3Dint maxTextureSizeForLevel = pow(2.0, m_maxTextureLevel - 1 - level);
+    GCGLint maxTextureSizeForLevel = pow(2.0, m_maxTextureLevel - 1 - level);
     switch (target) {
     case GraphicsContextGL::TEXTURE_2D:
         if (width > maxTextureSizeForLevel || height > maxTextureSizeForLevel) {
@@ -4200,7 +4200,7 @@ bool WebGLRenderingContextBase::validateTexFuncParameters(const char* functionNa
     return true;
 }
 
-bool WebGLRenderingContextBase::validateTexFuncFormatAndType(const char* functionName, GC3Denum internalFormat, GC3Denum format, GC3Denum type, GC3Dint level)
+bool WebGLRenderingContextBase::validateTexFuncFormatAndType(const char* functionName, GCGLenum internalFormat, GCGLenum format, GCGLenum type, GCGLint level)
 {
     switch (format) {
     case GraphicsContextGL::ALPHA:
@@ -4405,7 +4405,7 @@ bool WebGLRenderingContextBase::validateTexFuncFormatAndType(const char* functio
     return true;
 }
 
-void WebGLRenderingContextBase::texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum internalFormat, GC3Denum format, GC3Denum type, const void* pixels)
+void WebGLRenderingContextBase::texSubImage2DBase(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLsizei width, GCGLsizei height, GCGLenum internalFormat, GCGLenum format, GCGLenum type, const void* pixels)
 {
     ASSERT(!isContextLost());
     ASSERT(validateTexFuncParameters("texSubImage2D", TexSubImage, target, level, internalFormat, width, height, 0, format, type));
@@ -4424,7 +4424,7 @@ void WebGLRenderingContextBase::texSubImage2DBase(GC3Denum target, GC3Dint level
     m_context->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
-void WebGLRenderingContextBase::copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalFormat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border)
+void WebGLRenderingContextBase::copyTexImage2D(GCGLenum target, GCGLint level, GCGLenum internalFormat, GCGLint x, GCGLint y, GCGLsizei width, GCGLsizei height, GCGLint border)
 {
     if (isContextLostOrPending())
         return;
@@ -4450,8 +4450,8 @@ void WebGLRenderingContextBase::copyTexImage2D(GC3Denum target, GC3Dint level, G
     }
     clearIfComposited();
 
-    GC3Dint clippedX, clippedY;
-    GC3Dsizei clippedWidth, clippedHeight;
+    GCGLint clippedX, clippedY;
+    GCGLsizei clippedWidth, clippedHeight;
     if (clip2D(x, y, width, height, getBoundFramebufferWidth(), getBoundFramebufferHeight(), &clippedX, &clippedY, &clippedWidth, &clippedHeight)) {
         m_context->texImage2DResourceSafe(target, level, internalFormat, width, height, border,
             internalFormat, GraphicsContextGL::UNSIGNED_BYTE, m_unpackAlignment);
@@ -4466,7 +4466,7 @@ void WebGLRenderingContextBase::copyTexImage2D(GC3Denum target, GC3Dint level, G
     tex->setLevelInfo(target, level, internalFormat, width, height, GraphicsContextGL::UNSIGNED_BYTE);
 }
 
-static bool isRGBFormat(GC3Denum internalFormat)
+static bool isRGBFormat(GCGLenum internalFormat)
 {
     return internalFormat == GraphicsContextGL::RGB
         || internalFormat == GraphicsContextGL::RGBA
@@ -4474,7 +4474,7 @@ static bool isRGBFormat(GC3Denum internalFormat)
         || internalFormat == GraphicsContextGL::RGBA8;
 }
 
-ExceptionOr<void> WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Optional<TexImageSource> source)
+ExceptionOr<void> WebGLRenderingContextBase::texImage2D(GCGLenum target, GCGLint level, GCGLenum internalformat, GCGLenum format, GCGLenum type, Optional<TexImageSource> source)
 {
     if (!source) {
         synthesizeGLError(GraphicsContextGL::INVALID_VALUE, "texImage2D", "source is null");
@@ -4668,7 +4668,7 @@ RefPtr<Image> WebGLRenderingContextBase::videoFrameToImage(HTMLVideoElement* vid
 
 #endif
 
-void WebGLRenderingContextBase::texParameter(GC3Denum target, GC3Denum pname, GC3Dfloat paramf, GC3Dint parami, bool isFloat)
+void WebGLRenderingContextBase::texParameter(GCGLenum target, GCGLenum pname, GCGLfloat paramf, GCGLint parami, bool isFloat)
 {
     if (isContextLostOrPending())
         return;
@@ -4706,17 +4706,17 @@ void WebGLRenderingContextBase::texParameter(GC3Denum target, GC3Denum pname, GC
     }
 }
 
-void WebGLRenderingContextBase::texParameterf(GC3Denum target, GC3Denum pname, GC3Dfloat param)
+void WebGLRenderingContextBase::texParameterf(GCGLenum target, GCGLenum pname, GCGLfloat param)
 {
     texParameter(target, pname, param, 0, true);
 }
 
-void WebGLRenderingContextBase::texParameteri(GC3Denum target, GC3Denum pname, GC3Dint param)
+void WebGLRenderingContextBase::texParameteri(GCGLenum target, GCGLenum pname, GCGLint param)
 {
     texParameter(target, pname, 0, param, false);
 }
 
-void WebGLRenderingContextBase::uniform1f(const WebGLUniformLocation* location, GC3Dfloat x)
+void WebGLRenderingContextBase::uniform1f(const WebGLUniformLocation* location, GCGLfloat x)
 {
     if (isContextLostOrPending() || !location)
         return;
@@ -4729,7 +4729,7 @@ void WebGLRenderingContextBase::uniform1f(const WebGLUniformLocation* location,
     m_context->uniform1f(location->location(), x);
 }
 
-void WebGLRenderingContextBase::uniform2f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y)
+void WebGLRenderingContextBase::uniform2f(const WebGLUniformLocation* location, GCGLfloat x, GCGLfloat y)
 {
     if (isContextLostOrPending() || !location)
         return;
@@ -4742,7 +4742,7 @@ void WebGLRenderingContextBase::uniform2f(const WebGLUniformLocation* location,
     m_context->uniform2f(location->location(), x, y);
 }
 
-void WebGLRenderingContextBase::uniform3f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z)
+void WebGLRenderingContextBase::uniform3f(const WebGLUniformLocation* location, GCGLfloat x, GCGLfloat y, GCGLfloat z)
 {
     if (isContextLostOrPending() || !location)
         return;
@@ -4755,7 +4755,7 @@ void WebGLRenderingContextBase::uniform3f(const WebGLUniformLocation* location,
     m_context->uniform3f(location->location(), x, y, z);
 }
 
-void WebGLRenderingContextBase::uniform4f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w)
+void WebGLRenderingContextBase::uniform4f(const WebGLUniformLocation* location, GCGLfloat x, GCGLfloat y, GCGLfloat z, GCGLfloat w)
 {
     if (isContextLostOrPending() || !location)
         return;
@@ -4768,7 +4768,7 @@ void WebGLRenderingContextBase::uniform4f(const WebGLUniformLocation* location,
     m_context->uniform4f(location->location(), x, y, z, w);
 }
 
-void WebGLRenderingContextBase::uniform1i(const WebGLUniformLocation* location, GC3Dint x)
+void WebGLRenderingContextBase::uniform1i(const WebGLUniformLocation* location, GCGLint x)
 {
     if (isContextLostOrPending() || !location)
         return;
@@ -4786,7 +4786,7 @@ void WebGLRenderingContextBase::uniform1i(const WebGLUniformLocation* location,
     m_context->uniform1i(location->location(), x);
 }
 
-void WebGLRenderingContextBase::uniform2i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y)
+void WebGLRenderingContextBase::uniform2i(const WebGLUniformLocation* location, GCGLint x, GCGLint y)
 {
     if (isContextLostOrPending() || !location)
         return;
@@ -4799,7 +4799,7 @@ void WebGLRenderingContextBase::uniform2i(const WebGLUniformLocation* location,
     m_context->uniform2i(location->location(), x, y);
 }
 
-void WebGLRenderingContextBase::uniform3i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z)
+void WebGLRenderingContextBase::uniform3i(const WebGLUniformLocation* location, GCGLint x, GCGLint y, GCGLint z)
 {
     if (isContextLostOrPending() || !location)
         return;
@@ -4812,7 +4812,7 @@ void WebGLRenderingContextBase::uniform3i(const WebGLUniformLocation* location,
     m_context->uniform3i(location->location(), x, y, z);
 }
 
-void WebGLRenderingContextBase::uniform4i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w)
+void WebGLRenderingContextBase::uniform4i(const WebGLUniformLocation* location, GCGLint x, GCGLint y, GCGLint z, GCGLint w)
 {
     if (isContextLostOrPending() || !location)
         return;
@@ -4902,21 +4902,21 @@ void WebGLRenderingContextBase::uniform4iv(const WebGLUniformLocation* location,
     m_context->uniform4iv(location->location(), v.length() / 4, v.data());
 }
 
-void WebGLRenderingContextBase::uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32List&& v)
+void WebGLRenderingContextBase::uniformMatrix2fv(const WebGLUniformLocation* location, GCGLboolean transpose, Float32List&& v)
 {
     if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v, 4))
         return;
     m_context->uniformMatrix2fv(location->location(), v.length() / 4, transpose, v.data());
 }
 
-void WebGLRenderingContextBase::uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32List&& v)
+void WebGLRenderingContextBase::uniformMatrix3fv(const WebGLUniformLocation* location, GCGLboolean 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::uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32List&& v)
+void WebGLRenderingContextBase::uniformMatrix4fv(const WebGLUniformLocation* location, GCGLboolean transpose, Float32List&& v)
 {
     if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v, 16))
         return;
@@ -4951,47 +4951,47 @@ void WebGLRenderingContextBase::validateProgram(WebGLProgram* program)
     m_context->validateProgram(objectOrZero(program));
 }
 
-void WebGLRenderingContextBase::vertexAttrib1f(GC3Duint index, GC3Dfloat v0)
+void WebGLRenderingContextBase::vertexAttrib1f(GCGLuint index, GCGLfloat v0)
 {
     vertexAttribfImpl("vertexAttrib1f", index, 1, v0, 0.0f, 0.0f, 1.0f);
 }
 
-void WebGLRenderingContextBase::vertexAttrib2f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1)
+void WebGLRenderingContextBase::vertexAttrib2f(GCGLuint index, GCGLfloat v0, GCGLfloat v1)
 {
     vertexAttribfImpl("vertexAttrib2f", index, 2, v0, v1, 0.0f, 1.0f);
 }
 
-void WebGLRenderingContextBase::vertexAttrib3f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2)
+void WebGLRenderingContextBase::vertexAttrib3f(GCGLuint index, GCGLfloat v0, GCGLfloat v1, GCGLfloat v2)
 {
     vertexAttribfImpl("vertexAttrib3f", index, 3, v0, v1, v2, 1.0f);
 }
 
-void WebGLRenderingContextBase::vertexAttrib4f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2, GC3Dfloat v3)
+void WebGLRenderingContextBase::vertexAttrib4f(GCGLuint index, GCGLfloat v0, GCGLfloat v1, GCGLfloat v2, GCGLfloat v3)
 {
     vertexAttribfImpl("vertexAttrib4f", index, 4, v0, v1, v2, v3);
 }
 
-void WebGLRenderingContextBase::vertexAttrib1fv(GC3Duint index, Float32List&& v)
+void WebGLRenderingContextBase::vertexAttrib1fv(GCGLuint index, Float32List&& v)
 {
     vertexAttribfvImpl("vertexAttrib1fv", index, WTFMove(v), 1);
 }
 
-void WebGLRenderingContextBase::vertexAttrib2fv(GC3Duint index, Float32List&& v)
+void WebGLRenderingContextBase::vertexAttrib2fv(GCGLuint index, Float32List&& v)
 {
     vertexAttribfvImpl("vertexAttrib2fv", index, WTFMove(v), 2);
 }
 
-void WebGLRenderingContextBase::vertexAttrib3fv(GC3Duint index, Float32List&& v)
+void WebGLRenderingContextBase::vertexAttrib3fv(GCGLuint index, Float32List&& v)
 {
     vertexAttribfvImpl("vertexAttrib3fv", index, WTFMove(v), 3);
 }
 
-void WebGLRenderingContextBase::vertexAttrib4fv(GC3Duint index, Float32List&& v)
+void WebGLRenderingContextBase::vertexAttrib4fv(GCGLuint index, Float32List&& v)
 {
     vertexAttribfvImpl("vertexAttrib4fv", index, WTFMove(v), 4);
 }
 
-void WebGLRenderingContextBase::vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized, GC3Dsizei stride, long long offset)
+void WebGLRenderingContextBase::vertexAttribPointer(GCGLuint index, GCGLint size, GCGLenum type, GCGLboolean normalized, GCGLsizei stride, long long offset)
 {
     if (isContextLostOrPending())
         return;
@@ -5032,17 +5032,17 @@ void WebGLRenderingContextBase::vertexAttribPointer(GC3Duint index, GC3Dint size
         synthesizeGLError(GraphicsContextGL::INVALID_ENUM, "vertexAttribPointer", "invalid type");
         return;
     }
-    if ((stride % typeSize) || (static_cast<GC3Dintptr>(offset) % typeSize)) {
+    if ((stride % typeSize) || (static_cast<GCGLintptr>(offset) % typeSize)) {
         synthesizeGLError(GraphicsContextGL::INVALID_OPERATION, "vertexAttribPointer", "stride or offset not valid for type");
         return;
     }
-    GC3Dsizei bytesPerElement = size * typeSize;
+    GCGLsizei bytesPerElement = size * typeSize;
 
-    m_boundVertexArrayObject->setVertexAttribState(index, bytesPerElement, size, type, normalized, stride, static_cast<GC3Dintptr>(offset), m_boundArrayBuffer.get());
-    m_context->vertexAttribPointer(index, size, type, normalized, stride, static_cast<GC3Dintptr>(offset));
+    m_boundVertexArrayObject->setVertexAttribState(index, bytesPerElement, size, type, normalized, stride, static_cast<GCGLintptr>(offset), m_boundArrayBuffer.get());
+    m_context->vertexAttribPointer(index, size, type, normalized, stride, static_cast<GCGLintptr>(offset));
 }
 
-void WebGLRenderingContextBase::viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)
+void WebGLRenderingContextBase::viewport(GCGLint x, GCGLint y, GCGLsizei width, GCGLsizei height)
 {
     if (isContextLostOrPending())
         return;
@@ -5196,20 +5196,20 @@ void WebGLRenderingContextBase::resume()
     m_isSuspended = false;
 }
 
-bool WebGLRenderingContextBase::getBooleanParameter(GC3Denum pname)
+bool WebGLRenderingContextBase::getBooleanParameter(GCGLenum pname)
 {
-    GC3Dboolean value = 0;
+    GCGLboolean value = 0;
     m_context->getBooleanv(pname, &value);
     return value;
 }
 
-Vector<bool> WebGLRenderingContextBase::getBooleanArrayParameter(GC3Denum pname)
+Vector<bool> WebGLRenderingContextBase::getBooleanArrayParameter(GCGLenum pname)
 {
     if (pname != GraphicsContextGL::COLOR_WRITEMASK) {
         notImplemented();
         return { };
     }
-    GC3Dboolean value[4] = { 0 };
+    GCGLboolean value[4] = { 0 };
     m_context->getBooleanv(pname, value);
     Vector<bool> vector(4);
     for (unsigned i = 0; i < 4; ++i)
@@ -5217,37 +5217,37 @@ Vector<bool> WebGLRenderingContextBase::getBooleanArrayParameter(GC3Denum pname)
     return vector;
 }
 
-float WebGLRenderingContextBase::getFloatParameter(GC3Denum pname)
+float WebGLRenderingContextBase::getFloatParameter(GCGLenum pname)
 {
-    GC3Dfloat value = 0;
+    GCGLfloat value = 0;
     m_context->getFloatv(pname, &value);
     return value;
 }
 
-int WebGLRenderingContextBase::getIntParameter(GC3Denum pname)
+int WebGLRenderingContextBase::getIntParameter(GCGLenum pname)
 {
-    GC3Dint value = 0;
+    GCGLint value = 0;
     m_context->getIntegerv(pname, &value);
     return value;
 }
 
-unsigned WebGLRenderingContextBase::getUnsignedIntParameter(GC3Denum pname)
+unsigned WebGLRenderingContextBase::getUnsignedIntParameter(GCGLenum pname)
 {
-    GC3Dint value = 0;
+    GCGLint value = 0;
     m_context->getIntegerv(pname, &value);
     return value;
 }
 
-long long WebGLRenderingContextBase::getInt64Parameter(GC3Denum pname)
+long long WebGLRenderingContextBase::getInt64Parameter(GCGLenum pname)
 {
-    GC3Dint64 value = 0;
+    GCGLint64 value = 0;
     m_context->getInteger64v(pname, &value);
     return value;
 }
 
-RefPtr<Float32Array> WebGLRenderingContextBase::getWebGLFloatArrayParameter(GC3Denum pname)
+RefPtr<Float32Array> WebGLRenderingContextBase::getWebGLFloatArrayParameter(GCGLenum pname)
 {
-    GC3Dfloat value[4] = {0};
+    GCGLfloat value[4] = {0};
     m_context->getFloatv(pname, value);
     unsigned length = 0;
     switch (pname) {
@@ -5266,9 +5266,9 @@ RefPtr<Float32Array> WebGLRenderingContextBase::getWebGLFloatArrayParameter(GC3D
     return Float32Array::tryCreate(value, length);
 }
 
-RefPtr<Int32Array> WebGLRenderingContextBase::getWebGLIntArrayParameter(GC3Denum pname)
+RefPtr<Int32Array> WebGLRenderingContextBase::getWebGLIntArrayParameter(GCGLenum pname)
 {
-    GC3Dint value[4] = {0};
+    GCGLint value[4] = {0};
     m_context->getIntegerv(pname, value);
     unsigned length = 0;
     switch (pname) {
@@ -5363,14 +5363,14 @@ void WebGLRenderingContextBase::createFallbackBlackTextures1x1()
     m_context->bindTexture(GraphicsContextGL::TEXTURE_CUBE_MAP, 0);
 }
 
-bool WebGLRenderingContextBase::isTexInternalFormatColorBufferCombinationValid(GC3Denum texInternalFormat, GC3Denum colorBufferFormat)
+bool WebGLRenderingContextBase::isTexInternalFormatColorBufferCombinationValid(GCGLenum texInternalFormat, GCGLenum colorBufferFormat)
 {
     auto need = GraphicsContextGLOpenGL::getChannelBitsByFormat(texInternalFormat);
     auto have = GraphicsContextGLOpenGL::getChannelBitsByFormat(colorBufferFormat);
     return (need & have) == need;
 }
 
-GC3Denum WebGLRenderingContextBase::getBoundFramebufferColorFormat()
+GCGLenum WebGLRenderingContextBase::getBoundFramebufferColorFormat()
 {
     if (m_framebufferBinding && m_framebufferBinding->object())
         return m_framebufferBinding->getColorBufferFormat();
@@ -5393,7 +5393,7 @@ int WebGLRenderingContextBase::getBoundFramebufferHeight()
     return m_context->getInternalFramebufferSize().height();
 }
 
-RefPtr<WebGLTexture> WebGLRenderingContextBase::validateTextureBinding(const char* functionName, GC3Denum target, bool useSixEnumsForCubeMap)
+RefPtr<WebGLTexture> WebGLRenderingContextBase::validateTextureBinding(const char* functionName, GCGLenum target, bool useSixEnumsForCubeMap)
 {
     RefPtr<WebGLTexture> texture;
     switch (target) {
@@ -5442,7 +5442,7 @@ bool WebGLRenderingContextBase::validateLocationLength(const char* functionName,
     return true;
 }
 
-bool WebGLRenderingContextBase::validateSize(const char* functionName, GC3Dint x, GC3Dint y)
+bool WebGLRenderingContextBase::validateSize(const char* functionName, GCGLint x, GCGLint y)
 {
     if (x < 0 || y < 0) {
         synthesizeGLError(GraphicsContextGL::INVALID_VALUE, functionName, "size < 0");
@@ -5462,7 +5462,7 @@ bool WebGLRenderingContextBase::validateString(const char* functionName, const S
     return true;
 }
 
-bool WebGLRenderingContextBase::validateTexFuncLevel(const char* functionName, GC3Denum target, GC3Dint level)
+bool WebGLRenderingContextBase::validateTexFuncLevel(const char* functionName, GCGLenum target, GCGLint level)
 {
     if (level < 0) {
         synthesizeGLError(GraphicsContextGL::INVALID_VALUE, functionName, "level < 0");
@@ -5492,7 +5492,7 @@ bool WebGLRenderingContextBase::validateTexFuncLevel(const char* functionName, G
     return true;
 }
 
-bool WebGLRenderingContextBase::validateCompressedTexFormat(GC3Denum format)
+bool WebGLRenderingContextBase::validateCompressedTexFormat(GCGLenum format)
 {
     return m_compressedTextureFormats.contains(format);
 }
@@ -5503,12 +5503,12 @@ struct BlockParameters {
     const int size;
 };
 
-static inline unsigned calculateBytesForASTC(GC3Dsizei width, GC3Dsizei height, const BlockParameters& parameters)
+static inline unsigned calculateBytesForASTC(GCGLsizei width, GCGLsizei height, const BlockParameters& parameters)
 {
     return ((width + parameters.width - 1) / parameters.width) * ((height + parameters.height - 1) / parameters.height) * parameters.size;
 }
 
-bool WebGLRenderingContextBase::validateCompressedTexFuncData(const char* functionName, GC3Dsizei width, GC3Dsizei height, GC3Denum format, ArrayBufferView& pixels)
+bool WebGLRenderingContextBase::validateCompressedTexFuncData(const char* functionName, GCGLsizei width, GCGLsizei height, GCGLenum format, ArrayBufferView& pixels)
 {
     if (width < 0 || height < 0) {
         synthesizeGLError(GraphicsContextGL::INVALID_VALUE, functionName, "width or height < 0");
@@ -5535,8 +5535,8 @@ bool WebGLRenderingContextBase::validateCompressedTexFuncData(const char* functi
         BlockParameters { 12, 10, kASTCBlockSize },
         BlockParameters { 12, 12, kASTCBlockSize }
     };
-    const GC3Denum ASTCEnumStartRGBA = ExtensionsGL::COMPRESSED_RGBA_ASTC_4x4_KHR;
-    const GC3Denum ASTCEnumStartSRGB8 = ExtensionsGL::COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR;
+    const GCGLenum ASTCEnumStartRGBA = ExtensionsGL::COMPRESSED_RGBA_ASTC_4x4_KHR;
+    const GCGLenum ASTCEnumStartSRGB8 = ExtensionsGL::COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR;
 
     const int kEACAndETC2BlockSize = 4;
 
@@ -5659,17 +5659,17 @@ bool WebGLRenderingContextBase::validateCompressedTexFuncData(const char* functi
     return true;
 }
 
-bool WebGLRenderingContextBase::validateCompressedTexDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dsizei width, GC3Dsizei height, GC3Denum format)
+bool WebGLRenderingContextBase::validateCompressedTexDimensions(const char* functionName, GCGLenum target, GCGLint level, GCGLsizei width, GCGLsizei height, GCGLenum format)
 {
     switch (format) {
     case ExtensionsGL::COMPRESSED_RGB_S3TC_DXT1_EXT:
     case ExtensionsGL::COMPRESSED_RGBA_S3TC_DXT1_EXT:
     case ExtensionsGL::COMPRESSED_RGBA_S3TC_DXT3_EXT:
     case ExtensionsGL::COMPRESSED_RGBA_S3TC_DXT5_EXT: {
-        const GC3Dsizei kBlockWidth = 4;
-        const GC3Dsizei kBlockHeight = 4;
-        const GC3Dint maxTextureSize = target ? m_maxTextureSize : m_maxCubeMapTextureSize;
-        const GC3Dsizei maxCompressedDimension = maxTextureSize >> level;
+        const GCGLsizei kBlockWidth = 4;
+        const GCGLsizei kBlockHeight = 4;
+        const GCGLint maxTextureSize = target ? m_maxTextureSize : m_maxCubeMapTextureSize;
+        const GCGLsizei maxCompressedDimension = maxTextureSize >> level;
         bool widthValid = (level && width == 1) || (level && width == 2) || (!(width % kBlockWidth) && width <= maxCompressedDimension);
         bool heightValid = (level && height == 1) || (level && height == 2) || (!(height % kBlockHeight) && height <= maxCompressedDimension);
         if (!widthValid || !heightValid) {
@@ -5734,8 +5734,7 @@ bool WebGLRenderingContextBase::validateCompressedTexDimensions(const char* func
     }
 }
 
-bool WebGLRenderingContextBase::validateCompressedTexSubDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-                                                               GC3Dsizei width, GC3Dsizei height, GC3Denum format, WebGLTexture* tex)
+bool WebGLRenderingContextBase::validateCompressedTexSubDimensions(const char* functionName, GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLsizei width, GCGLsizei height, GCGLenum format, WebGLTexture* tex)
 {
     if (xoffset < 0 || yoffset < 0) {
         synthesizeGLError(GraphicsContextGL::INVALID_VALUE, functionName, "xoffset or yoffset < 0");
@@ -5808,7 +5807,7 @@ bool WebGLRenderingContextBase::validateCompressedTexSubDimensions(const char* f
     }
 }
 
-bool WebGLRenderingContextBase::validateDrawMode(const char* functionName, GC3Denum mode)
+bool WebGLRenderingContextBase::validateDrawMode(const char* functionName, GCGLenum mode)
 {
     switch (mode) {
     case GraphicsContextGL::POINTS:
@@ -5834,7 +5833,7 @@ bool WebGLRenderingContextBase::validateStencilSettings(const char* functionName
     return true;
 }
 
-bool WebGLRenderingContextBase::validateStencilFunc(const char* functionName, GC3Denum func)
+bool WebGLRenderingContextBase::validateStencilFunc(const char* functionName, GCGLenum func)
 {
     switch (func) {
     case GraphicsContextGL::NEVER:
@@ -5875,7 +5874,7 @@ void WebGLRenderingContextBase::printToConsole(MessageLevel level, const String&
         printToConsole(MessageLevel::Warning, "WebGL: too many errors, no more errors will be reported to the console for this context.");
 }
 
-bool WebGLRenderingContextBase::validateBlendFuncFactors(const char* functionName, GC3Denum src, GC3Denum dst)
+bool WebGLRenderingContextBase::validateBlendFuncFactors(const char* functionName, GCGLenum src, GCGLenum dst)
 {
     if (((src == GraphicsContextGL::CONSTANT_COLOR || src == GraphicsContextGL::ONE_MINUS_CONSTANT_COLOR)
         && (dst == GraphicsContextGL::CONSTANT_ALPHA || dst == GraphicsContextGL::ONE_MINUS_CONSTANT_ALPHA))
@@ -5887,27 +5886,27 @@ bool WebGLRenderingContextBase::validateBlendFuncFactors(const char* functionNam
     return true;
 }
 
-bool WebGLRenderingContextBase::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, const Float32List& v, GC3Dsizei requiredMinSize)
+bool WebGLRenderingContextBase::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, const Float32List& v, GCGLsizei requiredMinSize)
 {
     return validateUniformMatrixParameters(functionName, location, false, v.data(), v.length(), requiredMinSize);
 }
 
-bool WebGLRenderingContextBase::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, const Int32List& v, GC3Dsizei requiredMinSize)
+bool WebGLRenderingContextBase::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, const Int32List& v, GCGLsizei requiredMinSize)
 {
     return validateUniformMatrixParameters(functionName, location, false, v.data(), v.length(), requiredMinSize);
 }
 
-bool WebGLRenderingContextBase::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, void* v, GC3Dsizei size, GC3Dsizei requiredMinSize)
+bool WebGLRenderingContextBase::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, void* v, GCGLsizei size, GCGLsizei requiredMinSize)
 {
     return validateUniformMatrixParameters(functionName, location, false, v, size, requiredMinSize);
 }
 
-bool WebGLRenderingContextBase::validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation* location, GC3Dboolean transpose, const Float32List& v, GC3Dsizei requiredMinSize)
+bool WebGLRenderingContextBase::validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation* location, GCGLboolean transpose, const Float32List& v, GCGLsizei requiredMinSize)
 {
     return validateUniformMatrixParameters(functionName, location, transpose, v.data(), v.length(), requiredMinSize);
 }
 
-bool WebGLRenderingContextBase::validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation* location, GC3Dboolean transpose, const void* v, GC3Dsizei size, GC3Dsizei requiredMinSize)
+bool WebGLRenderingContextBase::validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation* location, GCGLboolean transpose, const void* v, GCGLsizei size, GCGLsizei requiredMinSize)
 {
     if (!location)
         return false;
@@ -5930,7 +5929,7 @@ bool WebGLRenderingContextBase::validateUniformMatrixParameters(const char* func
     return true;
 }
 
-WebGLBuffer* WebGLRenderingContextBase::validateBufferDataParameters(const char* functionName, GC3Denum target, GC3Denum usage)
+WebGLBuffer* WebGLRenderingContextBase::validateBufferDataParameters(const char* functionName, GCGLenum target, GCGLenum usage)
 {
     Optional<WebGLBuffer*> buffer;
     switch (target) {
@@ -6026,7 +6025,7 @@ ExceptionOr<bool> WebGLRenderingContextBase::validateHTMLVideoElement(const char
 
 #endif
 
-void WebGLRenderingContextBase::vertexAttribfImpl(const char* functionName, GC3Duint index, GC3Dsizei expectedSize, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2, GC3Dfloat v3)
+void WebGLRenderingContextBase::vertexAttribfImpl(const char* functionName, GCGLuint index, GCGLsizei expectedSize, GCGLfloat v0, GCGLfloat v1, GCGLfloat v2, GCGLfloat v3)
 {
     if (isContextLostOrPending())
         return;
@@ -6058,7 +6057,7 @@ void WebGLRenderingContextBase::vertexAttribfImpl(const char* functionName, GC3D
     attribValue.value[3] = v3;
 }
 
-void WebGLRenderingContextBase::vertexAttribfvImpl(const char* functionName, GC3Duint index, Float32List&& list, GC3Dsizei expectedSize)
+void WebGLRenderingContextBase::vertexAttribfvImpl(const char* functionName, GCGLuint index, Float32List&& list, GCGLsizei expectedSize)
 {
     if (isContextLostOrPending())
         return;
@@ -6121,7 +6120,7 @@ void WebGLRenderingContextBase::initVertexAttrib0()
     m_vertexAttrib0UsedBefore = false;
 }
 
-bool WebGLRenderingContextBase::validateSimulatedVertexAttrib0(GC3Duint numVertex)
+bool WebGLRenderingContextBase::validateSimulatedVertexAttrib0(GCGLuint numVertex)
 {
     if (!m_currentProgram)
         return true;
@@ -6134,16 +6133,16 @@ bool WebGLRenderingContextBase::validateSimulatedVertexAttrib0(GC3Duint numVerte
     if (state.enabled)
         return true;
 
-    auto bufferSize = checkedAddAndMultiply<GC3Duint>(numVertex, 1, 4);
+    auto bufferSize = checkedAddAndMultiply<GCGLuint>(numVertex, 1, 4);
     if (!bufferSize)
         return false;
 
-    Checked<GC3Dsizeiptr, RecordOverflow> bufferDataSize(bufferSize.value());
-    bufferDataSize *= Checked<GC3Dsizeiptr>(sizeof(GC3Dfloat));
+    Checked<GCGLsizeiptr, RecordOverflow> bufferDataSize(bufferSize.value());
+    bufferDataSize *= Checked<GCGLsizeiptr>(sizeof(GCGLfloat));
     return !bufferDataSize.hasOverflowed() && bufferDataSize.unsafeGet() > 0;
 }
 
-Optional<bool> WebGLRenderingContextBase::simulateVertexAttrib0(GC3Duint numVertex)
+Optional<bool> WebGLRenderingContextBase::simulateVertexAttrib0(GCGLuint numVertex)
 {
     if (!m_currentProgram)
         return false;
@@ -6160,8 +6159,8 @@ Optional<bool> WebGLRenderingContextBase::simulateVertexAttrib0(GC3Duint numVert
     m_context->bindBuffer(GraphicsContextGL::ARRAY_BUFFER, m_vertexAttrib0Buffer->object());
 
     // We know bufferSize and bufferDataSize won't overflow or go negative, thanks to validateSimulatedVertexAttrib0
-    GC3Duint bufferSize = (numVertex + 1) * 4;
-    GC3Dsizeiptr bufferDataSize = bufferSize * sizeof(GC3Dfloat);
+    GCGLuint bufferSize = (numVertex + 1) * 4;
+    GCGLsizeiptr bufferDataSize = bufferSize * sizeof(GCGLfloat);
 
     if (bufferDataSize > m_vertexAttrib0BufferSize) {
         m_context->moveErrorsToSyntheticErrorList();
@@ -6186,8 +6185,8 @@ Optional<bool> WebGLRenderingContextBase::simulateVertexAttrib0(GC3Duint numVert
             || attribValue.value[2] != m_vertexAttrib0BufferValue[2]
             || attribValue.value[3] != m_vertexAttrib0BufferValue[3])) {
 
-        auto bufferData = makeUniqueArray<GC3Dfloat>(bufferSize);
-        for (GC3Duint ii = 0; ii < numVertex + 1; ++ii) {
+        auto bufferData = makeUniqueArray<GCGLfloat>(bufferSize);
+        for (GCGLuint ii = 0; ii < numVertex + 1; ++ii) {
             bufferData[ii * 4] = attribValue.value[0];
             bufferData[ii * 4 + 1] = attribValue.value[1];
             bufferData[ii * 4 + 2] = attribValue.value[2];
@@ -6364,7 +6363,7 @@ void WebGLRenderingContextBase::LRUImageBufferCache::bubbleToFront(size_t idx)
 
 namespace {
 
-    String GetErrorString(GC3Denum error)
+    String GetErrorString(GCGLenum error)
     {
         switch (error) {
         case GraphicsContextGL::INVALID_ENUM:
@@ -6386,7 +6385,7 @@ namespace {
 
 } // namespace anonymous
 
-void WebGLRenderingContextBase::synthesizeGLError(GC3Denum error, const char* functionName, const char* description, ConsoleDisplayPreference display)
+void WebGLRenderingContextBase::synthesizeGLError(GCGLenum error, const char* functionName, const char* description, ConsoleDisplayPreference display)
 {
     if (m_synthesizedErrorsToConsole && display == DisplayInConsole) {
         String str = "WebGL: " + GetErrorString(error) +  ": " + String(functionName) + ": " + String(description);
@@ -6409,7 +6408,7 @@ void WebGLRenderingContextBase::applyStencilTest()
     enableOrDisable(GraphicsContextGL::STENCIL_TEST, m_stencilEnabled && haveStencilBuffer);
 }
 
-void WebGLRenderingContextBase::enableOrDisable(GC3Denum capability, bool enable)
+void WebGLRenderingContextBase::enableOrDisable(GCGLenum capability, bool enable)
 {
     if (enable)
         m_context->enable(capability);
@@ -6423,7 +6422,7 @@ IntSize WebGLRenderingContextBase::clampedCanvasSize()
         clamp(canvasBase().height(), 1, m_maxViewportDims[1]));
 }
 
-GC3Dint WebGLRenderingContextBase::getMaxDrawBuffers()
+GCGLint WebGLRenderingContextBase::getMaxDrawBuffers()
 {
     if (!supportsDrawBuffers())
         return 0;
@@ -6435,7 +6434,7 @@ GC3Dint WebGLRenderingContextBase::getMaxDrawBuffers()
     return std::min(m_maxDrawBuffers, m_maxColorAttachments);
 }
 
-GC3Dint WebGLRenderingContextBase::getMaxColorAttachments()
+GCGLint WebGLRenderingContextBase::getMaxColorAttachments()
 {
     if (!supportsDrawBuffers())
         return 0;
@@ -6444,7 +6443,7 @@ GC3Dint WebGLRenderingContextBase::getMaxColorAttachments()
     return m_maxColorAttachments;
 }
 
-void WebGLRenderingContextBase::setBackDrawBuffer(GC3Denum buf)
+void WebGLRenderingContextBase::setBackDrawBuffer(GCGLenum buf)
 {
     m_backDrawBuffer = buf;
 }
@@ -6471,7 +6470,7 @@ bool WebGLRenderingContextBase::supportsDrawBuffers()
     return m_drawBuffersSupported;
 }
 
-void WebGLRenderingContextBase::drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount)
+void WebGLRenderingContextBase::drawArraysInstanced(GCGLenum mode, GCGLint first, GCGLsizei count, GCGLsizei primcount)
 {
     if (!primcount) {
         markContextChanged();
@@ -6505,7 +6504,7 @@ void WebGLRenderingContextBase::drawArraysInstanced(GC3Denum mode, GC3Dint first
     markContextChangedAndNotifyCanvasObserver();
 }
 
-void WebGLRenderingContextBase::drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, GC3Dsizei primcount)
+void WebGLRenderingContextBase::drawElementsInstanced(GCGLenum mode, GCGLsizei count, GCGLenum type, long long offset, GCGLsizei primcount)
 {
     if (!primcount) {
         markContextChanged();
@@ -6521,7 +6520,7 @@ void WebGLRenderingContextBase::drawElementsInstanced(GC3Denum mode, GC3Dsizei c
     bool vertexAttrib0Simulated = false;
     if (!isGLES2Compliant()) {
         if (!numElements)
-            validateIndexArrayPrecise(count, type, static_cast<GC3Dintptr>(offset), numElements);
+            validateIndexArrayPrecise(count, type, static_cast<GCGLintptr>(offset), numElements);
         auto simulateVertexAttrib0Status = simulateVertexAttrib0(numElements);
         if (!simulateVertexAttrib0Status) {
             // We were unable to simulate the attribute buffer.
@@ -6538,7 +6537,7 @@ void WebGLRenderingContextBase::drawElementsInstanced(GC3Denum mode, GC3Dsizei c
         m_context->primitiveRestartIndex(getRestartIndex(type));
 #endif
 
-    m_context->drawElementsInstanced(mode, count, type, static_cast<GC3Dintptr>(offset), primcount);
+    m_context->drawElementsInstanced(mode, count, type, static_cast<GCGLintptr>(offset), primcount);
 
     if (!isGLES2Compliant() && vertexAttrib0Simulated)
         restoreStatesAfterVertexAttrib0Simulation();
@@ -6547,7 +6546,7 @@ void WebGLRenderingContextBase::drawElementsInstanced(GC3Denum mode, GC3Dsizei c
     markContextChangedAndNotifyCanvasObserver();
 }
 
-void WebGLRenderingContextBase::vertexAttribDivisor(GC3Duint index, GC3Duint divisor)
+void WebGLRenderingContextBase::vertexAttribDivisor(GCGLuint index, GCGLuint divisor)
 {
     if (isContextLostOrPending())
         return;
index 0c4452b..6acc112 100644 (file)
@@ -114,46 +114,46 @@ public:
     int drawingBufferWidth() const;
     int drawingBufferHeight() const;
 
-    void activeTexture(GC3Denum texture);
+    void activeTexture(GCGLenum texture);
     void attachShader(WebGLProgram*, WebGLShader*);
-    void bindAttribLocation(WebGLProgram*, GC3Duint index, const String& name);
-    void bindBuffer(GC3Denum target, WebGLBuffer*);
-    void bindFramebuffer(GC3Denum target, WebGLFramebuffer*);
-    void bindRenderbuffer(GC3Denum target, WebGLRenderbuffer*);
-    void bindTexture(GC3Denum target, WebGLTexture*);
-    void blendColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha);
-    void blendEquation(GC3Denum mode);
-    void blendEquationSeparate(GC3Denum modeRGB, GC3Denum modeAlpha);
-    void blendFunc(GC3Denum sfactor, GC3Denum dfactor);
-    void blendFuncSeparate(GC3Denum srcRGB, GC3Denum dstRGB, GC3Denum srcAlpha, GC3Denum dstAlpha);
+    void bindAttribLocation(WebGLProgram*, GCGLuint index, const String& name);
+    void bindBuffer(GCGLenum target, WebGLBuffer*);
+    void bindFramebuffer(GCGLenum target, WebGLFramebuffer*);
+    void bindRenderbuffer(GCGLenum target, WebGLRenderbuffer*);
+    void bindTexture(GCGLenum target, WebGLTexture*);
+    void blendColor(GCGLfloat red, GCGLfloat green, GCGLfloat blue, GCGLfloat alpha);
+    void blendEquation(GCGLenum mode);
+    void blendEquationSeparate(GCGLenum modeRGB, GCGLenum modeAlpha);
+    void blendFunc(GCGLenum sfactor, GCGLenum dfactor);
+    void blendFuncSeparate(GCGLenum srcRGB, GCGLenum dstRGB, GCGLenum srcAlpha, GCGLenum dstAlpha);
 
     using BufferDataSource = WTF::Variant<RefPtr<ArrayBuffer>, RefPtr<ArrayBufferView>>;
-    void bufferData(GC3Denum target, long long size, GC3Denum usage);
-    void bufferData(GC3Denum target, Optional<BufferDataSource>&&, GC3Denum usage);
-    void bufferSubData(GC3Denum target, long long offset, Optional<BufferDataSource>&&);
-
-    GC3Denum checkFramebufferStatus(GC3Denum target);
-    virtual void clear(GC3Dbitfield mask) = 0;
-    void clearColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha);
-    void clearDepth(GC3Dfloat);
-    void clearStencil(GC3Dint);
-    void colorMask(GC3Dboolean red, GC3Dboolean green, GC3Dboolean blue, GC3Dboolean alpha);
+    void bufferData(GCGLenum target, long long size, GCGLenum usage);
+    void bufferData(GCGLenum target, Optional<BufferDataSource>&&, GCGLenum usage);
+    void bufferSubData(GCGLenum target, long long offset, Optional<BufferDataSource>&&);
+
+    GCGLenum checkFramebufferStatus(GCGLenum target);
+    virtual void clear(GCGLbitfield mask) = 0;
+    void clearColor(GCGLfloat red, GCGLfloat green, GCGLfloat blue, GCGLfloat alpha);
+    void clearDepth(GCGLfloat);
+    void clearStencil(GCGLint);
+    void colorMask(GCGLboolean red, GCGLboolean green, GCGLboolean blue, GCGLboolean alpha);
     void compileShader(WebGLShader*);
 
-    void compressedTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, ArrayBufferView& data);
-    void compressedTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, ArrayBufferView& data);
+    void compressedTexImage2D(GCGLenum target, GCGLint level, GCGLenum internalformat, GCGLsizei width, GCGLsizei height, GCGLint border, ArrayBufferView& data);
+    void compressedTexSubImage2D(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLsizei width, GCGLsizei height, GCGLenum format, ArrayBufferView& data);
 
-    void copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border);
-    void copyTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
+    void copyTexImage2D(GCGLenum target, GCGLint level, GCGLenum internalformat, GCGLint x, GCGLint y, GCGLsizei width, GCGLsizei height, GCGLint border);
+    void copyTexSubImage2D(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLint x, GCGLint y, GCGLsizei width, GCGLsizei height);
 
     RefPtr<WebGLBuffer> createBuffer();
     RefPtr<WebGLFramebuffer> createFramebuffer();
     RefPtr<WebGLProgram> createProgram();
     RefPtr<WebGLRenderbuffer> createRenderbuffer();
-    RefPtr<WebGLShader> createShader(GC3Denum type);
+    RefPtr<WebGLShader> createShader(GCGLenum type);
     RefPtr<WebGLTexture> createTexture();
 
-    void cullFace(GC3Denum mode);
+    void cullFace(GCGLenum mode);
 
     void deleteBuffer(WebGLBuffer*);
     void deleteFramebuffer(WebGLFramebuffer*);
@@ -162,47 +162,47 @@ public:
     void deleteShader(WebGLShader*);
     void deleteTexture(WebGLTexture*);
 
-    void depthFunc(GC3Denum);
-    void depthMask(GC3Dboolean);
-    void depthRange(GC3Dfloat zNear, GC3Dfloat zFar);
+    void depthFunc(GCGLenum);
+    void depthMask(GCGLboolean);
+    void depthRange(GCGLfloat zNear, GCGLfloat zFar);
     void detachShader(WebGLProgram*, WebGLShader*);
-    void disable(GC3Denum cap);
-    void disableVertexAttribArray(GC3Duint index);
-    void drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count);
-    void drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset);
+    void disable(GCGLenum cap);
+    void disableVertexAttribArray(GCGLuint index);
+    void drawArrays(GCGLenum mode, GCGLint first, GCGLsizei count);
+    void drawElements(GCGLenum mode, GCGLsizei count, GCGLenum type, long long offset);
 
-    void enable(GC3Denum cap);
-    void enableVertexAttribArray(GC3Duint index);
+    void enable(GCGLenum cap);
+    void enableVertexAttribArray(GCGLuint index);
     void finish();
     void flush();
-    void framebufferRenderbuffer(GC3Denum target, GC3Denum attachment, GC3Denum renderbuffertarget, WebGLRenderbuffer*);
-    void framebufferTexture2D(GC3Denum target, GC3Denum attachment, GC3Denum textarget, WebGLTexture*, GC3Dint level);
-    void frontFace(GC3Denum mode);
-    void generateMipmap(GC3Denum target);
+    void framebufferRenderbuffer(GCGLenum target, GCGLenum attachment, GCGLenum renderbuffertarget, WebGLRenderbuffer*);
+    void framebufferTexture2D(GCGLenum target, GCGLenum attachment, GCGLenum textarget, WebGLTexture*, GCGLint level);
+    void frontFace(GCGLenum mode);
+    void generateMipmap(GCGLenum target);
 
-    RefPtr<WebGLActiveInfo> getActiveAttrib(WebGLProgram*, GC3Duint index);
-    RefPtr<WebGLActiveInfo> getActiveUniform(WebGLProgram*, GC3Duint index);
+    RefPtr<WebGLActiveInfo> getActiveAttrib(WebGLProgram*, GCGLuint index);
+    RefPtr<WebGLActiveInfo> getActiveUniform(WebGLProgram*, GCGLuint index);
     Optional<Vector<RefPtr<WebGLShader>>> getAttachedShaders(WebGLProgram*);
-    GC3Dint getAttribLocation(WebGLProgram*, const String& name);
-    WebGLAny getBufferParameter(GC3Denum target, GC3Denum pname);
+    GCGLint getAttribLocation(WebGLProgram*, const String& name);
+    WebGLAny getBufferParameter(GCGLenum target, GCGLenum pname);
     Optional<WebGLContextAttributes> getContextAttributes();
-    GC3Denum getError();
+    GCGLenum getError();
     virtual WebGLExtension* getExtension(const String& name) = 0;
-    virtual WebGLAny getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname) = 0;
-    virtual WebGLAny getParameter(GC3Denum pname) = 0;
-    WebGLAny getProgramParameter(WebGLProgram*, GC3Denum pname);
+    virtual WebGLAny getFramebufferAttachmentParameter(GCGLenum target, GCGLenum attachment, GCGLenum pname) = 0;
+    virtual WebGLAny getParameter(GCGLenum pname) = 0;
+    WebGLAny getProgramParameter(WebGLProgram*, GCGLenum pname);
     String getProgramInfoLog(WebGLProgram*);
-    WebGLAny getRenderbufferParameter(GC3Denum target, GC3Denum pname);
-    WebGLAny getShaderParameter(WebGLShader*, GC3Denum pname);
+    WebGLAny getRenderbufferParameter(GCGLenum target, GCGLenum pname);
+    WebGLAny getShaderParameter(WebGLShader*, GCGLenum pname);
     String getShaderInfoLog(WebGLShader*);
-    RefPtr<WebGLShaderPrecisionFormat> getShaderPrecisionFormat(GC3Denum shaderType, GC3Denum precisionType);
+    RefPtr<WebGLShaderPrecisionFormat> getShaderPrecisionFormat(GCGLenum shaderType, GCGLenum precisionType);
     String getShaderSource(WebGLShader*);
     virtual Optional<Vector<String>> getSupportedExtensions() = 0;
-    WebGLAny getTexParameter(GC3Denum target, GC3Denum pname);
+    WebGLAny getTexParameter(GCGLenum target, GCGLenum pname);
     WebGLAny getUniform(WebGLProgram*, const WebGLUniformLocation*);
     RefPtr<WebGLUniformLocation> getUniformLocation(WebGLProgram*, const String&);
-    WebGLAny getVertexAttrib(GC3Duint index, GC3Denum pname);
-    long long getVertexAttribOffset(GC3Duint index, GC3Denum pname);
+    WebGLAny getVertexAttrib(GCGLuint index, GCGLenum pname);
+    long long getVertexAttribOffset(GCGLuint index, GCGLenum pname);
 
     bool extensionIsEnabled(const String&);
 
@@ -212,35 +212,35 @@ public:
     bool preventBufferClearForInspector() const { return m_preventBufferClearForInspector; }
     void setPreventBufferClearForInspector(bool value) { m_preventBufferClearForInspector = value; }
 
-    virtual void hint(GC3Denum target, GC3Denum mode) = 0;
-    GC3Dboolean isBuffer(WebGLBuffer*);
+    virtual void hint(GCGLenum target, GCGLenum mode) = 0;
+    GCGLboolean isBuffer(WebGLBuffer*);
     bool isContextLost() const;
-    GC3Dboolean isEnabled(GC3Denum cap);
-    GC3Dboolean isFramebuffer(WebGLFramebuffer*);
-    GC3Dboolean isProgram(WebGLProgram*);
-    GC3Dboolean isRenderbuffer(WebGLRenderbuffer*);
-    GC3Dboolean isShader(WebGLShader*);
-    GC3Dboolean isTexture(WebGLTexture*);
-
-    void lineWidth(GC3Dfloat);
+    GCGLboolean isEnabled(GCGLenum cap);
+    GCGLboolean isFramebuffer(WebGLFramebuffer*);
+    GCGLboolean isProgram(WebGLProgram*);
+    GCGLboolean isRenderbuffer(WebGLRenderbuffer*);
+    GCGLboolean isShader(WebGLShader*);
+    GCGLboolean isTexture(WebGLTexture*);
+
+    void lineWidth(GCGLfloat);
     void linkProgram(WebGLProgram*);
     bool linkProgramWithoutInvalidatingAttribLocations(WebGLProgram*);
-    void pixelStorei(GC3Denum pname, GC3Dint param);
-    void polygonOffset(GC3Dfloat factor, GC3Dfloat units);
-    void readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, ArrayBufferView& pixels);
+    void pixelStorei(GCGLenum pname, GCGLint param);
+    void polygonOffset(GCGLfloat factor, GCGLfloat units);
+    void readPixels(GCGLint x, GCGLint y, GCGLsizei width, GCGLsizei height, GCGLenum format, GCGLenum type, ArrayBufferView& pixels);
     void releaseShaderCompiler();
-    virtual void renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height) = 0;
-    void sampleCoverage(GC3Dfloat value, GC3Dboolean invert);
-    void scissor(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
+    virtual void renderbufferStorage(GCGLenum target, GCGLenum internalformat, GCGLsizei width, GCGLsizei height) = 0;
+    void sampleCoverage(GCGLfloat value, GCGLboolean invert);
+    void scissor(GCGLint x, GCGLint y, GCGLsizei width, GCGLsizei height);
     void shaderSource(WebGLShader*, const String&);
-    void stencilFunc(GC3Denum func, GC3Dint ref, GC3Duint mask);
-    void stencilFuncSeparate(GC3Denum face, GC3Denum func, GC3Dint ref, GC3Duint mask);
-    void stencilMask(GC3Duint);
-    void stencilMaskSeparate(GC3Denum face, GC3Duint mask);
-    void stencilOp(GC3Denum fail, GC3Denum zfail, GC3Denum zpass);
-    void stencilOpSeparate(GC3Denum face, GC3Denum fail, GC3Denum zfail, GC3Denum zpass);
+    void stencilFunc(GCGLenum func, GCGLint ref, GCGLuint mask);
+    void stencilFuncSeparate(GCGLenum face, GCGLenum func, GCGLint ref, GCGLuint mask);
+    void stencilMask(GCGLuint);
+    void stencilMaskSeparate(GCGLenum face, GCGLuint mask);
+    void stencilOp(GCGLenum fail, GCGLenum zfail, GCGLenum zpass);
+    void stencilOpSeparate(GCGLenum face, GCGLenum fail, GCGLenum zfail, GCGLenum zpass);
 
-    void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&&);
+    void texImage2D(GCGLenum target, GCGLint level, GCGLenum internalformat, GCGLsizei width, GCGLsizei height, GCGLint border, GCGLenum format, GCGLenum type, RefPtr<ArrayBufferView>&&);
 
 #if ENABLE(VIDEO)
     using TexImageSource = WTF::Variant<RefPtr<ImageBitmap>, RefPtr<ImageData>, RefPtr<HTMLImageElement>, RefPtr<HTMLCanvasElement>, RefPtr<HTMLVideoElement>>;
@@ -248,13 +248,13 @@ public:
     using TexImageSource = WTF::Variant<RefPtr<ImageBitmap>, RefPtr<ImageData>, RefPtr<HTMLImageElement>, RefPtr<HTMLCanvasElement>>;
 #endif
 
-    ExceptionOr<void> texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Optional<TexImageSource>);
+    ExceptionOr<void> texImage2D(GCGLenum target, GCGLint level, GCGLenum internalformat, GCGLenum format, GCGLenum type, Optional<TexImageSource>);
 
-    void texParameterf(GC3Denum target, GC3Denum pname, GC3Dfloat param);
-    void texParameteri(GC3Denum target, GC3Denum pname, GC3Dint param);
+    void texParameterf(GCGLenum target, GCGLenum pname, GCGLfloat param);
+    void texParameteri(GCGLenum target, GCGLenum pname, GCGLint param);
 
-    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, Optional<TexImageSource>&&);
+    void texSubImage2D(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLsizei width, GCGLsizei height, GCGLenum format, GCGLenum type, RefPtr<ArrayBufferView>&&);
+    ExceptionOr<void> texSubImage2D(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLenum format, GCGLenum type, Optional<TexImageSource>&&);
 
     template <class TypedArray, class DataType>
     class TypedList {
@@ -274,11 +274,11 @@ public:
             );
         }
 
-        GC3Dsizei length() const
+        GCGLsizei length() const
         {
             return WTF::switchOn(m_variant,
-                [] (const RefPtr<TypedArray>& typedArray) -> GC3Dsizei { return typedArray->length(); },
-                [] (const Vector<DataType>& vector) -> GC3Dsizei { return vector.size(); }
+                [] (const RefPtr<TypedArray>& typedArray) -> GCGLsizei { return typedArray->length(); },
+                [] (const Vector<DataType>& vector) -> GCGLsizei { return vector.size(); }
             );
         }
 
@@ -289,15 +289,15 @@ public:
     using Float32List = TypedList<Float32Array, float>;
     using Int32List = TypedList<Int32Array, int>;
 
-    void uniform1f(const WebGLUniformLocation*, GC3Dfloat x);
-    void uniform2f(const WebGLUniformLocation*, GC3Dfloat x, GC3Dfloat y);
-    void uniform3f(const WebGLUniformLocation*, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z);
-    void uniform4f(const WebGLUniformLocation*, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w);
+    void uniform1f(const WebGLUniformLocation*, GCGLfloat x);
+    void uniform2f(const WebGLUniformLocation*, GCGLfloat x, GCGLfloat y);
+    void uniform3f(const WebGLUniformLocation*, GCGLfloat x, GCGLfloat y, GCGLfloat z);
+    void uniform4f(const WebGLUniformLocation*, GCGLfloat x, GCGLfloat y, GCGLfloat z, GCGLfloat w);
 
-    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 uniform1i(const WebGLUniformLocation*, GCGLint x);
+    void uniform2i(const WebGLUniformLocation*, GCGLint x, GCGLint y);
+    void uniform3i(const WebGLUniformLocation*, GCGLint x, GCGLint y, GCGLint z);
+    void uniform4i(const WebGLUniformLocation*, GCGLint x, GCGLint y, GCGLint z, GCGLint w);
 
     void uniform1fv(const WebGLUniformLocation*, Float32List&&);
     void uniform2fv(const WebGLUniformLocation*, Float32List&&);
@@ -309,27 +309,27 @@ public:
     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 uniformMatrix2fv(const WebGLUniformLocation*, GCGLboolean transpose, Float32List&&);
+    void uniformMatrix3fv(const WebGLUniformLocation*, GCGLboolean transpose, Float32List&&);
+    void uniformMatrix4fv(const WebGLUniformLocation*, GCGLboolean transpose, Float32List&&);
 
     void useProgram(WebGLProgram*);
     void validateProgram(WebGLProgram*);
 
-    void vertexAttrib1f(GC3Duint index, GC3Dfloat x);
-    void vertexAttrib2f(GC3Duint index, GC3Dfloat x, GC3Dfloat y);
-    void vertexAttrib3f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z);
-    void vertexAttrib4f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w);
+    void vertexAttrib1f(GCGLuint index, GCGLfloat x);
+    void vertexAttrib2f(GCGLuint index, GCGLfloat x, GCGLfloat y);
+    void vertexAttrib3f(GCGLuint index, GCGLfloat x, GCGLfloat y, GCGLfloat z);
+    void vertexAttrib4f(GCGLuint index, GCGLfloat x, GCGLfloat y, GCGLfloat z, GCGLfloat w);
 
-    void vertexAttrib1fv(GC3Duint index, Float32List&&);
-    void vertexAttrib2fv(GC3Duint index, Float32List&&);
-    void vertexAttrib3fv(GC3Duint index, Float32List&&);
-    void vertexAttrib4fv(GC3Duint index, Float32List&&);
+    void vertexAttrib1fv(GCGLuint index, Float32List&&);
+    void vertexAttrib2fv(GCGLuint index, Float32List&&);
+    void vertexAttrib3fv(GCGLuint index, Float32List&&);
+    void vertexAttrib4fv(GCGLuint index, Float32List&&);
 
-    void vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized,
-        GC3Dsizei stride, long long offset);
+    void vertexAttribPointer(GCGLuint index, GCGLint size, GCGLenum type, GCGLboolean normalized,
+        GCGLsizei stride, long long offset);
 
-    void viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
+    void viewport(GCGLint x, GCGLint y, GCGLsizei width, GCGLsizei height);
 
     // WEBKIT_lose_context support
     enum LostContextMode {
@@ -360,9 +360,9 @@ public:
     unsigned getMaxVertexAttribs() const { return m_maxVertexAttribs; }
 
     // Instanced Array helper functions.
-    void drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount);
-    void drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, GC3Dsizei primcount);
-    void vertexAttribDivisor(GC3Duint index, GC3Duint divisor);
+    void drawArraysInstanced(GCGLenum mode, GCGLint first, GCGLsizei count, GCGLsizei primcount);
+    void drawElementsInstanced(GCGLenum mode, GCGLsizei count, GCGLenum type, long long offset, GCGLsizei primcount);
+    void vertexAttribDivisor(GCGLuint index, GCGLuint divisor);
 
     // Used for testing only, from Internals.
     WEBCORE_EXPORT void setFailNextGPUStatusCheck();
@@ -426,26 +426,26 @@ protected:
 
     // Helper to return the size in bytes of OpenGL data types
     // like GL_FLOAT, GL_INT, etc.
-    unsigned int sizeInBytes(GC3Denum type);
+    unsigned sizeInBytes(GCGLenum type);
 
     // Basic validation of count and offset against number of elements in element array buffer
-    bool validateElementArraySize(GC3Dsizei count, GC3Denum type, GC3Dintptr offset);
+    bool validateElementArraySize(GCGLsizei count, GCGLenum type, GCGLintptr offset);
 
     // Conservative but quick index validation
-    virtual bool validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired) = 0;
+    virtual bool validateIndexArrayConservative(GCGLenum type, unsigned& numElementsRequired) = 0;
 
     // Precise but slow index validation -- only done if conservative checks fail
-    bool validateIndexArrayPrecise(GC3Dsizei count, GC3Denum type, GC3Dintptr offset, unsigned& numElementsRequired);
+    bool validateIndexArrayPrecise(GCGLsizei count, GCGLenum type, GCGLintptr offset, unsigned& numElementsRequired);
     bool validateVertexAttributes(unsigned elementCount, unsigned primitiveCount = 0);
 
     bool validateWebGLObject(const char*, WebGLObject*);
 
-    bool validateDrawArrays(const char* functionName, GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount);
-    bool validateDrawElements(const char* functionName, GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, unsigned& numElements, GC3Dsizei primcount);
-    bool validateNPOTTextureLevel(GC3Dsizei width, GC3Dsizei height, GC3Dint level, const char* functionName);
+    bool validateDrawArrays(const char* functionName, GCGLenum mode, GCGLint first, GCGLsizei count, GCGLsizei primcount);
+    bool validateDrawElements(const char* functionName, GCGLenum mode, GCGLsizei count, GCGLenum type, long long offset, unsigned& numElements, GCGLsizei primcount);
+    bool validateNPOTTextureLevel(GCGLsizei width, GCGLsizei height, GCGLint level, const char* functionName);
 
     // Adds a compressed texture format.
-    void addCompressedTextureFormat(GC3Denum);
+    void addCompressedTextureFormat(GCGLenum);
 
     RefPtr<Image> drawImageIntoBuffer(Image&, int width, int height, int deviceScaleFactor);
 
@@ -506,13 +506,13 @@ protected:
             value[3] = 1.0f;
         }
         
-        GC3Dfloat value[4];
+        GCGLfloat value[4];
     };
     Vector<VertexAttribValue> m_vertexAttribValue;
     unsigned m_maxVertexAttribs;
     RefPtr<WebGLBuffer> m_vertexAttrib0Buffer;
     long m_vertexAttrib0BufferSize { 0 };
-    GC3Dfloat m_vertexAttrib0BufferValue[4];
+    GCGLfloat m_vertexAttrib0BufferValue[4];
     bool m_forceAttrib0BufferRefill { true };
     bool m_vertexAttrib0UsedBefore { false };
 
@@ -532,7 +532,7 @@ protected:
     RefPtr<WebGLTexture> m_blackTexture2D;
     RefPtr<WebGLTexture> m_blackTextureCubeMap;
 
-    Vector<GC3Denum> m_compressedTextureFormats;
+    Vector<GCGLenum> m_compressedTextureFormats;
 
     // Fixed-size cache of reusable image buffers for video texImage2D calls.
     class LRUImageBufferCache {
@@ -546,40 +546,40 @@ protected:
     };
     LRUImageBufferCache m_generatedImageCache { 0 };
 
-    GC3Dint m_maxTextureSize;
-    GC3Dint m_maxCubeMapTextureSize;
-    GC3Dint m_maxRenderbufferSize;
-    GC3Dint m_maxViewportDims[2] { 0, 0 };
-    GC3Dint m_maxTextureLevel;
-    GC3Dint m_maxCubeMapTextureLevel;
+    GCGLint m_maxTextureSize;
+    GCGLint m_maxCubeMapTextureSize;
+    GCGLint m_maxRenderbufferSize;
+    GCGLint m_maxViewportDims[2] { 0, 0 };
+    GCGLint m_maxTextureLevel;
+    GCGLint m_maxCubeMapTextureLevel;
 
-    GC3Dint m_maxDrawBuffers;
-    GC3Dint m_maxColorAttachments;
-    GC3Denum m_backDrawBuffer;
+    GCGLint m_maxDrawBuffers;
+    GCGLint m_maxColorAttachments;
+    GCGLenum m_backDrawBuffer;
     bool m_drawBuffersWebGLRequirementsChecked;
     bool m_drawBuffersSupported;
 
-    GC3Dint m_packAlignment;
-    GC3Dint m_unpackAlignment;
+    GCGLint m_packAlignment;
+    GCGLint m_unpackAlignment;
     bool m_unpackFlipY;
     bool m_unpackPremultiplyAlpha;
-    GC3Denum m_unpackColorspaceConversion;
+    GCGLenum m_unpackColorspaceConversion;
     bool m_contextLost { false };
     LostContextMode m_contextLostMode { SyntheticLostContext };
     WebGLContextAttributes m_attributes;
 
     bool m_layerCleared;
-    GC3Dfloat m_clearColor[4];
+    GCGLfloat m_clearColor[4];
     bool m_scissorEnabled;
-    GC3Dfloat m_clearDepth;
-    GC3Dint m_clearStencil;
-    GC3Dboolean m_colorMask[4];
-    GC3Dboolean m_depthMask;
+    GCGLfloat m_clearDepth;
+    GCGLint m_clearStencil;
+    GCGLboolean m_colorMask[4];
+    GCGLboolean m_depthMask;
 
     bool m_stencilEnabled;
-    GC3Duint m_stencilMask, m_stencilMaskBack;
-    GC3Dint m_stencilFuncRef, m_stencilFuncRefBack; // Note that these are the user specified values, not the internal clamped value.
-    GC3Duint m_stencilFuncMask, m_stencilFuncMaskBack;
+    GCGLuint m_stencilMask, m_stencilMaskBack;
+    GCGLint m_stencilFuncRef, m_stencilFuncRefBack; // Note that these are the user specified values, not the internal clamped value.
+    GCGLuint m_stencilFuncMask, m_stencilFuncMaskBack;
 
     bool m_isGLES2Compliant;
     bool m_isGLES2NPOTStrict;
@@ -626,27 +626,27 @@ protected:
     std::unique_ptr<ANGLEInstancedArrays> m_angleInstancedArrays;
 
     // Helpers for getParameter and other similar functions.
-    bool getBooleanParameter(GC3Denum);
-    Vector<bool> getBooleanArrayParameter(GC3Denum);
-    float getFloatParameter(GC3Denum);
-    int getIntParameter(GC3Denum);
-    unsigned getUnsignedIntParameter(GC3Denum);
-    long long getInt64Parameter(GC3Denum);
-    RefPtr<Float32Array> getWebGLFloatArrayParameter(GC3Denum);
-    RefPtr<Int32Array> getWebGLIntArrayParameter(GC3Denum);
+    bool getBooleanParameter(GCGLenum);
+    Vector<bool> getBooleanArrayParameter(GCGLenum);
+    float getFloatParameter(GCGLenum);
+    int getIntParameter(GCGLenum);
+    unsigned getUnsignedIntParameter(GCGLenum);
+    long long getInt64Parameter(GCGLenum);
+    RefPtr<Float32Array> getWebGLFloatArrayParameter(GCGLenum);
+    RefPtr<Int32Array> getWebGLIntArrayParameter(GCGLenum);
 
     // Clear the backbuffer if it was composited since the last operation.
     // clearMask is set to the bitfield of any clear that would happen anyway at this time
     // and the function returns true if that clear is now unnecessary.
-    bool clearIfComposited(GC3Dbitfield clearMask = 0);
+    bool clearIfComposited(GCGLbitfield clearMask = 0);
 
     // Helper to restore state that clearing the framebuffer may destroy.
     void restoreStateAfterClear();
 
-    void texImage2DBase(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels);
-    void texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image*, GraphicsContextGL::DOMSource, bool flipY, bool premultiplyAlpha);
-    void texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum internalformat, GC3Denum format, GC3Denum type, const void* pixels);
-    void texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image*, GraphicsContextGL::DOMSource, bool flipY, bool premultiplyAlpha);
+    void texImage2DBase(GCGLenum target, GCGLint level, GCGLenum internalformat, GCGLsizei width, GCGLsizei height, GCGLint border, GCGLenum format, GCGLenum type, const void* pixels);
+    void texImage2DImpl(GCGLenum target, GCGLint level, GCGLenum internalformat, GCGLenum format, GCGLenum type, Image*, GraphicsContextGL::DOMSource, bool flipY, bool premultiplyAlpha);
+    void texSubImage2DBase(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLsizei width, GCGLsizei height, GCGLenum internalformat, GCGLenum format, GCGLenum type, const void* pixels);
+    void texSubImage2DImpl(GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset, GCGLenum format, GCGLenum type, Image*, GraphicsContextGL::DOMSource, bool flipY, bool premultiplyAlpha);
 
     bool checkTextureCompleteness(const char*, bool);
 
@@ -655,11 +655,10 @@ protected:
     // Helper function for copyTex{Sub}Image, check whether the internalformat
     // and the color buffer format of the current bound framebuffer combination
     // is valid.
-    bool isTexInternalFormatColorBufferCombinationValid(GC3Denum texInternalFormat,
-                                                        GC3Denum colorBufferFormat);
+    bool isTexInternalFormatColorBufferCombinationValid(GCGLenum texInternalFormat, GCGLenum colorBufferFormat);
 
     // Helper function to get the bound framebuffer's color buffer format.
-    GC3Denum getBoundFramebufferColorFormat();
+    GCGLenum getBoundFramebufferColorFormat();
 
     // Helper function to get the bound framebuffer's width.
     int getBoundFramebufferWidth();
@@ -672,7 +671,7 @@ protected:
 
     // Helper function to check if size is non-negative.
     // Generate GL error and return false for negative inputs; otherwise, return true.
-    bool validateSize(const char* functionName, GC3Dint x, GC3Dint y);
+    bool validateSize(const char* functionName, GCGLint x, GCGLint y);
 
     // Helper function to check if all characters in the string belong to the
     // ASCII subset as defined in GLSL ES 1.0 spec section 3.1.
@@ -681,15 +680,15 @@ protected:
     // Helper function to check target and texture bound to the target.
     // Generate GL errors and return 0 if target is invalid or texture bound is
     // null.  Otherwise, return the texture bound to the target.
-    RefPtr<WebGLTexture> validateTextureBinding(const char* functionName, GC3Denum target, bool useSixEnumsForCubeMap);
+    RefPtr<WebGLTexture> validateTextureBinding(const char* functionName, GCGLenum target, bool useSixEnumsForCubeMap);
 
     // Helper function to check input format/type for functions {copy}Tex{Sub}Image.
     // Generates GL error and returns false if parameters are invalid.
-    bool validateTexFuncFormatAndType(const char* functionName, GC3Denum internalformat, GC3Denum format, GC3Denum type, GC3Dint level);
+    bool validateTexFuncFormatAndType(const char* functionName, GCGLenum internalformat, GCGLenum format, GCGLenum type, GCGLint level);
 
     // Helper function to check input level for functions {copy}Tex{Sub}Image.
     // Generates GL error and returns false if level is invalid.
-    bool validateTexFuncLevel(const char* functionName, GC3Denum target, GC3Dint level);
+    bool validateTexFuncLevel(const char* functionName, GCGLenum target, GCGLint level);
 
     enum TexFuncValidationFunctionType {
         TexImage,
@@ -710,17 +709,17 @@ protected:
 
     // Helper function for tex{Sub}Image2D to check if the input format/type/level/target/width/height/border/xoffset/yoffset are valid.
     // Otherwise, it would return quickly without doing other work.
-    bool validateTexFunc(const char* functionName, TexFuncValidationFunctionType, TexFuncValidationSourceType, GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width,
-        GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, GC3Dint xoffset, GC3Dint yoffset);
+    bool validateTexFunc(const char* functionName, TexFuncValidationFunctionType, TexFuncValidationSourceType, GCGLenum target, GCGLint level, GCGLenum internalformat, GCGLsizei width,
+        GCGLsizei height, GCGLint border, GCGLenum format, GCGLenum type, GCGLint xoffset, GCGLint yoffset);
 
     // Helper function to check input parameters for functions {copy}Tex{Sub}Image.
     // Generates GL error and returns false if parameters are invalid.
     bool validateTexFuncParameters(const char* functionName,
         TexFuncValidationFunctionType,
-        GC3Denum target, GC3Dint level,
-        GC3Denum internalformat,
-        GC3Dsizei width, GC3Dsizei height, GC3Dint border,
-        GC3Denum format, GC3Denum type);
+        GCGLenum target, GCGLint level,
+        GCGLenum internalformat,
+        GCGLsizei width, GCGLsizei height, GCGLint border,
+        GCGLenum format, GCGLenum type);
 
     enum NullDisposition {
         NullAllowed,
@@ -730,9 +729,9 @@ protected:
     // Helper function to validate that the given ArrayBufferView
     // is of the correct type and contains enough data for the texImage call.
     // Generates GL error and returns false if parameters are invalid.
-    bool validateTexFuncData(const char* functionName, GC3Dint level,
-        GC3Dsizei width, GC3Dsizei height,
-        GC3Denum internalformat, GC3Denum format, GC3Denum type,
+    bool validateTexFuncData(const char* functionName, GCGLint level,
+        GCGLsizei width, GCGLsizei height,
+        GCGLenum internalformat, GCGLenum format, GCGLenum type,
         ArrayBufferView* pixels,
         NullDisposition);
 
@@ -740,62 +739,62 @@ protected:
     // you can supply data to texImage2D, or call texImage2D, copyTexImage2D and
     // copyTexSubImage2D.
     // Generates GL error and returns false if the format is not settable.
-    bool validateSettableTexInternalFormat(const char* functionName, GC3Denum format);
+    bool validateSettableTexInternalFormat(const char* functionName, GCGLenum format);
 
     // Helper function to validate compressed texture data is correct size
     // for the given format and dimensions.
-    bool validateCompressedTexFuncData(const char* functionName, GC3Dsizei width, GC3Dsizei height, GC3Denum format, ArrayBufferView& pixels);
+    bool validateCompressedTexFuncData(const char* functionName, GCGLsizei width, GCGLsizei height, GCGLenum format, ArrayBufferView& pixels);
 
     // Helper function for validating compressed texture formats.
-    bool validateCompressedTexFormat(GC3Denum format);
+    bool validateCompressedTexFormat(GCGLenum format);
 
     // Helper function to validate compressed texture dimensions are valid for
     // the given format.
-    bool validateCompressedTexDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dsizei width, GC3Dsizei height, GC3Denum format);
+    bool validateCompressedTexDimensions(const char* functionName, GCGLenum target, GCGLint level, GCGLsizei width, GCGLsizei height, GCGLenum format);
 
     // Helper function to validate compressed texture dimensions are valid for
     // the given format.
-    bool validateCompressedTexSubDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-                                            GC3Dsizei width, GC3Dsizei height, GC3Denum format, WebGLTexture*);
+    bool validateCompressedTexSubDimensions(const char* functionName, GCGLenum target, GCGLint level, GCGLint xoffset, GCGLint yoffset,
+        GCGLsizei width, GCGLsizei height, GCGLenum format, WebGLTexture*);
 
     // Helper function to validate mode for draw{Arrays/Elements}.
-    bool validateDrawMode(const char* functionName, GC3Denum);
+    bool validateDrawMode(const char* functionName, GCGLenum);
 
     // Helper function to validate if front/back stencilMask and stencilFunc settings are the same.
     bool validateStencilSettings(const char* functionName);
 
     // Helper function to validate stencil func.
-    bool validateStencilFunc(const char* functionName, GC3Denum);
+    bool validateStencilFunc(const char* functionName, GCGLenum);
 
     // Helper function for texParameterf and texParameteri.
-    void texParameter(GC3Denum target, GC3Denum pname, GC3Dfloat parami, GC3Dint paramf, bool isFloat);
+    void texParameter(GCGLenum target, GCGLenum pname, GCGLfloat parami, GCGLint paramf, bool isFloat);
 
     // Helper function to print errors and warnings to console.
     void printToConsole(MessageLevel, const String&);
 
     // Helper function to validate input parameters for framebuffer functions.
     // Generate GL error if parameters are illegal.
-    virtual bool validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment) = 0;
+    virtual bool validateFramebufferFuncParameters(const char* functionName, GCGLenum target, GCGLenum attachment) = 0;
 
     // Helper function to validate blend equation mode.
-    virtual bool validateBlendEquation(const char* functionName, GC3Denum) = 0;
+    virtual bool validateBlendEquation(const char* functionName, GCGLenum) = 0;
 
     // Helper function to validate blend func factors.
-    bool validateBlendFuncFactors(const char* functionName, GC3Denum src, GC3Denum dst);
+    bool validateBlendFuncFactors(const char* functionName, GCGLenum src, GCGLenum dst);
 
     // Helper function to validate a GL capability.
-    virtual bool validateCapability(const char* functionName, GC3Denum) = 0;
+    virtual bool validateCapability(const char* functionName, GCGLenum) = 0;
 
     // Helper function to validate input parameters for uniform functions.
-    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, const Float32List&, GC3Dsizei mod);
-    bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GC3Dboolean transpose, const void*, GC3Dsizei, GC3Dsizei mod);
+    bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, const Float32List&, GCGLsizei mod);
+    bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, const Int32List&, GCGLsizei mod);
+    bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, void*, GCGLsizei, GCGLsizei mod);
+    bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GCGLboolean transpose, const Float32List&, GCGLsizei mod);
+    bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GCGLboolean transpose, const void*, GCGLsizei, GCGLsizei mod);
 
     // Helper function to validate parameters for bufferData.
     // Return the current bound buffer to target, or 0 if parameters are invalid.
-    WebGLBuffer* validateBufferDataParameters(const char* functionName, GC3Denum target, GC3Denum usage);
+    WebGLBuffer* validateBufferDataParameters(const char* functionName, GCGLenum target, GCGLenum usage);
 
     // Helper function for tex{Sub}Image2D to make sure image is ready.
     ExceptionOr<bool> validateHTMLImageElement(const char* functionName, HTMLImageElement*);
@@ -805,8 +804,8 @@ protected:
 #endif
 
     // 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, Float32List&&, GC3Dsizei expectedSize);
+    void vertexAttribfImpl(const char* functionName, GCGLuint index, GCGLsizei expectedSize, GCGLfloat, GCGLfloat, GCGLfloat, GCGLfloat);
+    void vertexAttribfvImpl(const char* functionName, GCGLuint index, Float32List&&, GCGLsizei expectedSize);
 
     // Helper function for delete* (deleteBuffer, deleteProgram, etc) functions.
     // Return false if caller should return without further processing.
@@ -819,13 +818,13 @@ protected:
 
     // Helpers for simulating vertexAttrib0.
     void initVertexAttrib0();
-    Optional<bool> simulateVertexAttrib0(GC3Duint numVertex);
-    bool validateSimulatedVertexAttrib0(GC3Duint numVertex);
+    Optional<bool> simulateVertexAttrib0(GCGLuint numVertex);
+    bool validateSimulatedVertexAttrib0(GCGLuint numVertex);
     void restoreStatesAfterVertexAttrib0Simulation();
 
     // Wrapper for GraphicsContextGLOpenGL::synthesizeGLError that sends a message to the JavaScript console.
     enum ConsoleDisplayPreference { DisplayInConsole, DontDisplayInConsole };
-    void synthesizeGLError(GC3Denum, const char* functionName, const char* description, ConsoleDisplayPreference = DisplayInConsole);
+    void synthesizeGLError(GCGLenum, const char* functionName, const char* description, ConsoleDisplayPreference = DisplayInConsole);
 
     String ensureNotNull(const String&) const;
 
@@ -833,15 +832,15 @@ protected:
     void applyStencilTest();
 
     // Helper for enabling or disabling a capability.
-    void enableOrDisable(GC3Denum capability, bool enable);
+    void enableOrDisable(GCGLenum capability, bool enable);
 
     // Clamp the width and height to GL_MAX_VIEWPORT_DIMS.
     IntSize clampedCanvasSize();
 
-    virtual GC3Dint getMaxDrawBuffers() = 0;
-    virtual GC3Dint getMaxColorAttachments() = 0;
+    virtual GCGLint getMaxDrawBuffers() = 0;
+    virtual GCGLint getMaxColorAttachments() = 0;
 
-    void setBackDrawBuffer(GC3Denum);
+    void setBackDrawBuffer(GCGLenum);
 
     void restoreCurrentFramebuffer();
     void restoreCurrentTexture2D();
@@ -854,7 +853,7 @@ protected:
 #endif
 
     template <typename T> inline Optional<T> checkedAddAndMultiply(T value, T add, T multiply);
-    template <typename T> unsigned getMaxIndex(const RefPtr<JSC::ArrayBuffer> elementArrayBuffer, GC3Dintptr uoffset, GC3Dsizei n);
+    template <typename T> unsigned getMaxIndex(const RefPtr<JSC::ArrayBuffer> elementArrayBuffer, GCGLintptr uoffset, GCGLsizei n);
 
 private:
     void dispatchContextLostEvent();
@@ -862,7 +861,7 @@ private:
     // Helper for restoration after context lost.
     void maybeRestoreContext();
 
-    bool validateArrayBufferType(const char* functionName, GC3Denum type, Optional<JSC::TypedArrayType>);
+    bool validateArrayBufferType(const char* functionName, GCGLenum type, Optional<JSC::TypedArrayType>);
     void registerWithWebGLStateTracker();
     void checkForContextLossHandling();
 
@@ -886,7 +885,7 @@ inline Optional<T> WebGLRenderingContextBase::checkedAddAndMultiply(T value, T a
 }
 
 template<typename T>
-inline unsigned WebGLRenderingContextBase::getMaxIndex(const RefPtr<JSC::ArrayBuffer> elementArrayBuffer, GC3Dintptr uoffset, GC3Dsizei n)
+inline unsigned WebGLRenderingContextBase::getMaxIndex(const RefPtr<JSC::ArrayBuffer> elementArrayBuffer, GCGLintptr uoffset, GCGLsizei n)
 {
     unsigned maxIndex = 0;
     T restartIndex = 0;
index f24fc4d..ee450a0 100644 (file)
@@ -49,7 +49,7 @@ WebGLSampler::WebGLSampler(WebGLRenderingContextBase& ctx)
     // FIXME: Call createSampler from GraphicsContextGLOpenGL.
 }
 
-void WebGLSampler::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, Platform3DObject object)
+void WebGLSampler::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
 {
     UNUSED_PARAM(context3d);
     UNUSED_PARAM(object);
index 912bb8c..1f0f77d 100644 (file)
@@ -38,7 +38,7 @@ public:
 
 protected:
     explicit WebGLSampler(WebGLRenderingContextBase&);
-    void deleteObjectImpl(GraphicsContextGLOpenGL*, Platform3DObject) final;
+    void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) final;
 };
 
 } // namespace WebCore
index f79577c..6478203 100644 (file)
 
 namespace WebCore {
 
-Ref<WebGLShader> WebGLShader::create(WebGLRenderingContextBase& ctx, GC3Denum type)
+Ref<WebGLShader> WebGLShader::create(WebGLRenderingContextBase& ctx, GCGLenum type)
 {
     return adoptRef(*new WebGLShader(ctx, type));
 }
 
-WebGLShader::WebGLShader(WebGLRenderingContextBase& ctx, GC3Denum type)
+WebGLShader::WebGLShader(WebGLRenderingContextBase& ctx, GCGLenum type)
     : WebGLSharedObject(ctx)
     , m_type(type)
     , m_source(emptyString())
@@ -53,7 +53,7 @@ WebGLShader::~WebGLShader()
     deleteObject(0);
 }
 
-void WebGLShader::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, Platform3DObject object)
+void WebGLShader::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
 {
     context3d->deleteShader(object);
 }
index 8edf0e2..d3d3a55 100644 (file)
@@ -34,10 +34,10 @@ namespace WebCore {
 
 class WebGLShader final : public WebGLSharedObject {
 public:
-    static Ref<WebGLShader> create(WebGLRenderingContextBase&, GC3Denum);
+    static Ref<WebGLShader> create(WebGLRenderingContextBase&, GCGLenum);
     virtual ~WebGLShader();
 
-    GC3Denum getType() const { return m_type; }
+    GCGLenum getType() const { return m_type; }
     const String& getSource() const { return m_source; }
 
     void setSource(const String& source) { m_source = source; }
@@ -46,11 +46,11 @@ public:
     void setValid(bool valid) { m_isValid = valid; }
 
 private:
-    WebGLShader(WebGLRenderingContextBase&, GC3Denum);
+    WebGLShader(WebGLRenderingContextBase&, GCGLenum);
 
-    void deleteObjectImpl(GraphicsContextGLOpenGL*, Platform3DObject) final;
+    void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) final;
 
-    GC3Denum m_type;
+    GCGLenum m_type;
     String m_source;
     bool m_isValid;
 };
index ed63a51..fd5fb5d 100644 (file)
 namespace WebCore {
 
 // static
-Ref<WebGLShaderPrecisionFormat> WebGLShaderPrecisionFormat::create(GC3Dint rangeMin, GC3Dint rangeMax, GC3Dint precision)
+Ref<WebGLShaderPrecisionFormat> WebGLShaderPrecisionFormat::create(GCGLint rangeMin, GCGLint rangeMax, GCGLint precision)
 {
     return adoptRef(*new WebGLShaderPrecisionFormat(rangeMin, rangeMax, precision));
 }
 
-GC3Dint WebGLShaderPrecisionFormat::rangeMin() const
+GCGLint WebGLShaderPrecisionFormat::rangeMin() const
 {
     return m_rangeMin;
 }
 
-GC3Dint WebGLShaderPrecisionFormat::rangeMax() const
+GCGLint WebGLShaderPrecisionFormat::rangeMax() const
 {
     return m_rangeMax;
 }
 
-GC3Dint WebGLShaderPrecisionFormat::precision() const
+GCGLint WebGLShaderPrecisionFormat::precision() const
 {
     return m_precision;
 }
 
-WebGLShaderPrecisionFormat::WebGLShaderPrecisionFormat(GC3Dint rangeMin, GC3Dint rangeMax, GC3Dint precision)
+WebGLShaderPrecisionFormat::WebGLShaderPrecisionFormat(GCGLint rangeMin, GCGLint rangeMax, GCGLint precision)
     : m_rangeMin(rangeMin)
     , m_rangeMax(rangeMax)
     , m_precision(precision)
index 8c4e621..7ab4220 100644 (file)
@@ -35,18 +35,18 @@ namespace WebCore {
 
 class WebGLShaderPrecisionFormat : public RefCounted<WebGLShaderPrecisionFormat> {
 public:
-    static Ref<WebGLShaderPrecisionFormat> create(GC3Dint rangeMin, GC3Dint rangeMax, GC3Dint precision);
+    static Ref<WebGLShaderPrecisionFormat> create(GCGLint rangeMin, GCGLint rangeMax, GCGLint precision);
 
-    GC3Dint rangeMin() const;
-    GC3Dint rangeMax() const;
-    GC3Dint precision() const;
+    GCGLint rangeMin() const;
+    GCGLint rangeMax() const;
+    GCGLint precision() const;
 
 private:
-    WebGLShaderPrecisionFormat(GC3Dint rangeMin, GC3Dint rangeMax, GC3Dint precision);
+    WebGLShaderPrecisionFormat(GCGLint rangeMin, GCGLint rangeMax, GCGLint precision);
 
-    GC3Dint m_rangeMin;
-    GC3Dint m_rangeMax;
-    GC3Dint m_precision;
+    GCGLint m_rangeMin;
+    GCGLint m_rangeMax;
+    GCGLint m_precision;
 };
 
 } // namespace WebCore
index b65e28b..f70e372 100644 (file)
@@ -49,7 +49,7 @@ WebGLSync::WebGLSync(WebGLRenderingContextBase& ctx)
     // FIXME: Call fenceSync from GraphicsContextGLOpenGL.
 }
 
-void WebGLSync::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, Platform3DObject object)
+void WebGLSync::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
 {
     UNUSED_PARAM(context3d);
     UNUSED_PARAM(object);
index 0d12a80..f917c7a 100644 (file)
@@ -40,7 +40,7 @@ public:
 protected:
     WebGLSync(WebGLRenderingContextBase&);
 
-    void deleteObjectImpl(GraphicsContextGLOpenGL*, Platform3DObject) override;
+    void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) override;
 };
 
 } // namespace WebCore
index 7ea21d9..a7d8690 100644 (file)
@@ -63,7 +63,7 @@ WebGLTexture::~WebGLTexture()
     deleteObject(0);
 }
 
-void WebGLTexture::setTarget(GC3Denum target, GC3Dint maxLevel)
+void WebGLTexture::setTarget(GCGLenum target, GCGLint maxLevel)
 {
     if (!object())
         return;
@@ -85,7 +85,7 @@ void WebGLTexture::setTarget(GC3Denum target, GC3Dint maxLevel)
     }
 }
 
-void WebGLTexture::setParameteri(GC3Denum pname, GC3Dint param)
+void WebGLTexture::setParameteri(GCGLenum pname, GCGLint param)
 {
     if (!object() || !m_target)
         return;
@@ -134,15 +134,15 @@ void WebGLTexture::setParameteri(GC3Denum pname, GC3Dint param)
     update();
 }
 
-void WebGLTexture::setParameterf(GC3Denum pname, GC3Dfloat param)
+void WebGLTexture::setParameterf(GCGLenum pname, GCGLfloat param)
 {
     if (!object() || !m_target)
         return;
-    GC3Dint iparam = static_cast<GC3Dint>(param);
+    GCGLint iparam = static_cast<GCGLint>(param);
     setParameteri(pname, iparam);
 }
 
-void WebGLTexture::setLevelInfo(GC3Denum target, GC3Dint level, GC3Denum internalFormat, GC3Dsizei width, GC3Dsizei height, GC3Denum type)
+void WebGLTexture::setLevelInfo(GCGLenum target, GCGLint level, GCGLenum internalFormat, GCGLsizei width, GCGLsizei height, GCGLenum type)
 {
     if (!object() || !m_target)
         return;
@@ -164,10 +164,10 @@ void WebGLTexture::generateMipmapLevelInfo()
     if (!m_isComplete) {
         for (size_t ii = 0; ii < m_info.size(); ++ii) {
             const LevelInfo& info0 = m_info[ii][0];
-            GC3Dsizei width = info0.width;
-            GC3Dsizei height = info0.height;
-            GC3Dint levelCount = computeLevelCount(width, height);
-            for (GC3Dint level = 1; level < levelCount; ++level) {
+            GCGLsizei width = info0.width;
+            GCGLsizei height = info0.height;
+            GCGLint levelCount = computeLevelCount(width, height);
+            for (GCGLint level = 1; level < levelCount; ++level) {
                 width = std::max(1, width >> 1);
                 height = std::max(1, height >> 1);
                 LevelInfo& info = m_info[ii][level];
@@ -179,7 +179,7 @@ void WebGLTexture::generateMipmapLevelInfo()
     m_needToUseBlackTexture = false;
 }
 
-GC3Denum WebGLTexture::getInternalFormat(GC3Denum target, GC3Dint level) const
+GCGLenum WebGLTexture::getInternalFormat(GCGLenum target, GCGLint level) const
 {
     const LevelInfo* info = getLevelInfo(target, level);
     if (!info)
@@ -187,7 +187,7 @@ GC3Denum WebGLTexture::getInternalFormat(GC3Denum target, GC3Dint level) const
     return info->internalFormat;
 }
 
-GC3Denum WebGLTexture::getType(GC3Denum target, GC3Dint level) const
+GCGLenum WebGLTexture::getType(GCGLenum target, GCGLint level) const
 {
     ASSERT(m_isForWebGL1);
     const LevelInfo* info = getLevelInfo(target, level);
@@ -196,7 +196,7 @@ GC3Denum WebGLTexture::getType(GC3Denum target, GC3Dint level) const
     return info->type;
 }
 
-GC3Dsizei WebGLTexture::getWidth(GC3Denum target, GC3Dint level) const
+GCGLsizei WebGLTexture::getWidth(GCGLenum target, GCGLint level) const
 {
     const LevelInfo* info = getLevelInfo(target, level);
     if (!info)
@@ -204,7 +204,7 @@ GC3Dsizei WebGLTexture::getWidth(GC3Denum target, GC3Dint level) const
     return info->width;
 }
 
-GC3Dsizei WebGLTexture::getHeight(GC3Denum target, GC3Dint level) const
+GCGLsizei WebGLTexture::getHeight(GCGLenum target, GCGLint level) const
 {
     const LevelInfo* info = getLevelInfo(target, level);
     if (!info)
@@ -212,7 +212,7 @@ GC3Dsizei WebGLTexture::getHeight(GC3Denum target, GC3Dint level) const
     return info->height;
 }
 
-bool WebGLTexture::isValid(GC3Denum target, GC3Dint level) const
+bool WebGLTexture::isValid(GCGLenum target, GCGLint level) const
 {
     const LevelInfo* info = getLevelInfo(target, level);
     if (!info)
@@ -220,7 +220,7 @@ bool WebGLTexture::isValid(GC3Denum target, GC3Dint level) const
     return info->valid;
 }
 
-void WebGLTexture::markInvalid(GC3Denum target, GC3Dint level)
+void WebGLTexture::markInvalid(GCGLenum target, GCGLint level)
 {
     int index = mapTargetToIndex(target);
     if (index < 0)
@@ -229,7 +229,7 @@ void WebGLTexture::markInvalid(GC3Denum target, GC3Dint level)
     update();
 }
 
-bool WebGLTexture::isNPOT(GC3Dsizei width, GC3Dsizei height)
+bool WebGLTexture::isNPOT(GCGLsizei width, GCGLsizei height)
 {
     ASSERT(width >= 0 && height >= 0);
     if (!width || !height)
@@ -274,12 +274,12 @@ void WebGLTexture::setCompressed()
     m_isCompressed = true;
 }
 
-void WebGLTexture::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, Platform3DObject object)
+void WebGLTexture::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
 {
     context3d->deleteTexture(object);
 }
 
-int WebGLTexture::mapTargetToIndex(GC3Denum target) const
+int WebGLTexture::mapTargetToIndex(GCGLenum target) const
 {
     if (m_target == GraphicsContextGL::TEXTURE_2D) {
         if (target == GraphicsContextGL::TEXTURE_2D)
@@ -318,17 +318,17 @@ bool WebGLTexture::canGenerateMipmaps()
     return true;
 }
 
-GC3Dint WebGLTexture::computeLevelCount(GC3Dsizei width, GC3Dsizei height)
+GCGLint WebGLTexture::computeLevelCount(GCGLsizei width, GCGLsizei height)
 {
     // return 1 + log2Floor(std::max(width, height));
-    GC3Dsizei n = std::max(width, height);
+    GCGLsizei n = std::max(width, height);
     if (n <= 0)
         return 0;
-    GC3Dint log = 0;
-    GC3Dsizei value = n;
+    GCGLint log = 0;
+    GC