script: Move WebGL DOM interfaces to script/dom/webgl/ (#38995)

Move interfaces defined by the WebGL spec to the `script/dom/webgl/
`module from `script/dom/`.

`script/dom/webgl*.rs` -> `script/dom/webgl/`
`script/dom/webgl_extensions` -> `script/dom/webgl/extensions`
`script/dom/webgl_validations` -> `script/dom/webgl/validations`

Testing: No changes, just a refactoring

Fixes (partially): #38901

Signed-off-by: Andrei Volykhin <volykhin.andrei@huawei.com>
Co-authored-by: Andrei Volykhin <volykhin.andrei@huawei.com>

components/script/dom/webgl/extensions/ext/angleinstancedarrays.rs

@@ -0,0 +1,96 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use canvas_traits::webgl::WebGLVersion;
+use dom_struct::dom_struct;
+
+use super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions};
+use crate::dom::bindings::codegen::Bindings::ANGLEInstancedArraysBinding::{
+    ANGLEInstancedArraysConstants, ANGLEInstancedArraysMethods,
+};
+use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
+use crate::dom::bindings::root::{Dom, DomRoot};
+use crate::dom::webgl::webglrenderingcontext::WebGLRenderingContext;
+use crate::script_runtime::CanGc;
+
+#[dom_struct]
+pub(crate) struct ANGLEInstancedArrays {
+    reflector_: Reflector,
+    ctx: Dom<WebGLRenderingContext>,
+}
+
+impl ANGLEInstancedArrays {
+    fn new_inherited(ctx: &WebGLRenderingContext) -> Self {
+        Self {
+            reflector_: Reflector::new(),
+            ctx: Dom::from_ref(ctx),
+        }
+    }
+}
+
+impl WebGLExtension for ANGLEInstancedArrays {
+    type Extension = Self;
+
+    fn new(ctx: &WebGLRenderingContext, can_gc: CanGc) -> DomRoot<Self> {
+        reflect_dom_object(
+            Box::new(ANGLEInstancedArrays::new_inherited(ctx)),
+            &*ctx.global(),
+            can_gc,
+        )
+    }
+
+    fn spec() -> WebGLExtensionSpec {
+        WebGLExtensionSpec::Specific(WebGLVersion::WebGL1)
+    }
+
+    fn is_supported(ext: &WebGLExtensions) -> bool {
+        ext.supports_any_gl_extension(&[
+            "GL_ANGLE_instanced_arrays",
+            "GL_ARB_instanced_arrays",
+            "GL_EXT_instanced_arrays",
+            "GL_NV_instanced_arrays",
+        ])
+    }
+
+    fn enable(ext: &WebGLExtensions) {
+        ext.enable_get_vertex_attrib_name(
+            ANGLEInstancedArraysConstants::VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE,
+        );
+    }
+
+    fn name() -> &'static str {
+        "ANGLE_instanced_arrays"
+    }
+}
+
+impl ANGLEInstancedArraysMethods<crate::DomTypeHolder> for ANGLEInstancedArrays {
+    // https://www.khronos.org/registry/webgl/extensions/ANGLE_instanced_arrays/
+    fn DrawArraysInstancedANGLE(&self, mode: u32, first: i32, count: i32, primcount: i32) {
+        handle_potential_webgl_error!(
+            self.ctx,
+            self.ctx
+                .draw_arrays_instanced(mode, first, count, primcount)
+        )
+    }
+
+    // https://www.khronos.org/registry/webgl/extensions/ANGLE_instanced_arrays/
+    fn DrawElementsInstancedANGLE(
+        &self,
+        mode: u32,
+        count: i32,
+        type_: u32,
+        offset: i64,
+        primcount: i32,
+    ) {
+        handle_potential_webgl_error!(
+            self.ctx,
+            self.ctx
+                .draw_elements_instanced(mode, count, type_, offset, primcount)
+        )
+    }
+
+    fn VertexAttribDivisorANGLE(&self, index: u32, divisor: u32) {
+        self.ctx.vertex_attrib_divisor(index, divisor);
+    }
+}

components/script/dom/webgl/extensions/ext/extblendminmax.rs

