WebGL2: support TexImage3D (#37718)

Add TexImage3D method to WebGL2RenderingContext

Testing: conformance2 should pass. Also it should get
http://webglsamples.org/WebGL2Samples/#texture_2d_array and
http://webglsamples.org/WebGL2Samples/#texture_3d running.
Fixes: #26511

Now Servo can run texture_2d_array and texture_3d samples!

![圖片](https://github.com/user-attachments/assets/41b87563-08b8-4db3-b503-12f3a61dbed7)

![圖片](https://github.com/user-attachments/assets/3c62a4de-35ea-488d-b2e5-00e3aed52090)

And it can now run three.js too!

![圖片](https://github.com/user-attachments/assets/d880aa92-a154-4895-aa06-b7919d1fc869)

---------

Signed-off-by: Wu Yu Wei <yuweiwu@pm.me>

components/script/dom/webgl2renderingcontext.rs

@@ -11,8 +11,8 @@ use std::rc::Rc;
 use bitflags::bitflags;
 use canvas_traits::webgl::WebGLError::*;
 use canvas_traits::webgl::{
-    GLContextAttributes, InternalFormatParameter, WebGLCommand, WebGLContextId, WebGLResult,
-    WebGLVersion, webgl_channel,
+    AlphaTreatment, GLContextAttributes, InternalFormatParameter, TexDataType, TexFormat,
+    WebGLCommand, WebGLContextId, WebGLResult, WebGLVersion, YAxisTreatment, webgl_channel,
 };
 use dom_struct::dom_struct;
 use euclid::default::{Point2D, Rect, Size2D};
@@ -27,6 +27,7 @@ use servo_config::pref;
 use url::Host;
 use webrender_api::ImageKey;
 
+use super::webgl_validations::types::TexImageTarget;
 use crate::canvas_context::CanvasContext;
 use crate::dom::bindings::codegen::Bindings::WebGL2RenderingContextBinding::{
     WebGL2RenderingContextConstants as constants, WebGL2RenderingContextMethods,
@@ -51,6 +52,7 @@ use crate::dom::webgl_validations::WebGLValidator;
 use crate::dom::webgl_validations::tex_image_2d::{
     TexImage2DValidator, TexImage2DValidatorResult, TexStorageValidator, TexStorageValidatorResult,
 };
+use crate::dom::webgl_validations::tex_image_3d::{TexImage3DValidator, TexImage3DValidatorResult};
 use crate::dom::webglactiveinfo::WebGLActiveInfo;
 use crate::dom::webglbuffer::WebGLBuffer;
 use crate::dom::webglframebuffer::{WebGLFramebuffer, WebGLFramebufferAttachmentRoot};
@@ -899,6 +901,66 @@ impl WebGL2RenderingContext {
             texture.storage(target, levels, internal_format, width, height, depth)
         );
     }
+
+    #[allow(clippy::too_many_arguments)]
+    fn tex_image_3d(
+        &self,
+        texture: &WebGLTexture,
+        target: TexImageTarget,
+        data_type: TexDataType,
+        internal_format: TexFormat,
+        format: TexFormat,
+        level: u32,
+        width: u32,
+        height: u32,
+        depth: u32,
+        _border: u32,
+        unpacking_alignment: u32,
+        data: TexPixels,
+    ) {
+        handle_potential_webgl_error!(
+            self.base,
+            texture.initialize(
+                target,
+                width,
+                height,
+                depth,
+                internal_format,
+                level,
+                Some(data_type)
+            )
+        );
+
+        let internal_format = self
+            .base
+            .extension_manager()
+            .get_effective_tex_internal_format(internal_format, data_type.as_gl_constant());
+        let effective_data_type = self
+            .base
+            .extension_manager()
+            .effective_type(data_type.as_gl_constant());
+
+        self.base.send_command(WebGLCommand::TexImage3D {
+            target: target.as_gl_constant(),
+            level,
+            internal_format,
+            size: data.size(),
+            depth,
+            format,
+            data_type,
+            effective_data_type,
+            unpacking_alignment,
+            alpha_treatment: data.alpha_treatment(),
+            y_axis_treatment: data.y_axis_treatment(),
+            pixel_format: data.pixel_format(),
+            data: data.into_shared_memory().into(),
+        });
+        // TODO: Hint/tex_parameter
+
+        if let Some(fb) = self.base.bound_draw_framebuffer() {
+            fb.invalidate_texture(texture);
+        }
+    }
 }
 
 impl CanvasContext for WebGL2RenderingContext {
@@ -2344,6 +2406,8 @@ impl WebGL2RenderingContextMethods<crate::DomTypeHolder> for WebGL2RenderingCont
                 constants::BOOL |
                 constants::UNSIGNED_INT |
                 constants::SAMPLER_2D |
+                constants::SAMPLER_2D_ARRAY |
+                constants::SAMPLER_3D |
                 constants::SAMPLER_CUBE => {},
                 _ => return Err(InvalidOperation),
             }
@@ -2992,6 +3056,136 @@ impl WebGL2RenderingContextMethods<crate::DomTypeHolder> for WebGL2RenderingCont
         self.base.Viewport(x, y, width, height)
     }
 
+    /// <https://www.khronos.org/registry/webgl/specs/latest/2.0/#3.7.6>
+    ///
+    /// Allocates and initializes the specified mipmap level of a three-dimensional or
+    /// two-dimensional array texture.
+    #[allow(unsafe_code)]
+    fn TexImage3D(
+        &self,
+        target: u32,
+        level: i32,
+        internal_format: i32,
+        width: i32,
+        height: i32,
+        depth: i32,
+        border: i32,
+        format: u32,
+        type_: u32,
+        src_data: CustomAutoRooterGuard<Option<ArrayBufferView>>,
+    ) -> Fallible<()> {
+        // If a WebGLBuffer is bound to the PIXEL_UNPACK_BUFFER target,
+        // generates an INVALID_OPERATION error.
+        if self.bound_pixel_unpack_buffer.get().is_some() {
+            self.base.webgl_error(InvalidOperation);
+            return Ok(());
+        }
+
+        // If type is specified as FLOAT_32_UNSIGNED_INT_24_8_REV, srcData must be null;
+        // otherwise, generates an INVALID_OPERATION error.
+        if type_ == constants::FLOAT_32_UNSIGNED_INT_24_8_REV && src_data.is_some() {
+            self.base.webgl_error(InvalidOperation);
+            return Ok(());
+        }
+
+        if border != 0 {
+            self.base.webgl_error(InvalidValue);
+            return Ok(());
+        }
+
+        let Ok(TexImage3DValidatorResult {
+            width,
+            height,
+            depth,
+            level,
+            border,
+            texture,
+            target,
+            internal_format,
+            format,
+            data_type,
+        }) = TexImage3DValidator::new(
+            &self.base,
+            target,
+            level,
+            internal_format as u32,
+            width,
+            height,
+            depth,
+            border,
+            format,
+            type_,
+            &src_data,
+        )
+        .validate()
+        else {
+            return Ok(());
+        };
+
+        // TODO: If pixel store parameter constraints are not met, generates an INVALID_OPERATION error.
+
+        // If srcData is null, a buffer of sufficient size initialized to 0 is passed.
+        let unpacking_alignment = self.base.texture_unpacking_alignment();
+        let buff = match *src_data {
+            Some(ref data) => IpcSharedMemory::from_bytes(unsafe { data.as_slice() }),
+            None => {
+                let element_size = data_type.element_size();
+                let components = format.components();
+                let components_per_element = format.components();
+                // FIXME: This is copied from tex_image_2d which is apparently incorrect
+                // NOTE: width and height are positive or zero due to validate()
+                let expected_byte_len = if height == 0 {
+                    0
+                } else {
+                    // We need to be careful here to not count unpack
+                    // alignment at the end of the image, otherwise (for
+                    // example) passing a single byte for uploading a 1x1
+                    // GL_ALPHA/GL_UNSIGNED_BYTE texture would throw an error.
+                    let cpp = element_size * components / components_per_element;
+                    let stride =
+                        (width * cpp + unpacking_alignment - 1) & !(unpacking_alignment - 1);
+                    stride * (height - 1) + width * cpp
+                };
+                IpcSharedMemory::from_bytes(&vec![0u8; expected_byte_len as usize])
+            },
+        };
+        let (alpha_treatment, y_axis_treatment) =
+            self.base.get_current_unpack_state(Alpha::NotPremultiplied);
+        // If UNPACK_FLIP_Y_WEBGL or UNPACK_PREMULTIPLY_ALPHA_WEBGL is set to true, texImage3D and texSubImage3D
+        // generate an INVALID_OPERATION error if they upload data from a PIXEL_UNPACK_BUFFER or a non-null client
+        // side ArrayBufferView.
+        if let (Some(AlphaTreatment::Premultiply), YAxisTreatment::Flipped) =
+            (alpha_treatment, y_axis_treatment)
+        {
+            if src_data.is_some() {
+                self.base.webgl_error(InvalidOperation);
+                return Ok(());
+            }
+        }
+        let tex_source = TexPixels::from_array(
+            buff,
+            Size2D::new(width, height),
+            alpha_treatment,
+            y_axis_treatment,
+        );
+
+        self.tex_image_3d(
+            &texture,
+            target,
+            data_type,
+            internal_format,
+            format,
+            level,
+            width,
+            height,
+            depth,
+            border,
+            unpacking_alignment,
+            tex_source,
+        );
+        Ok(())
+    }
+
     /// <https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.8>
     fn TexImage2D(
         &self,

components/script/dom/webgl_validations/mod.rs

@@ -10,4 +10,5 @@ pub(crate) trait WebGLValidator {
 }
 
 pub(crate) mod tex_image_2d;
+pub(crate) mod tex_image_3d;
 pub(crate) mod types;

components/script/dom/webgl_validations/tex_image_3d.rs

@@ -0,0 +1,311 @@
+/* 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::WebGLError::*;
+use canvas_traits::webgl::{TexDataType, TexFormat};
+use js::jsapi::Type;
+use js::typedarray::ArrayBufferView;
+
+use super::WebGLValidator;
+use super::tex_image_2d::TexImageValidationError;
+use super::types::TexImageTarget;
+use crate::dom::bindings::root::DomRoot;
+use crate::dom::webglrenderingcontext::WebGLRenderingContext;
+use crate::dom::webgltexture::WebGLTexture;
+
+fn log2(n: u32) -> u32 {
+    31 - n.leading_zeros()
+}
+
+pub(crate) struct CommonTexImage3DValidator<'a> {
+    context: &'a WebGLRenderingContext,
+    target: u32,
+    level: i32,
+    internal_format: u32,
+    width: i32,
+    height: i32,
+    depth: i32,
+    border: i32,
+}
+
+pub(crate) struct CommonTexImage3DValidatorResult {
+    pub(crate) texture: DomRoot<WebGLTexture>,
+    pub(crate) target: TexImageTarget,
+    pub(crate) level: u32,
+    pub(crate) internal_format: TexFormat,
+    pub(crate) width: u32,
+    pub(crate) height: u32,
+    pub(crate) depth: u32,
+    pub(crate) border: u32,
+}
+
+impl WebGLValidator for CommonTexImage3DValidator<'_> {
+    type Error = TexImageValidationError;
+    type ValidatedOutput = CommonTexImage3DValidatorResult;
+    fn validate(self) -> Result<Self::ValidatedOutput, TexImageValidationError> {
+        // GL_INVALID_ENUM is generated if target is not GL_TEXTURE_3D or GL_TEXTURE_2D_ARRAY.
+        let target = match TexImageTarget::from_gl_constant(self.target) {
+            Some(target) if target.dimensions() == 3 => target,
+            _ => {
+                self.context.webgl_error(InvalidEnum);
+                return Err(TexImageValidationError::InvalidTextureTarget(self.target));
+            },
+        };
+
+        let texture = self
+            .context
+            .textures()
+            .active_texture_for_image_target(target);
+        let limits = self.context.limits();
+
+        let max_size = limits.max_3d_tex_size;
+
+        //  If an attempt is made to call this function with no WebGLTexture
+        //  bound, an INVALID_OPERATION error is generated.
+        let texture = match texture {
+            Some(texture) => texture,
+            None => {
+                self.context.webgl_error(InvalidOperation);
+                return Err(TexImageValidationError::TextureTargetNotBound(self.target));
+            },
+        };
+
+        // GL_INVALID_ENUM is generated if internal_format is not an accepted
+        // format.
+        let internal_format = match TexFormat::from_gl_constant(self.internal_format) {
+            Some(format)
+                if format.required_webgl_version() <= self.context.webgl_version() &&
+                    format.usable_as_internal() =>
+            {
+                format
+            },
+            _ => {
+                self.context.webgl_error(InvalidEnum);
+                return Err(TexImageValidationError::InvalidTextureFormat);
+            },
+        };
+
+        // GL_INVALID_VALUE is generated if width, height, or depth is less than 0 or greater than
+        // GL_MAX_3D_TEXTURE_SIZE.
+        if self.width < 0 || self.height < 0 || self.depth < 0 {
+            self.context.webgl_error(InvalidValue);
+            return Err(TexImageValidationError::NegativeDimension);
+        }
+        let width = self.width as u32;
+        let height = self.height as u32;
+        let depth = self.depth as u32;
+        let level = self.level as u32;
+        if width > max_size || height > max_size || level > max_size {
+            self.context.webgl_error(InvalidValue);
+            return Err(TexImageValidationError::TextureTooBig);
+        }
+
+        // GL_INVALID_VALUE may be generated if level is greater than log2(max),
+        // where max is the returned value of GL_MAX_3D_TEXTURE_SIZE.
+        if self.level < 0 {
+            self.context.webgl_error(InvalidValue);
+            return Err(TexImageValidationError::NegativeLevel);
+        }
+        if level > log2(max_size) {
+            self.context.webgl_error(InvalidValue);
+            return Err(TexImageValidationError::LevelTooHigh);
+        }
+
+        // GL_INVALID_VALUE is generated if border is not 0 or 1.
+        if !(self.border == 0 || self.border == 1) {
+            self.context.webgl_error(InvalidValue);
+            return Err(TexImageValidationError::InvalidBorder);
+        }
+
+        Ok(CommonTexImage3DValidatorResult {
+            texture,
+            target,
+            level,
+            internal_format,
+            width,
+            height,
+            depth,
+            border: self.border as u32,
+        })
+    }
+}
+
+impl<'a> CommonTexImage3DValidator<'a> {
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn new(
+        context: &'a WebGLRenderingContext,
+        target: u32,
+        level: i32,
+        internal_format: u32,
+        width: i32,
+        height: i32,
+        depth: i32,
+        border: i32,
+    ) -> Self {
+        CommonTexImage3DValidator {
+            context,
+            target,
+            level,
+            internal_format,
+            width,
+            height,
+            depth,
+            border,
+        }
+    }
+}
+
+pub(crate) struct TexImage3DValidator<'a> {
+    common_validator: CommonTexImage3DValidator<'a>,
+    format: u32,
+    data_type: u32,
+    data: &'a Option<ArrayBufferView>,
+}
+
+impl<'a> TexImage3DValidator<'a> {
+    /// TODO: Move data validation logic here.
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn new(
+        context: &'a WebGLRenderingContext,
+        target: u32,
+        level: i32,
+        internal_format: u32,
+        width: i32,
+        height: i32,
+        depth: i32,
+        border: i32,
+        format: u32,
+        data_type: u32,
+        data: &'a Option<ArrayBufferView>,
+    ) -> Self {
+        TexImage3DValidator {
+            common_validator: CommonTexImage3DValidator::new(
+                context,
+                target,
+                level,
+                internal_format,
+                width,
+                height,
+                depth,
+                border,
+            ),
+            format,
+            data_type,
+            data,
+        }
+    }
+}
+
+/// The validated result of a TexImage2DValidator-validated call.
+pub(crate) struct TexImage3DValidatorResult {
+    /// NB: width, height and level are already unsigned after validation.
+    pub(crate) width: u32,
+    pub(crate) height: u32,
+    pub(crate) depth: u32,
+    pub(crate) level: u32,
+    pub(crate) border: u32,
+    pub(crate) texture: DomRoot<WebGLTexture>,
+    pub(crate) target: TexImageTarget,
+    pub(crate) internal_format: TexFormat,
+    pub(crate) format: TexFormat,
+    pub(crate) data_type: TexDataType,
+}
+
+/// TexImage3d validator as per
+/// <https://www.khronos.org/opengles/sdk/docs/man/xhtml/glTexImage3D.xml>
+impl WebGLValidator for TexImage3DValidator<'_> {
+    type ValidatedOutput = TexImage3DValidatorResult;
+    type Error = TexImageValidationError;
+
+    fn validate(self) -> Result<Self::ValidatedOutput, TexImageValidationError> {
+        let context = self.common_validator.context;
+        let CommonTexImage3DValidatorResult {
+            texture,
+            target,
+            level,
+            internal_format,
+            width,
+            height,
+            depth,
+            border,
+        } = self.common_validator.validate()?;
+
+        // GL_INVALID_ENUM is generated if format is not an accepted format constant.
+        // Format constants other than GL_STENCIL_INDEX and GL_DEPTH_COMPONENT are accepted.
+        let data_type = match TexDataType::from_gl_constant(self.data_type) {
+            Some(data_type) if data_type.required_webgl_version() <= context.webgl_version() => {
+                data_type
+            },
+            _ => {
+                context.webgl_error(InvalidEnum);
+                return Err(TexImageValidationError::InvalidDataType);
+            },
+        };
+        let format = match TexFormat::from_gl_constant(self.format) {
+            Some(format) if format.required_webgl_version() <= context.webgl_version() => format,
+            _ => {
+                context.webgl_error(InvalidEnum);
+                return Err(TexImageValidationError::InvalidTextureFormat);
+            },
+        };
+
+        // GL_INVALID_OPERATION is generated if format does not match
+        // internal_format.
+        if format != internal_format.to_unsized() {
+            context.webgl_error(InvalidOperation);
+            return Err(TexImageValidationError::TextureFormatMismatch);
+        }
+
+        if !internal_format.compatible_data_types().contains(&data_type) {
+            context.webgl_error(InvalidOperation);
+            return Err(TexImageValidationError::TextureFormatMismatch);
+        }
+
+        // GL_INVALID_OPERATION is generated if target is GL_TEXTURE_3D and
+        // format is GL_DEPTH_COMPONENT, or GL_DEPTH_STENCIL.
+        if target == TexImageTarget::Texture3D &&
+            (format == TexFormat::DepthComponent || format == TexFormat::DepthStencil)
+        {
+            context.webgl_error(InvalidOperation);
+            return Err(TexImageValidationError::InvalidTypeForFormat);
+        }
+
+        // If srcData is non-null, the type of srcData must match the type according to
+        // the above table; otherwise, generate an INVALID_OPERATION error.
+        let element_size = data_type.element_size();
+        let received_size = match self.data {
+            Some(buf) => match buf.get_array_type() {
+                Type::Int8 => 1,
+                Type::Uint8 => 1,
+                Type::Int16 => 2,
+                Type::Uint16 => 2,
+                Type::Int32 => 4,
+                Type::Uint32 => 4,
+                Type::Float32 => 4,
+                _ => {
+                    context.webgl_error(InvalidOperation);
+                    return Err(TexImageValidationError::InvalidTypeForFormat);
+                },
+            },
+            None => element_size,
+        };
+        if received_size != element_size {
+            context.webgl_error(InvalidOperation);
+            return Err(TexImageValidationError::InvalidTypeForFormat);
+        }
+
+        Ok(TexImage3DValidatorResult {
+            width,
+            height,
+            depth,
+            level,
+            border,
+            texture,
+            target,
+            internal_format,
+            format,
+            data_type,
+        })
+    }
+}

components/script/dom/webglrenderingcontext.rs

@@ -143,7 +143,7 @@ pub(crate) unsafe fn uniform_typed<T>(
 
 /// Set of bitflags for texture unpacking (texImage2d, etc...)
 #[derive(Clone, Copy, JSTraceable, MallocSizeOf)]
-struct TextureUnpacking(u8);
+pub(crate) struct TextureUnpacking(u8);
 
 bitflags! {
     impl TextureUnpacking: u8 {
@@ -327,6 +327,10 @@ impl WebGLRenderingContext {
         self.texture_unpacking_alignment.get()
     }
 
+    pub(crate) fn bound_draw_framebuffer(&self) -> Option<DomRoot<WebGLFramebuffer>> {
+        self.bound_draw_framebuffer.get()
+    }
+
     pub(crate) fn current_vao(&self) -> DomRoot<WebGLVertexArrayObjectOES> {
         self.current_vao.or_init(|| {
             DomRoot::from_ref(
@@ -1680,6 +1684,8 @@ impl WebGLRenderingContext {
                 constants::BOOL |
                 constants::INT |
                 constants::SAMPLER_2D |
+                WebGL2RenderingContextConstants::SAMPLER_2D_ARRAY |
+                WebGL2RenderingContextConstants::SAMPLER_3D |
                 constants::SAMPLER_CUBE => {},
                 _ => return Err(InvalidOperation),
             }
@@ -1687,7 +1693,10 @@ impl WebGLRenderingContext {
             let val = self.uniform_vec_section_int(val, src_offset, src_length, 1, location)?;
 
             match location.type_() {
-                constants::SAMPLER_2D | constants::SAMPLER_CUBE => {
+                constants::SAMPLER_2D |
+                constants::SAMPLER_CUBE |
+                WebGL2RenderingContextConstants::SAMPLER_2D_ARRAY |
+                WebGL2RenderingContextConstants::SAMPLER_3D => {
                     for &v in val
                         .iter()
                         .take(cmp::min(location.size().unwrap_or(1) as usize, val.len()))
@@ -2149,6 +2158,30 @@ impl WebGLRenderingContextMethods<crate::DomTypeHolder> for WebGLRenderingContex
                 texture.to_jsval(*cx, retval);
                 return;
             },
+            WebGL2RenderingContextConstants::TEXTURE_BINDING_2D_ARRAY => unsafe {
+                let texture = self
+                    .textures
+                    .active_texture_slot(
+                        WebGL2RenderingContextConstants::TEXTURE_2D_ARRAY,
+                        self.webgl_version(),
+                    )
+                    .unwrap()
+                    .get();
+                texture.to_jsval(*cx, retval);
+                return;
+            },
+            WebGL2RenderingContextConstants::TEXTURE_BINDING_3D => unsafe {
+                let texture = self
+                    .textures
+                    .active_texture_slot(
+                        WebGL2RenderingContextConstants::TEXTURE_3D,
+                        self.webgl_version(),
+                    )
+                    .unwrap()
+                    .get();
+                texture.to_jsval(*cx, retval);
+                return;
+            },
             constants::TEXTURE_BINDING_CUBE_MAP => unsafe {
                 let texture = self
                     .textures
@@ -4036,7 +4069,10 @@ impl WebGLRenderingContextMethods<crate::DomTypeHolder> for WebGLRenderingContex
         self.with_location(location, |location| {
             match location.type_() {
                 constants::BOOL | constants::INT => {},
-                constants::SAMPLER_2D | constants::SAMPLER_CUBE => {
+                constants::SAMPLER_2D |
+                WebGL2RenderingContextConstants::SAMPLER_3D |
+                WebGL2RenderingContextConstants::SAMPLER_2D_ARRAY |
+                constants::SAMPLER_CUBE => {
                     if val < 0 || val as u32 >= self.limits.max_combined_texture_image_units {
                         return Err(InvalidValue);
                     }
@@ -4237,7 +4273,11 @@ impl WebGLRenderingContextMethods<crate::DomTypeHolder> for WebGLRenderingContex
             constants::BOOL_VEC4 => unsafe {
                 uniform_get(triple, WebGLCommand::GetUniformBool4).to_jsval(*cx, rval);
             },
-            constants::INT | constants::SAMPLER_2D | constants::SAMPLER_CUBE => {
+            constants::INT |
+            constants::SAMPLER_2D |
+            constants::SAMPLER_CUBE |
+            WebGL2RenderingContextConstants::SAMPLER_2D_ARRAY |
+            WebGL2RenderingContextConstants::SAMPLER_3D => {
                 rval.set(Int32Value(uniform_get(triple, WebGLCommand::GetUniformInt)))
             },
             constants::INT_VEC2 => unsafe {
@@ -5122,6 +5162,22 @@ impl TexPixels {
     pub(crate) fn size(&self) -> Size2D<u32> {
         self.size
     }
+
+    pub(crate) fn pixel_format(&self) -> Option<PixelFormat> {
+        self.pixel_format
+    }
+
+    pub(crate) fn alpha_treatment(&self) -> Option<AlphaTreatment> {
+        self.alpha_treatment
+    }
+
+    pub(crate) fn y_axis_treatment(&self) -> YAxisTreatment {
+        self.y_axis_treatment
+    }
+
+    pub(crate) fn into_shared_memory(self) -> IpcSharedMemory {
+        self.data
+    }
 }
 
 pub(crate) enum TexSource {

components/script/dom/webgltexture.rs

@@ -11,7 +11,7 @@ use std::cmp;
 
 use canvas_traits::webgl::{
     TexDataType, TexFormat, TexParameter, TexParameterBool, TexParameterInt, WebGLCommand,
-    WebGLError, WebGLResult, WebGLTextureId, webgl_channel,
+    WebGLError, WebGLResult, WebGLTextureId, WebGLVersion, webgl_channel,
 };
 use dom_struct::dom_struct;
 
@@ -158,7 +158,7 @@ impl WebGLTexture {
         } else {
             // This is the first time binding
             let face_count = match target {
-                constants::TEXTURE_2D => 1,
+                constants::TEXTURE_2D | constants::TEXTURE_2D_ARRAY | constants::TEXTURE_3D => 1,
                 constants::TEXTURE_CUBE_MAP => 6,
                 _ => return Err(WebGLError::InvalidEnum),
             };
@@ -314,16 +314,60 @@ impl WebGLTexture {
             TexParameterValue::Bool(_) => unreachable!("no settable tex params should be booleans"),
         };
 
+        let context = self.upcast::<WebGLObject>().context();
+        let is_webgl2 = context.webgl_version() == WebGLVersion::WebGL2;
+
         let update_filter = |filter: &Cell<u32>| {
             if filter.get() == int_value as u32 {
                 return Ok(());
             }
             filter.set(int_value as u32);
-            self.upcast::<WebGLObject>()
-                .context()
-                .send_command(WebGLCommand::TexParameteri(target, param, int_value));
+            context.send_command(WebGLCommand::TexParameteri(target, param, int_value));
             Ok(())
         };
+        if is_webgl2 {
+            match param {
+                constants::TEXTURE_BASE_LEVEL | constants::TEXTURE_MAX_LEVEL => {
+                    context.send_command(WebGLCommand::TexParameteri(target, param, int_value));
+                    return Ok(());
+                },
+                constants::TEXTURE_COMPARE_FUNC => match int_value as u32 {
+                    constants::LEQUAL |
+                    constants::GEQUAL |
+                    constants::LESS |
+                    constants::GREATER |
+                    constants::EQUAL |
+                    constants::NOTEQUAL |
+                    constants::ALWAYS |
+                    constants::NEVER => {
+                        context.send_command(WebGLCommand::TexParameteri(target, param, int_value));
+                        return Ok(());
+                    },
+                    _ => return Err(WebGLError::InvalidEnum),
+                },
+                constants::TEXTURE_COMPARE_MODE => match int_value as u32 {
+                    constants::COMPARE_REF_TO_TEXTURE | constants::NONE => {
+                        context.send_command(WebGLCommand::TexParameteri(target, param, int_value));
+                        return Ok(());
+                    },
+                    _ => return Err(WebGLError::InvalidEnum),
+                },
+                constants::TEXTURE_MAX_LOD | constants::TEXTURE_MIN_LOD => {
+                    context.send_command(WebGLCommand::TexParameterf(target, param, float_value));
+                    return Ok(());
+                },
+                constants::TEXTURE_WRAP_R => match int_value as u32 {
+                    constants::CLAMP_TO_EDGE | constants::MIRRORED_REPEAT | constants::REPEAT => {
+                        self.upcast::<WebGLObject>()
+                            .context()
+                            .send_command(WebGLCommand::TexParameteri(target, param, int_value));
+                        return Ok(());
+                    },
+                    _ => return Err(WebGLError::InvalidEnum),
+                },
+                _ => {},
+            }
+        }
         match param {
             constants::TEXTURE_MIN_FILTER => match int_value as u32 {
                 constants::NEAREST |
@@ -340,9 +384,7 @@ impl WebGLTexture {
             },
             constants::TEXTURE_WRAP_S | constants::TEXTURE_WRAP_T => match int_value as u32 {
                 constants::CLAMP_TO_EDGE | constants::MIRRORED_REPEAT | constants::REPEAT => {
-                    self.upcast::<WebGLObject>()
-                        .context()
-                        .send_command(WebGLCommand::TexParameteri(target, param, int_value));
+                    context.send_command(WebGLCommand::TexParameteri(target, param, int_value));
                     Ok(())
                 },
                 _ => Err(WebGLError::InvalidEnum),
@@ -352,9 +394,7 @@ impl WebGLTexture {
                 if float_value < 1. || !float_value.is_normal() {
                     return Err(WebGLError::InvalidValue);
                 }
-                self.upcast::<WebGLObject>()
-                    .context()
-                    .send_command(WebGLCommand::TexParameterf(target, param, float_value));
+                context.send_command(WebGLCommand::TexParameterf(target, param, float_value));
                 Ok(())
             },
             _ => Err(WebGLError::InvalidEnum),

components/script_bindings/webidls/WebGL2RenderingContext.webidl

@@ -322,9 +322,9 @@ interface mixin WebGL2RenderingContextBase
   //void texImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
   //                GLsizei depth, GLint border, GLenum format, GLenum type,
   //                TexImageSource source); // May throw DOMException
-  //[Throws]
-  //void texImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
-  //                GLsizei depth, GLint border, GLenum format, GLenum type, [AllowShared] ArrayBufferView? srcData);
+  [Throws]
+  undefined texImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
+                  GLsizei depth, GLint border, GLenum format, GLenum type, /*[AllowShared]*/ ArrayBufferView? srcData);
   //[Throws]
   //void texImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
   //                GLsizei depth, GLint border, GLenum format, GLenum type, [AllowShared] ArrayBufferView srcData,

components/shared/canvas/webgl.rs

@@ -364,6 +364,22 @@ pub enum WebGLCommand {
     VertexAttribPointer(u32, i32, u32, bool, i32, u32),
     VertexAttribPointer2f(u32, i32, bool, i32, u32),
     SetViewport(i32, i32, i32, i32),
+    TexImage3D {
+        target: u32,
+        level: u32,
+        internal_format: TexFormat,
+        size: Size2D<u32>,
+        depth: u32,
+        format: TexFormat,
+        data_type: TexDataType,
+        // FIXME: This should be computed on the WebGL thread.
+        effective_data_type: u32,
+        unpacking_alignment: u32,
+        alpha_treatment: Option<AlphaTreatment>,
+        y_axis_treatment: YAxisTreatment,
+        pixel_format: Option<PixelFormat>,
+        data: TruncatedDebug<IpcSharedMemory>,
+    },
     TexImage2D {
         target: u32,
         level: u32,
@@ -1437,6 +1453,7 @@ pub struct GLContextAttributes {
 pub struct GLLimits {
     pub max_vertex_attribs: u32,
     pub max_tex_size: u32,
+    pub max_3d_tex_size: u32,
     pub max_cube_map_tex_size: u32,
     pub max_combined_texture_image_units: u32,
     pub max_fragment_uniform_vectors: u32,

components/webgl/webgl_limits.rs

@@ -14,6 +14,7 @@ impl GLLimitsDetect for GLLimits {
     fn detect(gl: &Gl, webgl_version: WebGLVersion) -> GLLimits {
         let max_vertex_attribs = gl.get_integer(gl::MAX_VERTEX_ATTRIBS);
         let max_tex_size = gl.get_integer(gl::MAX_TEXTURE_SIZE);
+        let max_3d_tex_size = gl.get_integer(gl::MAX_3D_TEXTURE_SIZE);
         let max_cube_map_tex_size = gl.get_integer(gl::MAX_CUBE_MAP_TEXTURE_SIZE);
         let max_combined_texture_image_units = gl.get_integer(gl::MAX_COMBINED_TEXTURE_IMAGE_UNITS);
         let max_renderbuffer_size = gl.get_integer(gl::MAX_RENDERBUFFER_SIZE);
@@ -160,6 +161,7 @@ impl GLLimitsDetect for GLLimits {
         GLLimits {
             max_vertex_attribs,
             max_tex_size,
+            max_3d_tex_size,
             max_cube_map_tex_size,
             max_combined_texture_image_units,
             max_fragment_uniform_vectors,

components/webgl/webgl_thread.rs

@@ -1582,6 +1582,48 @@ impl WebGLImpl {
             WebGLCommand::SetViewport(x, y, width, height) => unsafe {
                 gl.viewport(x, y, width, height)
             },
+            WebGLCommand::TexImage3D {
+                target,
+                level,
+                internal_format,
+                size,
+                depth,
+                format,
+                data_type,
+                effective_data_type,
+                unpacking_alignment,
+                alpha_treatment,
+                y_axis_treatment,
+                pixel_format,
+                ref data,
+            } => {
+                let pixels = prepare_pixels(
+                    internal_format,
+                    data_type,
+                    size,
+                    unpacking_alignment,
+                    alpha_treatment,
+                    y_axis_treatment,
+                    pixel_format,
+                    Cow::Borrowed(data),
+                );
+
+                unsafe {
+                    gl.pixel_store_i32(gl::UNPACK_ALIGNMENT, unpacking_alignment as i32);
+                    gl.tex_image_3d(
+                        target,
+                        level as i32,
+                        internal_format.as_gl_constant() as i32,
+                        size.width as i32,
+                        size.height as i32,
+                        depth as i32,
+                        0,
+                        format.as_gl_constant(),
+                        effective_data_type,
+                        PixelUnpackData::Slice(Some(&pixels)),
+                    );
+                }
+            },
             WebGLCommand::TexImage2D {
                 target,
                 level,

tests/wpt/meta/webgl/idlharness.any.js.ini

@@ -11,9 +11,6 @@
   [WebGL2RenderingContext interface: operation getBufferSubData(GLenum, GLintptr, ArrayBufferView, optional GLuint, optional GLuint)]
     expected: FAIL
 
-  [WebGL2RenderingContext interface: operation texImage3D(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, GLintptr)]
-    expected: FAIL
-
   [WebGLRenderingContext interface: attribute drawingBufferColorSpace]
     expected: FAIL
 

tests/wpt/webgl/meta/conformance2/context/context-sharing-texture2darray-texture3d-data-bug.html.ini

@@ -1,4 +0,0 @@
-[context-sharing-texture2darray-texture3d-data-bug.html]
-  expected: ERROR
-  [WebGL test #1]
-    expected: FAIL

tests/wpt/webgl/meta/conformance2/context/incorrect-context-object-behaviour.html.ini

@@ -1,4 +1,12 @@
 [incorrect-context-object-behaviour.html]
-  expected: ERROR
-  [WebGL test #1]
+  [WebGL test #84]
+    expected: FAIL
+
+  [WebGL test #89]
+    expected: FAIL
+
+  [WebGL test #92]
+    expected: FAIL
+
+  [WebGL test #93]
     expected: FAIL

tests/wpt/webgl/meta/conformance2/context/methods-2.html.ini

@@ -11,8 +11,5 @@
   [WebGL test #3]
     expected: FAIL
 
-  [WebGL test #4]
-    expected: FAIL
-
   [WebGL test #7]
     expected: FAIL

tests/wpt/webgl/meta/conformance2/misc/expando-loss-2.html.ini

@@ -1,7 +0,0 @@
-[expando-loss-2.html]
-  expected: ERROR
-  [WebGL test #15]
-    expected: FAIL
-
-  [WebGL test #16]
-    expected: FAIL

tests/wpt/webgl/meta/conformance2/misc/uninitialized-test-2.html.ini

@@ -1,4 +1,4 @@
 [uninitialized-test-2.html]
-  expected: ERROR
+  expected: CRASH
   [WebGL test #1]
     expected: FAIL

tests/wpt/webgl/meta/conformance2/misc/views-with-offsets.html.ini

@@ -5,3 +5,6 @@
 
   [WebGL test #47]
     expected: FAIL
+
+  [WebGL test #48]
+    expected: FAIL

tests/wpt/webgl/meta/conformance2/renderbuffers/framebuffer-texture-layer.html.ini

@@ -1,4 +1,36 @@
 [framebuffer-texture-layer.html]
-  expected: ERROR
-  [WebGL test #1]
+  [WebGL test #3]
+    expected: FAIL
+
+  [WebGL test #5]
+    expected: FAIL
+
+  [WebGL test #6]
+    expected: FAIL
+
+  [WebGL test #10]
+    expected: FAIL
+
+  [WebGL test #11]
+    expected: FAIL
+
+  [WebGL test #12]
+    expected: FAIL
+
+  [WebGL test #13]
+    expected: FAIL
+
+  [WebGL test #14]
+    expected: FAIL
+
+  [WebGL test #15]
+    expected: FAIL
+
+  [WebGL test #16]
+    expected: FAIL
+
+  [WebGL test #17]
+    expected: FAIL
+
+  [WebGL test #18]
     expected: FAIL

tests/wpt/webgl/meta/conformance2/rendering/blitframebuffer-test.html.ini

@@ -1,5 +1,4 @@
 [blitframebuffer-test.html]
-  expected: ERROR
   [WebGL test #1]
     expected: FAIL
 
@@ -20,3 +19,21 @@
 
   [WebGL test #9]
     expected: FAIL
+
+  [WebGL test #11]
+    expected: FAIL
+
+  [WebGL test #13]
+    expected: FAIL
+
+  [WebGL test #16]
+    expected: FAIL
+
+  [WebGL test #18]
+    expected: FAIL
+
+  [WebGL test #19]
+    expected: FAIL
+
+  [WebGL test #20]
+    expected: FAIL

tests/wpt/webgl/meta/conformance2/rendering/depth-stencil-feedback-loop.html.ini

@@ -1,6 +1,3 @@
 [depth-stencil-feedback-loop.html]
-  [WebGL test #2]
-    expected: FAIL
-
   [WebGL test #3]
     expected: FAIL

tests/wpt/webgl/meta/conformance2/rendering/draw-with-integer-texture-base-level.html.ini

@@ -1,6 +0,0 @@
-[draw-with-integer-texture-base-level.html]
-  [WebGL test #0]
-    expected: FAIL
-
-  [WebGL test #2]
-    expected: FAIL

tests/wpt/webgl/meta/conformance2/rendering/framebuffer-mismatched-attachment-targets.html.ini

@@ -67,3 +67,33 @@
 
   [WebGL test #98]
     expected: FAIL
+
+  [WebGL test #89]
+    expected: FAIL
+
+  [WebGL test #90]
+    expected: FAIL
+
+  [WebGL test #91]
+    expected: FAIL
+
+  [WebGL test #94]
+    expected: FAIL
+
+  [WebGL test #95]
+    expected: FAIL
+
+  [WebGL test #96]
+    expected: FAIL
+
+  [WebGL test #99]
+    expected: FAIL
+
+  [WebGL test #100]
+    expected: FAIL
+
+  [WebGL test #101]
+    expected: FAIL
+
+  [WebGL test #103]
+    expected: FAIL

tests/wpt/webgl/meta/conformance2/rendering/framebuffer-render-to-layer-angle-issue.html.ini

@@ -1,4 +0,0 @@
-[framebuffer-render-to-layer-angle-issue.html]
-  expected: ERROR
-  [WebGL test #1]
-    expected: FAIL

tests/wpt/webgl/meta/conformance2/rendering/framebuffer-render-to-layer.html.ini

@@ -1,4 +1,519 @@
 [framebuffer-render-to-layer.html]
-  expected: ERROR
-  [WebGL test #31]
+  [WebGL test #190]
+    expected: FAIL
+
+  [WebGL test #192]
+    expected: FAIL
+
+  [WebGL test #194]
+    expected: FAIL
+
+  [WebGL test #195]
+    expected: FAIL
+
+  [WebGL test #197]
+    expected: FAIL
+
+  [WebGL test #199]
+    expected: FAIL
+
+  [WebGL test #206]
+    expected: FAIL
+
+  [WebGL test #213]
+    expected: FAIL
+
+  [WebGL test #361]
+    expected: FAIL
+
+  [WebGL test #368]
+    expected: FAIL
+
+  [WebGL test #385]
+    expected: FAIL
+
+  [WebGL test #387]
+    expected: FAIL
+
+  [WebGL test #389]
+    expected: FAIL
+
+  [WebGL test #391]
+    expected: FAIL
+
+  [WebGL test #393]
+    expected: FAIL
+
+  [WebGL test #395]
+    expected: FAIL
+
+  [WebGL test #397]
+    expected: FAIL
+
+  [WebGL test #399]
+    expected: FAIL
+
+  [WebGL test #401]
+    expected: FAIL
+
+  [WebGL test #403]
+    expected: FAIL
+
+  [WebGL test #405]
+    expected: FAIL
+
+  [WebGL test #407]
+    expected: FAIL
+
+  [WebGL test #409]
+    expected: FAIL
+
+  [WebGL test #411]
+    expected: FAIL
+
+  [WebGL test #412]
+    expected: FAIL
+
+  [WebGL test #414]
+    expected: FAIL
+
+  [WebGL test #416]
+    expected: FAIL
+
+  [WebGL test #417]
+    expected: FAIL
+
+  [WebGL test #419]
+    expected: FAIL
+
+  [WebGL test #421]
+    expected: FAIL
+
+  [WebGL test #422]
+    expected: FAIL
+
+  [WebGL test #424]
+    expected: FAIL
+
+  [WebGL test #426]
+    expected: FAIL
+
+  [WebGL test #427]
+    expected: FAIL
+
+  [WebGL test #429]
+    expected: FAIL
+
+  [WebGL test #431]
+    expected: FAIL
+
+  [WebGL test #432]
+    expected: FAIL
+
+  [WebGL test #434]
+    expected: FAIL
+
+  [WebGL test #436]
+    expected: FAIL
+
+  [WebGL test #437]
+    expected: FAIL
+
+  [WebGL test #439]
+    expected: FAIL
+
+  [WebGL test #441]
+    expected: FAIL
+
+  [WebGL test #442]
+    expected: FAIL
+
+  [WebGL test #444]
+    expected: FAIL
+
+  [WebGL test #446]
+    expected: FAIL
+
+  [WebGL test #447]
+    expected: FAIL
+
+  [WebGL test #449]
+    expected: FAIL
+
+  [WebGL test #451]
+    expected: FAIL
+
+  [WebGL test #453]
+    expected: FAIL
+
+  [WebGL test #455]
+    expected: FAIL
+
+  [WebGL test #457]
+    expected: FAIL
+
+  [WebGL test #458]
+    expected: FAIL
+
+  [WebGL test #460]
+    expected: FAIL
+
+  [WebGL test #462]
+    expected: FAIL
+
+  [WebGL test #463]
+    expected: FAIL
+
+  [WebGL test #465]
+    expected: FAIL
+
+  [WebGL test #467]
+    expected: FAIL
+
+  [WebGL test #468]
+    expected: FAIL
+
+  [WebGL test #470]
+    expected: FAIL
+
+  [WebGL test #472]
+    expected: FAIL
+
+  [WebGL test #473]
+    expected: FAIL
+
+  [WebGL test #475]
+    expected: FAIL
+
+  [WebGL test #477]
+    expected: FAIL
+
+  [WebGL test #478]
+    expected: FAIL
+
+  [WebGL test #480]
+    expected: FAIL
+
+  [WebGL test #482]
+    expected: FAIL
+
+  [WebGL test #483]
+    expected: FAIL
+
+  [WebGL test #485]
+    expected: FAIL
+
+  [WebGL test #487]
+    expected: FAIL
+
+  [WebGL test #488]
+    expected: FAIL
+
+  [WebGL test #490]
+    expected: FAIL
+
+  [WebGL test #492]
+    expected: FAIL
+
+  [WebGL test #493]
+    expected: FAIL
+
+  [WebGL test #495]
+    expected: FAIL
+
+  [WebGL test #497]
+    expected: FAIL
+
+  [WebGL test #499]
+    expected: FAIL
+
+  [WebGL test #500]
+    expected: FAIL
+
+  [WebGL test #501]
+    expected: FAIL
+
+  [WebGL test #502]
+    expected: FAIL
+
+  [WebGL test #503]
+    expected: FAIL
+
+  [WebGL test #504]
+    expected: FAIL
+
+  [WebGL test #505]
+    expected: FAIL
+
+  [WebGL test #506]
+    expected: FAIL
+
+  [WebGL test #507]
+    expected: FAIL
+
+  [WebGL test #508]
+    expected: FAIL
+
+  [WebGL test #509]
+    expected: FAIL
+
+  [WebGL test #510]
+    expected: FAIL
+
+  [WebGL test #511]
+    expected: FAIL
+
+  [WebGL test #512]
+    expected: FAIL
+
+  [WebGL test #513]
+    expected: FAIL
+
+  [WebGL test #514]
+    expected: FAIL
+
+  [WebGL test #515]
+    expected: FAIL
+
+  [WebGL test #516]
+    expected: FAIL
+
+  [WebGL test #518]
+    expected: FAIL
+
+  [WebGL test #520]
+    expected: FAIL
+
+  [WebGL test #522]
+    expected: FAIL
+
+  [WebGL test #523]
+    expected: FAIL
+
+  [WebGL test #525]
+    expected: FAIL
+
+  [WebGL test #527]
+    expected: FAIL
+
+  [WebGL test #528]
+    expected: FAIL
+
+  [WebGL test #530]
+    expected: FAIL
+
+  [WebGL test #532]
+    expected: FAIL
+
+  [WebGL test #533]
+    expected: FAIL
+
+  [WebGL test #535]
+    expected: FAIL
+
+  [WebGL test #537]
+    expected: FAIL
+
+  [WebGL test #538]
+    expected: FAIL
+
+  [WebGL test #540]
+    expected: FAIL
+
+  [WebGL test #542]
+    expected: FAIL
+
+  [WebGL test #543]
+    expected: FAIL
+
+  [WebGL test #545]
+    expected: FAIL
+
+  [WebGL test #547]
+    expected: FAIL
+
+  [WebGL test #548]
+    expected: FAIL
+
+  [WebGL test #550]
+    expected: FAIL
+
+  [WebGL test #552]
+    expected: FAIL
+
+  [WebGL test #553]
+    expected: FAIL
+
+  [WebGL test #555]
+    expected: FAIL
+
+  [WebGL test #557]
+    expected: FAIL
+
+  [WebGL test #558]
+    expected: FAIL
+
+  [WebGL test #560]
+    expected: FAIL
+
+  [WebGL test #562]
+    expected: FAIL
+
+  [WebGL test #563]
+    expected: FAIL
+
+  [WebGL test #565]
+    expected: FAIL
+
+  [WebGL test #567]
+    expected: FAIL
+
+  [WebGL test #569]
+    expected: FAIL
+
+  [WebGL test #571]
+    expected: FAIL
+
+  [WebGL test #573]
+    expected: FAIL
+
+  [WebGL test #574]
+    expected: FAIL
+
+  [WebGL test #576]
+    expected: FAIL
+
+  [WebGL test #578]
+    expected: FAIL
+
+  [WebGL test #579]
+    expected: FAIL
+
+  [WebGL test #581]
+    expected: FAIL
+
+  [WebGL test #583]
+    expected: FAIL
+
+  [WebGL test #584]
+    expected: FAIL
+
+  [WebGL test #586]
+    expected: FAIL
+
+  [WebGL test #588]
+    expected: FAIL
+
+  [WebGL test #589]
+    expected: FAIL
+
+  [WebGL test #591]
+    expected: FAIL
+
+  [WebGL test #593]
+    expected: FAIL
+
+  [WebGL test #594]
+    expected: FAIL
+
+  [WebGL test #596]
+    expected: FAIL
+
+  [WebGL test #598]
+    expected: FAIL
+
+  [WebGL test #599]
+    expected: FAIL
+
+  [WebGL test #601]
+    expected: FAIL
+
+  [WebGL test #603]
+    expected: FAIL
+
+  [WebGL test #604]
+    expected: FAIL
+
+  [WebGL test #606]
+    expected: FAIL
+
+  [WebGL test #608]
+    expected: FAIL
+
+  [WebGL test #609]
+    expected: FAIL
+
+  [WebGL test #611]
+    expected: FAIL
+
+  [WebGL test #613]
+    expected: FAIL
+
+  [WebGL test #614]
+    expected: FAIL
+
+  [WebGL test #616]
+    expected: FAIL
+
+  [WebGL test #618]
+    expected: FAIL
+
+  [WebGL test #620]
+    expected: FAIL
+
+  [WebGL test #621]
+    expected: FAIL
+
+  [WebGL test #622]
+    expected: FAIL
+
+  [WebGL test #623]
+    expected: FAIL
+
+  [WebGL test #624]
+    expected: FAIL
+
+  [WebGL test #625]
+    expected: FAIL
+
+  [WebGL test #626]
+    expected: FAIL
+
+  [WebGL test #627]
+    expected: FAIL
+
+  [WebGL test #628]
+    expected: FAIL
+
+  [WebGL test #629]
+    expected: FAIL
+
+  [WebGL test #630]
+    expected: FAIL
+
+  [WebGL test #631]
+    expected: FAIL
+
+  [WebGL test #632]
+    expected: FAIL
+
+  [WebGL test #633]
+    expected: FAIL
+
+  [WebGL test #634]
+    expected: FAIL
+
+  [WebGL test #635]
+    expected: FAIL
+
+  [WebGL test #636]
+    expected: FAIL
+
+  [WebGL test #637]
+    expected: FAIL
+
+  [WebGL test #638]
+    expected: FAIL
+
+  [WebGL test #639]
     expected: FAIL

tests/wpt/webgl/meta/conformance2/rendering/framebuffer-texture-changing-base-level.html.ini

@@ -1,15 +0,0 @@
-[framebuffer-texture-changing-base-level.html]
-  [WebGL test #10]
-    expected: FAIL
-
-  [WebGL test #14]
-    expected: FAIL
-
-  [WebGL test #17]
-    expected: FAIL
-
-  [WebGL test #2]
-    expected: FAIL
-
-  [WebGL test #6]
-    expected: FAIL

tests/wpt/webgl/meta/conformance2/rendering/framebuffer-texture-level1.html.ini

@@ -1,6 +1,3 @@
 [framebuffer-texture-level1.html]
   [WebGL test #1]
     expected: FAIL
-
-  [WebGL test #3]
-    expected: FAIL

tests/wpt/webgl/meta/conformance2/rendering/framebuffer-unsupported.html.ini

@@ -1,5 +1,4 @@
 [framebuffer-unsupported.html]
-  expected: ERROR
   [WebGL test #4]
     expected: FAIL
 
@@ -8,3 +7,9 @@
 
   [WebGL test #8]
     expected: FAIL
+
+  [WebGL test #9]
+    expected: FAIL
+
+  [WebGL test #10]
+    expected: FAIL

tests/wpt/webgl/meta/conformance2/state/gl-get-calls.html.ini

@@ -1,3 +0,0 @@
-[gl-get-calls.html]
-  [WebGL test #87]
-    expected: FAIL

tests/wpt/webgl/meta/conformance2/state/gl-object-get-calls.html.ini

@@ -8,27 +8,6 @@
   [WebGL test #182]
     expected: FAIL
 
-  [WebGL test #197]
-    expected: FAIL
-
-  [WebGL test #198]
-    expected: FAIL
-
-  [WebGL test #199]
-    expected: FAIL
-
-  [WebGL test #200]
-    expected: FAIL
-
-  [WebGL test #201]
-    expected: FAIL
-
-  [WebGL test #257]
-    expected: FAIL
-
-  [WebGL test #259]
-    expected: FAIL
-
   [WebGL test #268]
     expected: FAIL
 

tests/wpt/webgl/meta/conformance2/textures/misc/active-3d-texture-bug.html.ini

@@ -1,4 +0,0 @@
-[active-3d-texture-bug.html]
-  expected: ERROR
-  [WebGL test #1]
-    expected: FAIL

tests/wpt/webgl/meta/conformance2/textures/misc/copy-texture-image-same-texture.html.ini

@@ -2,29 +2,17 @@
   [WebGL test #11]
     expected: FAIL
 
-  [WebGL test #12]
-    expected: FAIL
-
   [WebGL test #16]
     expected: FAIL
 
   [WebGL test #18]
     expected: FAIL
 
-  [WebGL test #19]
-    expected: FAIL
-
   [WebGL test #2]
     expected: FAIL
 
   [WebGL test #3]
     expected: FAIL
 
-  [WebGL test #6]
-    expected: FAIL
-
   [WebGL test #8]
     expected: FAIL
-
-  [WebGL test #9]
-    expected: FAIL

tests/wpt/webgl/meta/conformance2/textures/misc/copy-texture-image-webgl-specific.html.ini

@@ -2,3 +2,12 @@
   expected: ERROR
   [WebGL test #1]
     expected: FAIL
+
+  [WebGL test #2]
+    expected: FAIL
+
+  [WebGL test #3]
+    expected: FAIL
+
+  [WebGL test #4]
+    expected: FAIL

tests/wpt/webgl/meta/conformance2/textures/misc/generate-mipmap-with-large-base-level.html.ini

@@ -1,6 +1,3 @@
 [generate-mipmap-with-large-base-level.html]
-  [WebGL test #1]
-    expected: FAIL
-
   [WebGL test #3]
     expected: FAIL

tests/wpt/webgl/meta/conformance2/textures/misc/gl-get-tex-parameter.html.ini

@@ -1,636 +0,0 @@
-[gl-get-tex-parameter.html]
-  [WebGL test #0]
-    expected: FAIL
-
-  [WebGL test #101]
-    expected: FAIL
-
-  [WebGL test #102]
-    expected: FAIL
-
-  [WebGL test #103]
-    expected: FAIL
-
-  [WebGL test #104]
-    expected: FAIL
-
-  [WebGL test #109]
-    expected: FAIL
-
-  [WebGL test #110]
-    expected: FAIL
-
-  [WebGL test #111]
-    expected: FAIL
-
-  [WebGL test #112]
-    expected: FAIL
-
-  [WebGL test #117]
-    expected: FAIL
-
-  [WebGL test #118]
-    expected: FAIL
-
-  [WebGL test #119]
-    expected: FAIL
-
-  [WebGL test #120]
-    expected: FAIL
-
-  [WebGL test #125]
-    expected: FAIL
-
-  [WebGL test #126]
-    expected: FAIL
-
-  [WebGL test #127]
-    expected: FAIL
-
-  [WebGL test #128]
-    expected: FAIL
-
-  [WebGL test #13]
-    expected: FAIL
-
-  [WebGL test #133]
-    expected: FAIL
-
-  [WebGL test #134]
-    expected: FAIL
-
-  [WebGL test #135]
-    expected: FAIL
-
-  [WebGL test #136]
-    expected: FAIL
-
-  [WebGL test #137]
-    expected: FAIL
-
-  [WebGL test #138]
-    expected: FAIL
-
-  [WebGL test #139]
-    expected: FAIL
-
-  [WebGL test #14]
-    expected: FAIL
-
-  [WebGL test #140]
-    expected: FAIL
-
-  [WebGL test #141]
-    expected: FAIL
-
-  [WebGL test #142]
-    expected: FAIL
-
-  [WebGL test #143]
-    expected: FAIL
-
-  [WebGL test #144]
-    expected: FAIL
-
-  [WebGL test #145]
-    expected: FAIL
-
-  [WebGL test #146]
-    expected: FAIL
-
-  [WebGL test #147]
-    expected: FAIL
-
-  [WebGL test #148]
-    expected: FAIL
-
-  [WebGL test #149]
-    expected: FAIL
-
-  [WebGL test #15]
-    expected: FAIL
-
-  [WebGL test #150]
-    expected: FAIL
-
-  [WebGL test #151]
-    expected: FAIL
-
-  [WebGL test #152]
-    expected: FAIL
-
-  [WebGL test #153]
-    expected: FAIL
-
-  [WebGL test #154]
-    expected: FAIL
-
-  [WebGL test #155]
-    expected: FAIL
-
-  [WebGL test #156]
-    expected: FAIL
-
-  [WebGL test #157]
-    expected: FAIL
-
-  [WebGL test #158]
-    expected: FAIL
-
-  [WebGL test #159]
-    expected: FAIL
-
-  [WebGL test #16]
-    expected: FAIL
-
-  [WebGL test #160]
-    expected: FAIL
-
-  [WebGL test #161]
-    expected: FAIL
-
-  [WebGL test #162]
-    expected: FAIL
-
-  [WebGL test #163]
-    expected: FAIL
-
-  [WebGL test #164]
-    expected: FAIL
-
-  [WebGL test #165]
-    expected: FAIL
-
-  [WebGL test #166]
-    expected: FAIL
-
-  [WebGL test #167]
-    expected: FAIL
-
-  [WebGL test #168]
-    expected: FAIL
-
-  [WebGL test #169]
-    expected: FAIL
-
-  [WebGL test #170]
-    expected: FAIL
-
-  [WebGL test #171]
-    expected: FAIL
-
-  [WebGL test #172]
-    expected: FAIL
-
-  [WebGL test #173]
-    expected: FAIL
-
-  [WebGL test #174]
-    expected: FAIL
-
-  [WebGL test #175]
-    expected: FAIL
-
-  [WebGL test #176]
-    expected: FAIL
-
-  [WebGL test #177]
-    expected: FAIL
-
-  [WebGL test #178]
-    expected: FAIL
-
-  [WebGL test #179]
-    expected: FAIL
-
-  [WebGL test #180]
-    expected: FAIL
-
-  [WebGL test #181]
-    expected: FAIL
-
-  [WebGL test #182]
-    expected: FAIL
-
-  [WebGL test #183]
-    expected: FAIL
-
-  [WebGL test #184]
-    expected: FAIL
-
-  [WebGL test #185]
-    expected: FAIL
-
-  [WebGL test #186]
-    expected: FAIL
-
-  [WebGL test #187]
-    expected: FAIL
-
-  [WebGL test #188]
-    expected: FAIL
-
-  [WebGL test #189]
-    expected: FAIL
-
-  [WebGL test #190]
-    expected: FAIL
-
-  [WebGL test #191]
-    expected: FAIL
-
-  [WebGL test #192]
-    expected: FAIL
-
-  [WebGL test #197]
-    expected: FAIL
-
-  [WebGL test #198]
-    expected: FAIL
-
-  [WebGL test #199]
-    expected: FAIL
-
-  [WebGL test #200]
-    expected: FAIL
-
-  [WebGL test #205]
-    expected: FAIL
-
-  [WebGL test #206]
-    expected: FAIL
-
-  [WebGL test #207]
-    expected: FAIL
-
-  [WebGL test #208]
-    expected: FAIL
-
-  [WebGL test #21]
-    expected: FAIL
-
-  [WebGL test #213]
-    expected: FAIL
-
-  [WebGL test #214]
-    expected: FAIL
-
-  [WebGL test #215]
-    expected: FAIL
-
-  [WebGL test #216]
-    expected: FAIL
-
-  [WebGL test #22]
-    expected: FAIL
-
-  [WebGL test #221]
-    expected: FAIL
-
-  [WebGL test #222]
-    expected: FAIL
-
-  [WebGL test #223]
-    expected: FAIL
-
-  [WebGL test #224]
-    expected: FAIL
-
-  [WebGL test #229]
-    expected: FAIL
-
-  [WebGL test #23]
-    expected: FAIL
-
-  [WebGL test #230]
-    expected: FAIL
-
-  [WebGL test #231]
-    expected: FAIL
-
-  [WebGL test #232]
-    expected: FAIL
-
-  [WebGL test #237]
-    expected: FAIL
-
-  [WebGL test #238]
-    expected: FAIL
-
-  [WebGL test #239]
-    expected: FAIL
-
-  [WebGL test #24]
-    expected: FAIL
-
-  [WebGL test #240]
-    expected: FAIL
-
-  [WebGL test #241]
-    expected: FAIL
-
-  [WebGL test #242]
-    expected: FAIL
-
-  [WebGL test #243]
-    expected: FAIL
-
-  [WebGL test #244]
-    expected: FAIL
-
-  [WebGL test #245]
-    expected: FAIL
-
-  [WebGL test #246]
-    expected: FAIL
-
-  [WebGL test #247]
-    expected: FAIL
-
-  [WebGL test #248]
-    expected: FAIL
-
-  [WebGL test #249]
-    expected: FAIL
-
-  [WebGL test #250]
-    expected: FAIL
-
-  [WebGL test #251]
-    expected: FAIL
-
-  [WebGL test #252]
-    expected: FAIL
-
-  [WebGL test #253]
-    expected: FAIL
-
-  [WebGL test #254]
-    expected: FAIL
-
-  [WebGL test #255]
-    expected: FAIL
-
-  [WebGL test #256]
-    expected: FAIL
-
-  [WebGL test #257]
-    expected: FAIL
-
-  [WebGL test #259]
-    expected: FAIL
-
-  [WebGL test #261]
-    expected: FAIL
-
-  [WebGL test #262]
-    expected: FAIL
-
-  [WebGL test #263]
-    expected: FAIL
-
-  [WebGL test #264]
-    expected: FAIL
-
-  [WebGL test #265]
-    expected: FAIL
-
-  [WebGL test #266]
-    expected: FAIL
-
-  [WebGL test #267]
-    expected: FAIL
-
-  [WebGL test #268]
-    expected: FAIL
-
-  [WebGL test #269]
-    expected: FAIL
-
-  [WebGL test #270]
-    expected: FAIL
-
-  [WebGL test #271]
-    expected: FAIL
-
-  [WebGL test #272]
-    expected: FAIL
-
-  [WebGL test #273]
-    expected: FAIL
-
-  [WebGL test #274]
-    expected: FAIL
-
-  [WebGL test #275]
-    expected: FAIL
-
-  [WebGL test #276]
-    expected: FAIL
-
-  [WebGL test #277]
-    expected: FAIL
-
-  [WebGL test #278]
-    expected: FAIL
-
-  [WebGL test #279]
-    expected: FAIL
-
-  [WebGL test #280]
-    expected: FAIL
-
-  [WebGL test #281]
-    expected: FAIL
-
-  [WebGL test #282]
-    expected: FAIL
-
-  [WebGL test #283]
-    expected: FAIL
-
-  [WebGL test #284]
-    expected: FAIL
-
-  [WebGL test #285]
-    expected: FAIL
-
-  [WebGL test #286]
-    expected: FAIL
-
-  [WebGL test #287]
-    expected: FAIL
-
-  [WebGL test #288]
-    expected: FAIL
-
-  [WebGL test #289]
-    expected: FAIL
-
-  [WebGL test #29]
-    expected: FAIL
-
-  [WebGL test #290]
-    expected: FAIL
-
-  [WebGL test #291]
-    expected: FAIL
-
-  [WebGL test #292]
-    expected: FAIL
-
-  [WebGL test #293]
-    expected: FAIL
-
-  [WebGL test #294]
-    expected: FAIL
-
-  [WebGL test #295]
-    expected: FAIL
-
-  [WebGL test #296]
-    expected: FAIL
-
-  [WebGL test #30]
-    expected: FAIL
-
-  [WebGL test #301]
-    expected: FAIL
-
-  [WebGL test #302]
-    expected: FAIL
-
-  [WebGL test #303]
-    expected: FAIL
-
-  [WebGL test #304]
-    expected: FAIL
-
-  [WebGL test #309]
-    expected: FAIL
-
-  [WebGL test #31]
-    expected: FAIL
-
-  [WebGL test #310]
-    expected: FAIL
-
-  [WebGL test #311]
-    expected: FAIL
-
-  [WebGL test #312]
-    expected: FAIL
-
-  [WebGL test #313]
-    expected: FAIL
-
-  [WebGL test #32]
-    expected: FAIL
-
-  [WebGL test #37]
-    expected: FAIL
-
-  [WebGL test #38]
-    expected: FAIL
-
-  [WebGL test #39]
-    expected: FAIL
-
-  [WebGL test #40]
-    expected: FAIL
-
-  [WebGL test #45]
-    expected: FAIL
-
-  [WebGL test #46]
-    expected: FAIL
-
-  [WebGL test #47]
-    expected: FAIL
-
-  [WebGL test #48]
-    expected: FAIL
-
-  [WebGL test #5]
-    expected: FAIL
-
-  [WebGL test #53]
-    expected: FAIL
-
-  [WebGL test #54]
-    expected: FAIL
-
-  [WebGL test #55]
-    expected: FAIL
-
-  [WebGL test #56]
-    expected: FAIL
-
-  [WebGL test #6]
-    expected: FAIL
-
-  [WebGL test #61]
-    expected: FAIL
-
-  [WebGL test #62]
-    expected: FAIL
-
-  [WebGL test #63]
-    expected: FAIL
-
-  [WebGL test #64]
-    expected: FAIL
-
-  [WebGL test #69]
-    expected: FAIL
-
-  [WebGL test #7]
-    expected: FAIL
-
-  [WebGL test #70]
-    expected: FAIL
-
-  [WebGL test #71]
-    expected: FAIL
-
-  [WebGL test #72]
-    expected: FAIL
-
-  [WebGL test #77]
-    expected: FAIL
-
-  [WebGL test #78]
-    expected: FAIL
-
-  [WebGL test #79]
-    expected: FAIL
-
-  [WebGL test #8]
-    expected: FAIL
-
-  [WebGL test #80]
-    expected: FAIL
-
-  [WebGL test #85]
-    expected: FAIL
-
-  [WebGL test #86]
-    expected: FAIL
-
-  [WebGL test #87]
-    expected: FAIL
-
-  [WebGL test #88]
-    expected: FAIL
-
-  [WebGL test #93]
-    expected: FAIL
-
-  [WebGL test #94]
-    expected: FAIL
-
-  [WebGL test #95]
-    expected: FAIL
-
-  [WebGL test #96]
-    expected: FAIL

tests/wpt/webgl/meta/conformance2/textures/misc/tex-3d-mipmap-levels-intel-bug.html.ini

@@ -1,13 +1,4 @@
 [tex-3d-mipmap-levels-intel-bug.html]
-  [WebGL test #1]
-    expected: FAIL
-
-  [WebGL test #2]
-    expected: FAIL
-
-  [WebGL test #3]
-    expected: FAIL
-
   [WebGL test #4]
     expected: FAIL
 

tests/wpt/webgl/meta/conformance2/textures/misc/tex-3d-size-limit.html.ini

@@ -1,4 +1,4 @@
 [tex-3d-size-limit.html]
-  expected: ERROR
+  expected: CRASH
   [WebGL test #1]
     expected: FAIL

tests/wpt/webgl/meta/conformance2/textures/misc/tex-base-level-bug.html.ini

@@ -1,9 +0,0 @@
-[tex-base-level-bug.html]
-  [WebGL test #1]
-    expected: FAIL
-
-  [WebGL test #3]
-    expected: FAIL
-
-  [WebGL test #5]
-    expected: FAIL

tests/wpt/webgl/meta/conformance2/textures/misc/tex-image-and-sub-image-with-array-buffer-view-sub-source.html.ini

@@ -8,3 +8,9 @@
 
   [WebGL test #8]
     expected: FAIL
+
+  [WebGL test #11]
+    expected: FAIL
+
+  [WebGL test #12]
+    expected: FAIL

tests/wpt/webgl/meta/conformance2/textures/misc/tex-input-validation.html.ini

@@ -12,8 +12,11 @@
   [WebGL test #68]
     expected: FAIL
 
-  [WebGL test #70]
+  [WebGL test #76]
     expected: FAIL
 
-  [WebGL test #71]
+  [WebGL test #77]
+    expected: FAIL
+
+  [WebGL test #79]
     expected: FAIL

tests/wpt/webgl/meta/conformance2/textures/misc/tex-mipmap-levels.html.ini

@@ -6,26 +6,8 @@
   [WebGL test #11]
     expected: FAIL
 
-  [WebGL test #14]
-    expected: FAIL
-
-  [WebGL test #15]
-    expected: FAIL
-
-  [WebGL test #21]
-    expected: FAIL
-
   [WebGL test #23]
     expected: FAIL
 
-  [WebGL test #24]
-    expected: FAIL
-
-  [WebGL test #4]
-    expected: FAIL
-
-  [WebGL test #5]
-    expected: FAIL
-
-  [WebGL test #9]
+  [WebGL test #25]
     expected: FAIL

tests/wpt/webgl/meta/conformance2/textures/misc/tex-new-formats.html.ini

@@ -1,4 +1,4 @@
 [tex-new-formats.html]
   expected: ERROR
-  [WebGL test #8]
+  [WebGL test #10]
     expected: FAIL

tests/wpt/webgl/meta/conformance2/textures/misc/tex-subimage3d-pixel-buffer-bug.html.ini

@@ -1,8 +1,5 @@
 [tex-subimage3d-pixel-buffer-bug.html]
   expected: ERROR
-  [WebGL test #1]
-    expected: FAIL
-
   [WebGL test #2]
     expected: FAIL
 

tests/wpt/webgl/meta/conformance2/textures/misc/tex-unpack-params.html.ini

@@ -8,3 +8,18 @@
 
   [WebGL test #11]
     expected: FAIL
+
+  [WebGL test #13]
+    expected: FAIL
+
+  [WebGL test #14]
+    expected: FAIL
+
+  [WebGL test #15]
+    expected: FAIL
+
+  [WebGL test #16]
+    expected: FAIL
+
+  [WebGL test #17]
+    expected: FAIL

tests/wpt/webgl/meta/conformance2/uniforms/incompatible-texture-type-for-sampler.html.ini

@@ -1,181 +1,2 @@
 [incompatible-texture-type-for-sampler.html]
-  expected: ERROR
-  [WebGL test #1]
-    expected: FAIL
-
-  [WebGL test #10]
-    expected: FAIL
-
-  [WebGL test #11]
-    expected: FAIL
-
-  [WebGL test #12]
-    expected: FAIL
-
-  [WebGL test #13]
-    expected: FAIL
-
-  [WebGL test #14]
-    expected: FAIL
-
-  [WebGL test #15]
-    expected: FAIL
-
-  [WebGL test #16]
-    expected: FAIL
-
-  [WebGL test #17]
-    expected: FAIL
-
-  [WebGL test #18]
-    expected: FAIL
-
-  [WebGL test #19]
-    expected: FAIL
-
-  [WebGL test #2]
-    expected: FAIL
-
-  [WebGL test #20]
-    expected: FAIL
-
-  [WebGL test #21]
-    expected: FAIL
-
-  [WebGL test #22]
-    expected: FAIL
-
-  [WebGL test #23]
-    expected: FAIL
-
-  [WebGL test #24]
-    expected: FAIL
-
-  [WebGL test #25]
-    expected: FAIL
-
-  [WebGL test #26]
-    expected: FAIL
-
-  [WebGL test #27]
-    expected: FAIL
-
-  [WebGL test #28]
-    expected: FAIL
-
-  [WebGL test #29]
-    expected: FAIL
-
-  [WebGL test #3]
-    expected: FAIL
-
-  [WebGL test #30]
-    expected: FAIL
-
-  [WebGL test #31]
-    expected: FAIL
-
-  [WebGL test #32]
-    expected: FAIL
-
-  [WebGL test #33]
-    expected: FAIL
-
-  [WebGL test #34]
-    expected: FAIL
-
-  [WebGL test #35]
-    expected: FAIL
-
-  [WebGL test #36]
-    expected: FAIL
-
-  [WebGL test #37]
-    expected: FAIL
-
-  [WebGL test #38]
-    expected: FAIL
-
-  [WebGL test #39]
-    expected: FAIL
-
-  [WebGL test #4]
-    expected: FAIL
-
-  [WebGL test #40]
-    expected: FAIL
-
-  [WebGL test #41]
-    expected: FAIL
-
-  [WebGL test #42]
-    expected: FAIL
-
-  [WebGL test #43]
-    expected: FAIL
-
-  [WebGL test #44]
-    expected: FAIL
-
-  [WebGL test #45]
-    expected: FAIL
-
-  [WebGL test #46]
-    expected: FAIL
-
-  [WebGL test #47]
-    expected: FAIL
-
-  [WebGL test #48]
-    expected: FAIL
-
-  [WebGL test #49]
-    expected: FAIL
-
-  [WebGL test #5]
-    expected: FAIL
-
-  [WebGL test #50]
-    expected: FAIL
-
-  [WebGL test #51]
-    expected: FAIL
-
-  [WebGL test #52]
-    expected: FAIL
-
-  [WebGL test #53]
-    expected: FAIL
-
-  [WebGL test #54]
-    expected: FAIL
-
-  [WebGL test #55]
-    expected: FAIL
-
-  [WebGL test #56]
-    expected: FAIL
-
-  [WebGL test #57]
-    expected: FAIL
-
-  [WebGL test #58]
-    expected: FAIL
-
-  [WebGL test #59]
-    expected: FAIL
-
-  [WebGL test #6]
-    expected: FAIL
-
-  [WebGL test #60]
-    expected: FAIL
-
-  [WebGL test #7]
-    expected: FAIL
-
-  [WebGL test #8]
-    expected: FAIL
-
-  [WebGL test #9]
-    expected: FAIL
+  disabled: too many tests to cause TIMEOUT