@@ -0,0 +1,49 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use canvas_traits::webgl::WebGLVersion;
+use dom_struct::dom_struct;
+
+use super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions};
+use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
+use crate::dom::bindings::root::DomRoot;
+use crate::dom::webgl::webglrenderingcontext::WebGLRenderingContext;
+use crate::script_runtime::CanGc;
+
+#[dom_struct]
+pub(crate) struct EXTBlendMinmax {
+    reflector_: Reflector,
+}
+
+impl EXTBlendMinmax {
+    fn new_inherited() -> Self {
+        Self {
+            reflector_: Reflector::new(),
+        }
+    }
+}
+
+impl WebGLExtension for EXTBlendMinmax {
+    type Extension = Self;
+
+    fn new(ctx: &WebGLRenderingContext, can_gc: CanGc) -> DomRoot<Self> {
+        reflect_dom_object(Box::new(Self::new_inherited()), &*ctx.global(), can_gc)
+    }
+
+    fn spec() -> WebGLExtensionSpec {
+        WebGLExtensionSpec::Specific(WebGLVersion::WebGL1)
+    }
+
+    fn is_supported(ext: &WebGLExtensions) -> bool {
+        ext.supports_gl_extension("GL_EXT_blend_minmax")
+    }
+
+    fn enable(ext: &WebGLExtensions) {
+        ext.enable_blend_minmax();
+    }
+
+    fn name() -> &'static str {
+        "EXT_blend_minmax"
+    }
+}

components/script/dom/webgl/extensions/ext/extcolorbufferhalffloat.rs

@@ -0,0 +1,51 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use canvas_traits::webgl::WebGLVersion;
+use dom_struct::dom_struct;
+
+use super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions};
+use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
+use crate::dom::bindings::root::DomRoot;
+use crate::dom::webgl::extensions::oestexturehalffloat::OESTextureHalfFloat;
+use crate::dom::webgl::webglrenderingcontext::WebGLRenderingContext;
+use crate::script_runtime::CanGc;
+
+#[dom_struct]
+pub(crate) struct EXTColorBufferHalfFloat {
+    reflector_: Reflector,
+}
+
+impl EXTColorBufferHalfFloat {
+    fn new_inherited() -> EXTColorBufferHalfFloat {
+        Self {
+            reflector_: Reflector::new(),
+        }
+    }
+}
+
+impl WebGLExtension for EXTColorBufferHalfFloat {
+    type Extension = EXTColorBufferHalfFloat;
+    fn new(ctx: &WebGLRenderingContext, can_gc: CanGc) -> DomRoot<EXTColorBufferHalfFloat> {
+        reflect_dom_object(
+            Box::new(EXTColorBufferHalfFloat::new_inherited()),
+            &*ctx.global(),
+            can_gc,
+        )
+    }
+
+    fn spec() -> WebGLExtensionSpec {
+        WebGLExtensionSpec::Specific(WebGLVersion::WebGL1)
+    }
+
+    fn is_supported(ext: &WebGLExtensions) -> bool {
+        OESTextureHalfFloat::is_supported(ext)
+    }
+
+    fn enable(_ext: &WebGLExtensions) {}
+
+    fn name() -> &'static str {
+        "EXT_color_buffer_half_float"
+    }
+}

components/script/dom/webgl/extensions/ext/extfragdepth.rs

@@ -0,0 +1,64 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use canvas_traits::webgl::{WebGLSLVersion, WebGLVersion};
+use dom_struct::dom_struct;
+
+use super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions};
+use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
+use crate::dom::bindings::root::DomRoot;
+use crate::dom::webgl::webglrenderingcontext::WebGLRenderingContext;
+use crate::script_runtime::CanGc;
+
+#[dom_struct]
+pub(crate) struct EXTFragDepth {
+    reflector_: Reflector,
+}
+
+impl EXTFragDepth {
+    fn new_inherited() -> EXTFragDepth {
+        Self {
+            reflector_: Reflector::new(),
+        }
+    }
+}
+
+impl WebGLExtension for EXTFragDepth {
+    type Extension = Self;
+
+    fn new(ctx: &WebGLRenderingContext, can_gc: CanGc) -> DomRoot<Self> {
+        reflect_dom_object(Box::new(Self::new_inherited()), &*ctx.global(), can_gc)
+    }
+
+    fn spec() -> WebGLExtensionSpec {
+        WebGLExtensionSpec::Specific(WebGLVersion::WebGL1)
+    }
+
+    fn is_supported(ext: &WebGLExtensions) -> bool {
+        let min_glsl_version = if ext.is_gles() {
+            WebGLSLVersion { major: 3, minor: 0 }
+        } else {
+            WebGLSLVersion {
+                major: 1,
+                minor: 10,
+            }
+        };
+        match (
+            ext.is_gles(),
+            ext.is_min_glsl_version_satisfied(min_glsl_version),
+        ) {
+            // ANGLE's shader translator can't translate ESSL1 exts to ESSL3. (bug
+            // 1524804)
+            (true, true) => false,
+            (true, false) => ext.supports_gl_extension("GL_EXT_frag_depth"),
+            (false, is_min_glsl_version_satisfied) => is_min_glsl_version_satisfied,
+        }
+    }
+
+    fn enable(_ext: &WebGLExtensions) {}
+
+    fn name() -> &'static str {
+        "EXT_frag_depth"
+    }
+}

components/script/dom/webgl/extensions/ext/extshadertexturelod.rs

@@ -0,0 +1,48 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use canvas_traits::webgl::WebGLVersion;
+use dom_struct::dom_struct;
+
+use super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions};
+use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
+use crate::dom::bindings::root::DomRoot;
+use crate::dom::webgl::webglrenderingcontext::WebGLRenderingContext;
+use crate::script_runtime::CanGc;
+
+#[dom_struct]
+pub(crate) struct EXTShaderTextureLod {
+    reflector_: Reflector,
+}
+
+impl EXTShaderTextureLod {
+    fn new_inherited() -> Self {
+        Self {
+            reflector_: Reflector::new(),
+        }
+    }
+}
+
+impl WebGLExtension for EXTShaderTextureLod {
+    type Extension = Self;
+
+    fn new(ctx: &WebGLRenderingContext, can_gc: CanGc) -> DomRoot<Self> {
+        reflect_dom_object(Box::new(Self::new_inherited()), &*ctx.global(), can_gc)
+    }
+
+    fn spec() -> WebGLExtensionSpec {
+        WebGLExtensionSpec::Specific(WebGLVersion::WebGL1)
+    }
+
+    fn is_supported(ext: &WebGLExtensions) -> bool {
+        // This extension is always available on desktop GL.
+        !ext.is_gles() || ext.supports_gl_extension("GL_EXT_shader_texture_lod")
+    }
+
+    fn enable(_ext: &WebGLExtensions) {}
+
+    fn name() -> &'static str {
+        "EXT_shader_texture_lod"
+    }
+}

components/script/dom/webgl/extensions/ext/exttexturefilteranisotropic.rs

@@ -0,0 +1,55 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use canvas_traits::webgl::WebGLVersion;
+use dom_struct::dom_struct;
+
+use super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions};
+use crate::dom::bindings::codegen::Bindings::EXTTextureFilterAnisotropicBinding::EXTTextureFilterAnisotropicConstants;
+use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
+use crate::dom::bindings::root::DomRoot;
+use crate::dom::webgl::webglrenderingcontext::WebGLRenderingContext;
+use crate::script_runtime::CanGc;
+
+#[dom_struct]
+pub(crate) struct EXTTextureFilterAnisotropic {
+    reflector_: Reflector,
+}
+
+impl EXTTextureFilterAnisotropic {
+    fn new_inherited() -> EXTTextureFilterAnisotropic {
+        Self {
+            reflector_: Reflector::new(),
+        }
+    }
+}
+
+impl WebGLExtension for EXTTextureFilterAnisotropic {
+    type Extension = EXTTextureFilterAnisotropic;
+
+    fn new(ctx: &WebGLRenderingContext, can_gc: CanGc) -> DomRoot<Self> {
+        reflect_dom_object(Box::new(Self::new_inherited()), &*ctx.global(), can_gc)
+    }
+
+    fn spec() -> WebGLExtensionSpec {
+        WebGLExtensionSpec::Specific(WebGLVersion::WebGL1)
+    }
+
+    fn is_supported(ext: &WebGLExtensions) -> bool {
+        ext.supports_gl_extension("GL_EXT_texture_filter_anisotropic")
+    }
+
+    fn enable(ext: &WebGLExtensions) {
+        ext.enable_get_tex_parameter_name(
+            EXTTextureFilterAnisotropicConstants::TEXTURE_MAX_ANISOTROPY_EXT,
+        );
+        ext.enable_get_parameter_name(
+            EXTTextureFilterAnisotropicConstants::MAX_TEXTURE_MAX_ANISOTROPY_EXT,
+        );
+    }
+
+    fn name() -> &'static str {
+        "EXT_texture_filter_anisotropic"
+    }
+}

components/script/dom/webgl/extensions/ext/mod.rs

@@ -0,0 +1,23 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions};
+use crate::dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
+
+pub(crate) mod angleinstancedarrays;
+pub(crate) mod extblendminmax;
+pub(crate) mod extcolorbufferhalffloat;
+pub(crate) mod extfragdepth;
+pub(crate) mod extshadertexturelod;
+pub(crate) mod exttexturefilteranisotropic;
+pub(crate) mod oeselementindexuint;
+pub(crate) mod oesstandardderivatives;
+pub(crate) mod oestexturefloat;
+pub(crate) mod oestexturefloatlinear;
+pub(crate) mod oestexturehalffloat;
+pub(crate) mod oestexturehalffloatlinear;
+pub(crate) mod oesvertexarrayobject;
+pub(crate) mod webglcolorbufferfloat;
+pub(crate) mod webglcompressedtextureetc1;
+pub(crate) mod webglcompressedtextures3tc;

components/script/dom/webgl/extensions/ext/oeselementindexuint.rs

@@ -0,0 +1,54 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use canvas_traits::webgl::WebGLVersion;
+use dom_struct::dom_struct;
+
+use super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions};
+use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
+use crate::dom::bindings::root::DomRoot;
+use crate::dom::webgl::webglrenderingcontext::WebGLRenderingContext;
+use crate::script_runtime::CanGc;
+
+#[dom_struct]
+pub(crate) struct OESElementIndexUint {
+    reflector_: Reflector,
+}
+
+impl OESElementIndexUint {
+    fn new_inherited() -> Self {
+        Self {
+            reflector_: Reflector::new(),
+        }
+    }
+}
+
+impl WebGLExtension for OESElementIndexUint {
+    type Extension = Self;
+
+    fn new(ctx: &WebGLRenderingContext, can_gc: CanGc) -> DomRoot<Self> {
+        reflect_dom_object(
+            Box::new(OESElementIndexUint::new_inherited()),
+            &*ctx.global(),
+            can_gc,
+        )
+    }
+
+    fn spec() -> WebGLExtensionSpec {
+        WebGLExtensionSpec::Specific(WebGLVersion::WebGL1)
+    }
+
+    fn is_supported(ext: &WebGLExtensions) -> bool {
+        // This extension is always available in desktop OpenGL.
+        !ext.is_gles() || ext.supports_gl_extension("GL_OES_element_index_uint")
+    }
+
+    fn enable(ext: &WebGLExtensions) {
+        ext.enable_element_index_uint();
+    }
+
+    fn name() -> &'static str {
+        "OES_element_index_uint"
+    }
+}

components/script/dom/webgl/extensions/ext/oesstandardderivatives.rs

@@ -0,0 +1,59 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use canvas_traits::webgl::WebGLVersion;
+use dom_struct::dom_struct;
+
+use super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions};
+use crate::dom::bindings::codegen::Bindings::OESStandardDerivativesBinding::OESStandardDerivativesConstants;
+use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
+use crate::dom::bindings::root::DomRoot;
+use crate::dom::webgl::webglrenderingcontext::WebGLRenderingContext;
+use crate::script_runtime::CanGc;
+
+#[dom_struct]
+pub(crate) struct OESStandardDerivatives {
+    reflector_: Reflector,
+}
+
+impl OESStandardDerivatives {
+    fn new_inherited() -> OESStandardDerivatives {
+        Self {
+            reflector_: Reflector::new(),
+        }
+    }
+}
+
+impl WebGLExtension for OESStandardDerivatives {
+    type Extension = OESStandardDerivatives;
+    fn new(ctx: &WebGLRenderingContext, can_gc: CanGc) -> DomRoot<OESStandardDerivatives> {
+        reflect_dom_object(
+            Box::new(OESStandardDerivatives::new_inherited()),
+            &*ctx.global(),
+            can_gc,
+        )
+    }
+
+    fn spec() -> WebGLExtensionSpec {
+        WebGLExtensionSpec::Specific(WebGLVersion::WebGL1)
+    }
+
+    fn is_supported(ext: &WebGLExtensions) -> bool {
+        // The standard derivatives are always available in desktop OpenGL.
+        !ext.is_gles() || ext.supports_any_gl_extension(&["GL_OES_standard_derivatives"])
+    }
+
+    fn enable(ext: &WebGLExtensions) {
+        ext.enable_hint_target(
+            OESStandardDerivativesConstants::FRAGMENT_SHADER_DERIVATIVE_HINT_OES,
+        );
+        ext.enable_get_parameter_name(
+            OESStandardDerivativesConstants::FRAGMENT_SHADER_DERIVATIVE_HINT_OES,
+        );
+    }
+
+    fn name() -> &'static str {
+        "OES_standard_derivatives"
+    }
+}

components/script/dom/webgl/extensions/ext/oestexturefloat.rs

@@ -0,0 +1,69 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use canvas_traits::webgl::{TexFormat, WebGLVersion};
+use dom_struct::dom_struct;
+
+use super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions, constants as webgl};
+use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
+use crate::dom::bindings::root::DomRoot;
+use crate::dom::webgl::webglrenderingcontext::WebGLRenderingContext;
+use crate::script_runtime::CanGc;
+
+#[dom_struct]
+pub(crate) struct OESTextureFloat {
+    reflector_: Reflector,
+}
+
+impl OESTextureFloat {
+    fn new_inherited() -> OESTextureFloat {
+        Self {
+            reflector_: Reflector::new(),
+        }
+    }
+}
+
+impl WebGLExtension for OESTextureFloat {
+    type Extension = OESTextureFloat;
+    fn new(ctx: &WebGLRenderingContext, can_gc: CanGc) -> DomRoot<OESTextureFloat> {
+        reflect_dom_object(
+            Box::new(OESTextureFloat::new_inherited()),
+            &*ctx.global(),
+            can_gc,
+        )
+    }
+
+    fn spec() -> WebGLExtensionSpec {
+        WebGLExtensionSpec::Specific(WebGLVersion::WebGL1)
+    }
+
+    fn is_supported(ext: &WebGLExtensions) -> bool {
+        ext.supports_any_gl_extension(&[
+            "GL_OES_texture_float",
+            "GL_ARB_texture_float",
+            "GL_EXT_color_buffer_float",
+        ])
+    }
+
+    fn enable(ext: &WebGLExtensions) {
+        ext.enable_tex_type(webgl::FLOAT);
+        ext.add_effective_tex_internal_format(TexFormat::RGBA, webgl::FLOAT, TexFormat::RGBA32f);
+        ext.add_effective_tex_internal_format(TexFormat::RGB, webgl::FLOAT, TexFormat::RGB32f);
+        ext.add_effective_tex_internal_format(
+            TexFormat::Luminance,
+            webgl::FLOAT,
+            TexFormat::Luminance32f,
+        );
+        ext.add_effective_tex_internal_format(TexFormat::Alpha, webgl::FLOAT, TexFormat::Alpha32f);
+        ext.add_effective_tex_internal_format(
+            TexFormat::LuminanceAlpha,
+            webgl::FLOAT,
+            TexFormat::LuminanceAlpha32f,
+        );
+    }
+
+    fn name() -> &'static str {
+        "OES_texture_float"
+    }
+}

components/script/dom/webgl/extensions/ext/oestexturefloatlinear.rs

@@ -0,0 +1,51 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use dom_struct::dom_struct;
+
+use super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions, constants as webgl};
+use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
+use crate::dom::bindings::root::DomRoot;
+use crate::dom::webgl::webglrenderingcontext::WebGLRenderingContext;
+use crate::script_runtime::CanGc;
+
+#[dom_struct]
+pub(crate) struct OESTextureFloatLinear {
+    reflector_: Reflector,
+}
+
+impl OESTextureFloatLinear {
+    fn new_inherited() -> OESTextureFloatLinear {
+        Self {
+            reflector_: Reflector::new(),
+        }
+    }
+}
+
+impl WebGLExtension for OESTextureFloatLinear {
+    type Extension = OESTextureFloatLinear;
+    fn new(ctx: &WebGLRenderingContext, can_gc: CanGc) -> DomRoot<OESTextureFloatLinear> {
+        reflect_dom_object(
+            Box::new(OESTextureFloatLinear::new_inherited()),
+            &*ctx.global(),
+            can_gc,
+        )
+    }
+
+    fn spec() -> WebGLExtensionSpec {
+        WebGLExtensionSpec::All
+    }
+
+    fn is_supported(ext: &WebGLExtensions) -> bool {
+        ext.supports_any_gl_extension(&["GL_OES_texture_float_linear", "GL_ARB_texture_float"])
+    }
+
+    fn enable(ext: &WebGLExtensions) {
+        ext.enable_filterable_tex_type(webgl::FLOAT);
+    }
+
+    fn name() -> &'static str {
+        "OES_texture_float_linear"
+    }
+}

components/script/dom/webgl/extensions/ext/oestexturehalffloat.rs

@@ -0,0 +1,68 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use canvas_traits::webgl::{TexFormat, WebGLVersion};
+use dom_struct::dom_struct;
+
+use super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions};
+use crate::dom::bindings::codegen::Bindings::OESTextureHalfFloatBinding::OESTextureHalfFloatConstants;
+use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
+use crate::dom::bindings::root::DomRoot;
+use crate::dom::webgl::webglrenderingcontext::WebGLRenderingContext;
+use crate::script_runtime::CanGc;
+
+#[dom_struct]
+pub(crate) struct OESTextureHalfFloat {
+    reflector_: Reflector,
+}
+
+impl OESTextureHalfFloat {
+    fn new_inherited() -> OESTextureHalfFloat {
+        Self {
+            reflector_: Reflector::new(),
+        }
+    }
+}
+
+impl WebGLExtension for OESTextureHalfFloat {
+    type Extension = OESTextureHalfFloat;
+    fn new(ctx: &WebGLRenderingContext, can_gc: CanGc) -> DomRoot<OESTextureHalfFloat> {
+        reflect_dom_object(
+            Box::new(OESTextureHalfFloat::new_inherited()),
+            &*ctx.global(),
+            can_gc,
+        )
+    }
+
+    fn spec() -> WebGLExtensionSpec {
+        WebGLExtensionSpec::Specific(WebGLVersion::WebGL1)
+    }
+
+    fn is_supported(ext: &WebGLExtensions) -> bool {
+        ext.supports_any_gl_extension(&[
+            "GL_OES_texture_half_float",
+            "GL_ARB_half_float_pixel",
+            "GL_NV_half_float",
+            "GL_EXT_color_buffer_half_float",
+        ])
+    }
+
+    fn enable(ext: &WebGLExtensions) {
+        let hf = OESTextureHalfFloatConstants::HALF_FLOAT_OES;
+        ext.enable_tex_type(hf);
+        ext.add_effective_tex_internal_format(TexFormat::RGBA, hf, TexFormat::RGBA16f);
+        ext.add_effective_tex_internal_format(TexFormat::RGB, hf, TexFormat::RGB16f);
+        ext.add_effective_tex_internal_format(TexFormat::Luminance, hf, TexFormat::Luminance16f);
+        ext.add_effective_tex_internal_format(TexFormat::Alpha, hf, TexFormat::Alpha16f);
+        ext.add_effective_tex_internal_format(
+            TexFormat::LuminanceAlpha,
+            hf,
+            TexFormat::LuminanceAlpha16f,
+        );
+    }
+
+    fn name() -> &'static str {
+        "OES_texture_half_float"
+    }
+}

components/script/dom/webgl/extensions/ext/oestexturehalffloatlinear.rs

@@ -0,0 +1,56 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use dom_struct::dom_struct;
+
+use super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions};
+use crate::dom::bindings::codegen::Bindings::OESTextureHalfFloatBinding::OESTextureHalfFloatConstants;
+use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
+use crate::dom::bindings::root::DomRoot;
+use crate::dom::webgl::webglrenderingcontext::WebGLRenderingContext;
+use crate::script_runtime::CanGc;
+
+#[dom_struct]
+pub(crate) struct OESTextureHalfFloatLinear {
+    reflector_: Reflector,
+}
+
+impl OESTextureHalfFloatLinear {
+    fn new_inherited() -> OESTextureHalfFloatLinear {
+        Self {
+            reflector_: Reflector::new(),
+        }
+    }
+}
+
+impl WebGLExtension for OESTextureHalfFloatLinear {
+    type Extension = OESTextureHalfFloatLinear;
+    fn new(ctx: &WebGLRenderingContext, can_gc: CanGc) -> DomRoot<OESTextureHalfFloatLinear> {
+        reflect_dom_object(
+            Box::new(OESTextureHalfFloatLinear::new_inherited()),
+            &*ctx.global(),
+            can_gc,
+        )
+    }
+
+    fn spec() -> WebGLExtensionSpec {
+        WebGLExtensionSpec::All
+    }
+
+    fn is_supported(ext: &WebGLExtensions) -> bool {
+        ext.supports_any_gl_extension(&[
+            "GL_OES_texture_float_linear",
+            "GL_ARB_half_float_pixel",
+            "GL_NV_half_float",
+        ])
+    }
+
+    fn enable(ext: &WebGLExtensions) {
+        ext.enable_filterable_tex_type(OESTextureHalfFloatConstants::HALF_FLOAT_OES);
+    }
+
+    fn name() -> &'static str {
+        "OES_texture_half_float_linear"
+    }
+}

components/script/dom/webgl/extensions/ext/oesvertexarrayobject.rs

@@ -0,0 +1,84 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use canvas_traits::webgl::WebGLVersion;
+use dom_struct::dom_struct;
+
+use super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions};
+use crate::dom::bindings::codegen::Bindings::OESVertexArrayObjectBinding::{
+    OESVertexArrayObjectConstants, OESVertexArrayObjectMethods,
+};
+use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
+use crate::dom::bindings::root::{Dom, DomRoot};
+use crate::dom::webgl::webglrenderingcontext::WebGLRenderingContext;
+use crate::dom::webgl::webglvertexarrayobjectoes::WebGLVertexArrayObjectOES;
+use crate::script_runtime::CanGc;
+
+#[dom_struct]
+pub(crate) struct OESVertexArrayObject {
+    reflector_: Reflector,
+    ctx: Dom<WebGLRenderingContext>,
+}
+
+impl OESVertexArrayObject {
+    fn new_inherited(ctx: &WebGLRenderingContext) -> OESVertexArrayObject {
+        Self {
+            reflector_: Reflector::new(),
+            ctx: Dom::from_ref(ctx),
+        }
+    }
+}
+
+impl OESVertexArrayObjectMethods<crate::DomTypeHolder> for OESVertexArrayObject {
+    // https://www.khronos.org/registry/webgl/extensions/OES_vertex_array_object/
+    fn CreateVertexArrayOES(&self) -> Option<DomRoot<WebGLVertexArrayObjectOES>> {
+        self.ctx.create_vertex_array()
+    }
+
+    // https://www.khronos.org/registry/webgl/extensions/OES_vertex_array_object/
+    fn DeleteVertexArrayOES(&self, vao: Option<&WebGLVertexArrayObjectOES>) {
+        self.ctx.delete_vertex_array(vao);
+    }
+
+    // https://www.khronos.org/registry/webgl/extensions/OES_vertex_array_object/
+    fn IsVertexArrayOES(&self, vao: Option<&WebGLVertexArrayObjectOES>) -> bool {
+        self.ctx.is_vertex_array(vao)
+    }
+
+    // https://www.khronos.org/registry/webgl/extensions/OES_vertex_array_object/
+    fn BindVertexArrayOES(&self, vao: Option<&WebGLVertexArrayObjectOES>) {
+        self.ctx.bind_vertex_array(vao);
+    }
+}
+
+impl WebGLExtension for OESVertexArrayObject {
+    type Extension = OESVertexArrayObject;
+    fn new(ctx: &WebGLRenderingContext, can_gc: CanGc) -> DomRoot<OESVertexArrayObject> {
+        reflect_dom_object(
+            Box::new(OESVertexArrayObject::new_inherited(ctx)),
+            &*ctx.global(),
+            can_gc,
+        )
+    }
+
+    fn spec() -> WebGLExtensionSpec {
+        WebGLExtensionSpec::Specific(WebGLVersion::WebGL1)
+    }
+
+    fn is_supported(ext: &WebGLExtensions) -> bool {
+        ext.supports_any_gl_extension(&[
+            "GL_OES_vertex_array_object",
+            "GL_ARB_vertex_array_object",
+            "GL_APPLE_vertex_array_object",
+        ])
+    }
+
+    fn enable(ext: &WebGLExtensions) {
+        ext.enable_get_parameter_name(OESVertexArrayObjectConstants::VERTEX_ARRAY_BINDING_OES);
+    }
+
+    fn name() -> &'static str {
+        "OES_vertex_array_object"
+    }
+}

components/script/dom/webgl/extensions/ext/webglcolorbufferfloat.rs

@@ -0,0 +1,51 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use canvas_traits::webgl::WebGLVersion;
+use dom_struct::dom_struct;
+
+use super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions};
+use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
+use crate::dom::bindings::root::DomRoot;
+use crate::dom::webgl::extensions::oestexturefloat::OESTextureFloat;
+use crate::dom::webgl::webglrenderingcontext::WebGLRenderingContext;
+use crate::script_runtime::CanGc;
+
+#[dom_struct]
+pub(crate) struct WEBGLColorBufferFloat {
+    reflector_: Reflector,
+}
+
+impl WEBGLColorBufferFloat {
+    fn new_inherited() -> WEBGLColorBufferFloat {
+        Self {
+            reflector_: Reflector::new(),
+        }
+    }
+}
+
+impl WebGLExtension for WEBGLColorBufferFloat {
+    type Extension = WEBGLColorBufferFloat;
+    fn new(ctx: &WebGLRenderingContext, can_gc: CanGc) -> DomRoot<WEBGLColorBufferFloat> {
+        reflect_dom_object(
+            Box::new(WEBGLColorBufferFloat::new_inherited()),
+            &*ctx.global(),
+            can_gc,
+        )
+    }
+
+    fn spec() -> WebGLExtensionSpec {
+        WebGLExtensionSpec::Specific(WebGLVersion::WebGL1)
+    }
+
+    fn is_supported(ext: &WebGLExtensions) -> bool {
+        OESTextureFloat::is_supported(ext)
+    }
+
+    fn enable(_ext: &WebGLExtensions) {}
+
+    fn name() -> &'static str {
+        "WEBGL_color_buffer_float"
+    }
+}

components/script/dom/webgl/extensions/ext/webglcompressedtextureetc1.rs

@@ -0,0 +1,59 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use canvas_traits::webgl::{TexFormat, WebGLVersion};
+use dom_struct::dom_struct;
+
+use super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions};
+use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
+use crate::dom::bindings::root::DomRoot;
+use crate::dom::webgl::webglrenderingcontext::WebGLRenderingContext;
+use crate::dom::webgl::webgltexture::{TexCompression, TexCompressionValidation};
+use crate::script_runtime::CanGc;
+
+#[dom_struct]
+pub(crate) struct WEBGLCompressedTextureETC1 {
+    reflector_: Reflector,
+}
+
+impl WEBGLCompressedTextureETC1 {
+    fn new_inherited() -> WEBGLCompressedTextureETC1 {
+        Self {
+            reflector_: Reflector::new(),
+        }
+    }
+}
+
+impl WebGLExtension for WEBGLCompressedTextureETC1 {
+    type Extension = WEBGLCompressedTextureETC1;
+    fn new(ctx: &WebGLRenderingContext, can_gc: CanGc) -> DomRoot<WEBGLCompressedTextureETC1> {
+        reflect_dom_object(
+            Box::new(WEBGLCompressedTextureETC1::new_inherited()),
+            &*ctx.global(),
+            can_gc,
+        )
+    }
+
+    fn spec() -> WebGLExtensionSpec {
+        WebGLExtensionSpec::Specific(WebGLVersion::WebGL1)
+    }
+
+    fn is_supported(ext: &WebGLExtensions) -> bool {
+        ext.supports_gl_extension("GL_OES_compressed_ETC1_RGB8_texture")
+    }
+
+    fn enable(ext: &WebGLExtensions) {
+        ext.add_tex_compression_formats(&[TexCompression {
+            format: TexFormat::CompressedRgbEtc1,
+            bytes_per_block: 8,
+            block_width: 4,
+            block_height: 4,
+            validation: TexCompressionValidation::None,
+        }]);
+    }
+
+    fn name() -> &'static str {
+        "WEBGL_compressed_texture_etc1"
+    }
+}

components/script/dom/webgl/extensions/ext/webglcompressedtextures3tc.rs

@@ -0,0 +1,87 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use canvas_traits::webgl::{TexFormat, WebGLVersion};
+use dom_struct::dom_struct;
+
+use super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions};
+use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
+use crate::dom::bindings::root::DomRoot;
+use crate::dom::webgl::webglrenderingcontext::WebGLRenderingContext;
+use crate::dom::webgl::webgltexture::{TexCompression, TexCompressionValidation};
+use crate::script_runtime::CanGc;
+
+#[dom_struct]
+pub(crate) struct WEBGLCompressedTextureS3TC {
+    reflector_: Reflector,
+}
+
+impl WEBGLCompressedTextureS3TC {
+    fn new_inherited() -> WEBGLCompressedTextureS3TC {
+        Self {
+            reflector_: Reflector::new(),
+        }
+    }
+}
+
+impl WebGLExtension for WEBGLCompressedTextureS3TC {
+    type Extension = WEBGLCompressedTextureS3TC;
+    fn new(ctx: &WebGLRenderingContext, can_gc: CanGc) -> DomRoot<WEBGLCompressedTextureS3TC> {
+        reflect_dom_object(
+            Box::new(WEBGLCompressedTextureS3TC::new_inherited()),
+            &*ctx.global(),
+            can_gc,
+        )
+    }
+
+    fn spec() -> WebGLExtensionSpec {
+        WebGLExtensionSpec::Specific(WebGLVersion::WebGL1)
+    }
+
+    fn is_supported(ext: &WebGLExtensions) -> bool {
+        ext.supports_gl_extension("GL_EXT_texture_compression_s3tc") ||
+            ext.supports_all_gl_extension(&[
+                "GL_EXT_texture_compression_dxt1",
+                "GL_ANGLE_texture_compression_dxt3",
+                "GL_ANGLE_texture_compression_dxt5",
+            ])
+    }
+
+    fn enable(ext: &WebGLExtensions) {
+        ext.add_tex_compression_formats(&[
+            TexCompression {
+                format: TexFormat::CompressedRgbS3tcDxt1,
+                bytes_per_block: 8,
+                block_width: 4,
+                block_height: 4,
+                validation: TexCompressionValidation::S3TC,
+            },
+            TexCompression {
+                format: TexFormat::CompressedRgbaS3tcDxt1,
+                bytes_per_block: 8,
+                block_width: 4,
+                block_height: 4,
+                validation: TexCompressionValidation::S3TC,
+            },
+            TexCompression {
+                format: TexFormat::CompressedRgbaS3tcDxt3,
+                bytes_per_block: 16,
+                block_width: 4,
+                block_height: 4,
+                validation: TexCompressionValidation::S3TC,
+            },
+            TexCompression {
+                format: TexFormat::CompressedRgbaS3tcDxt5,
+                bytes_per_block: 16,
+                block_width: 4,
+                block_height: 4,
+                validation: TexCompressionValidation::S3TC,
+            },
+        ]);
+    }
+
+    fn name() -> &'static str {
+        "WEBGL_compressed_texture_s3tc"
+    }
+}