Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

fix(canvas): implement WebGL viewport state

ldm070b4b330f61e
diff --git a/moli-cdp-smoke/README.md b/moli-cdp-smoke/README.md
index 65f076798..6ea75681f 100644
--- a/moli-cdp-smoke/README.md
+++ b/moli-cdp-smoke/README.md
@@ -145,6 +145,13 @@ workers can partition that selected list with the one-based
The current suite is a strong core smoke gate, not a complete Playwright compatibility suite.
+The default `webgl-viewport` group was calibrated on 2026-09-07 against
+Debian `/usr/bin/chromium` 145.0.7632.116. It uses the same fixture as the
+renderer tests to check WebGL1/2 on HTML and
+Offscreen canvases: viewport initialization, setter/conversion errors, copied
+Int32Array queries, context isolation, context reacquisition, resize retention,
+and clamping to the advertised maximum. It is not a GPU rendering test.
+
Covered well:
- The default raw `debugger-breakpoints`, `runtime-exception`, and
diff --git a/moli-cdp-smoke/moli_cdp_smoke/groups/webgl_viewport.py b/moli-cdp-smoke/moli_cdp_smoke/groups/webgl_viewport.py
new file mode 100644
index 000000000..82e31319a
--- /dev/null
+++ b/moli-cdp-smoke/moli_cdp_smoke/groups/webgl_viewport.py
@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from ..assertions import assert_equal, record_contract
+from ..config import REPO_ROOT
+
+
+async def run_webgl_viewport_group(
+ browser: Any, fixture: str, results: list[dict[str, Any]]
+) -> None:
+ context = await browser.new_context()
+ try:
+ page = await context.new_page()
+ await page.goto(f"{fixture}/plain", wait_until="load", timeout=10_000)
+ script = (REPO_ROOT / "moli-renderer-v8/tests/fixtures/webgl-viewport.js").read_text()
+ observed = json.loads(await page.evaluate(script))
+ assert_equal(
+ observed,
+ ["html:webgl", "offscreen:webgl", "html:webgl2", "offscreen:webgl2"],
+ "WebGL viewport state matrix",
+ )
+ record_contract(
+ results,
+ "webgl_viewport_state",
+ contract=(
+ "WebGL1/2 on HTMLCanvasElement and OffscreenCanvas preserve context-local "
+ "viewport/error state, typed copies, WebIDL conversion, limits and resize semantics. "
+ "This is a state contract, not a GPU rasterization test."
+ ),
+ source="Chromium 145.0.7632.116 executable probe (2026-09-07)",
+ commands=["Runtime.evaluate"],
+ observed=observed,
+ )
+ finally:
+ await context.close()
diff --git a/moli-cdp-smoke/moli_cdp_smoke/runner.py b/moli-cdp-smoke/moli_cdp_smoke/runner.py
index ffdca0463..69cb72239 100644
--- a/moli-cdp-smoke/moli_cdp_smoke/runner.py
+++ b/moli-cdp-smoke/moli_cdp_smoke/runner.py
@@ -63,6 +63,7 @@ from .groups.stagehand import run_stagehand_group
from .groups.target_semantics import run_target_semantics_group
from .groups.tracing import run_raw_tracing_group, run_tracing_group
from .groups.url_policy import run_url_policy_group
+from .groups.webgl_viewport import run_webgl_viewport_group
from .groups.media_error import run_media_error_group
from .groups.workers import run_workers_group
from .groups.xhr_sync_semantics import run_xhr_sync_semantics_group
@@ -338,6 +339,12 @@ PAGE_GROUPS: tuple[SmokeGroup, ...] = (
)
BROWSER_GROUPS: tuple[SmokeGroup, ...] = (
+ SmokeGroup(
+ "webgl-viewport",
+ "WebGL viewport state and HTML/OffscreenCanvas context lifetime.",
+ "browser",
+ run_webgl_viewport_group,
+ ),
SmokeGroup(
"media-error",
"HTMLMediaElement MediaError publication, identity, and reset lifecycle.",
diff --git a/moli-cdp-smoke/tests/test_group_selection.py b/moli-cdp-smoke/tests/test_group_selection.py
index 4f8b2aa97..753a5d6a9 100644
--- a/moli-cdp-smoke/tests/test_group_selection.py
+++ b/moli-cdp-smoke/tests/test_group_selection.py
@@ -32,6 +32,7 @@ class GroupSelectionTests(unittest.TestCase):
self.assertIn("inspector-routing", DEFAULT_GROUP_NAMES)
self.assertIn("navigation-outcomes", DEFAULT_GROUP_NAMES)
self.assertIn("media-error", DEFAULT_GROUP_NAMES)
+ self.assertIn("webgl-viewport", DEFAULT_GROUP_NAMES)
self.assertIn("multi-page", DEFAULT_GROUP_NAMES)
self.assertIn("puppeteer", DEFAULT_GROUP_NAMES)
self.assertEqual(
diff --git a/moli-renderer-v8/src/context_bootstrap/canvas.rs b/moli-renderer-v8/src/context_bootstrap/canvas.rs
index 640f9b392..c62d3d8f6 100644
--- a/moli-renderer-v8/src/context_bootstrap/canvas.rs
+++ b/moli-renderer-v8/src/context_bootstrap/canvas.rs
@@ -255,10 +255,11 @@ pub(crate) use webgl::{
webgl_create_framebuffer_callback, webgl_create_program_callback,
webgl_create_renderbuffer_callback, webgl_create_shader_callback,
webgl_get_attrib_location_callback, webgl_get_context_attributes_callback,
- webgl_get_extension_callback, webgl_get_parameter_callback, webgl_get_shader_info_log_callback,
- webgl_get_shader_precision_format_callback, webgl_get_supported_extensions_callback,
- webgl_is_context_lost_callback, webgl_lose_context_noop_callback, webgl_noop_callback,
- webgl_uniform_location_callback, webgl_zero_callback, webgl2_color_space_getter_callback,
+ webgl_get_error_callback, webgl_get_extension_callback, webgl_get_parameter_callback,
+ webgl_get_shader_info_log_callback, webgl_get_shader_precision_format_callback,
+ webgl_get_supported_extensions_callback, webgl_is_context_lost_callback,
+ webgl_lose_context_noop_callback, webgl_noop_callback, webgl_uniform_location_callback,
+ webgl_viewport_callback, webgl2_color_space_getter_callback,
webgl2_color_space_setter_callback, webgl2_get_extension_callback,
webgl2_get_internalformat_parameter_callback, webgl2_get_parameter_callback,
webgl2_get_supported_extensions_callback,
diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/backing_store.rs b/moli-renderer-v8/src/context_bootstrap/canvas/backing_store.rs
index 584b5086e..4f5df3000 100644
--- a/moli-renderer-v8/src/context_bootstrap/canvas/backing_store.rs
+++ b/moli-renderer-v8/src/context_bootstrap/canvas/backing_store.rs
@@ -26,6 +26,9 @@ pub(crate) fn attach_canvas_like_context_object<'s>(
canvas: v8::Local<'s, v8::Object>,
context: v8::Local<'s, v8::Object>,
) {
+ if canvas_owner_from_context(scope, context).is_none() {
+ super::webgl::initialize_attached_webgl_viewport(scope, canvas, context);
+ }
let _ = CanvasContextOwnerDeclaration::new(canvas).initialize(scope, context);
set_private_value(scope, context, CANVAS_OWNER_SLOT, canvas.into());
if get_private_value(scope, context, super::CANVAS_CONTEXT_FILL_STYLE_SLOT).is_some() {
@@ -214,7 +217,7 @@ fn remove_html_canvas_pixels<'s>(
let _ = unsafe { &mut *runtime_ptr }.remove_canvas_pixels(handle);
}
-fn canvas_like_dimensions<'s>(
+pub(super) fn canvas_like_dimensions<'s>(
scope: &mut v8::PinScope<'s, '_>,
canvas: v8::Local<'s, v8::Object>,
) -> Option<(u32, u32)> {
diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/constructors.rs b/moli-renderer-v8/src/context_bootstrap/canvas/constructors.rs
index 7fdb28594..cc9a4be6f 100644
--- a/moli-renderer-v8/src/context_bootstrap/canvas/constructors.rs
+++ b/moli-renderer-v8/src/context_bootstrap/canvas/constructors.rs
@@ -61,10 +61,11 @@ pub(crate) fn offscreen_canvas_rendering_context_2d_constructor_callback<'s>(
}
pub(crate) fn webgl_rendering_context_constructor_callback<'s>(
- _scope: &mut v8::PinScope<'s, '_>,
+ scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
+ super::webgl::init_webgl_context_object(scope, args.this());
rv.set(args.this().into());
}
diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/offscreen.rs b/moli-renderer-v8/src/context_bootstrap/canvas/offscreen.rs
index d6f2538be..fed9164f3 100644
--- a/moli-renderer-v8/src/context_bootstrap/canvas/offscreen.rs
+++ b/moli-renderer-v8/src/context_bootstrap/canvas/offscreen.rs
@@ -4,12 +4,14 @@ use super::objects::{
};
use super::*;
use crate::util::{
- callback_data_index_value, callback_data_item, get_private_value, set_private_value,
+ callback_data_index_value, callback_data_item, get_private_value, set_private_value, v8str,
};
use crate::webidl;
use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};
const OFFSCREEN_CANVAS_BRAND_SLOT: &str = "__moliOffscreenCanvasBrand";
+const OFFSCREEN_CANVAS_CONTEXT_SLOT: &str = "__moliOffscreenCanvasContext";
+const OFFSCREEN_CANVAS_CONTEXT_KIND_SLOT: &str = "__moliOffscreenCanvasContextKind";
#[derive(WebApiObject)]
#[webapi(interface = "OffscreenCanvas")]
@@ -151,22 +153,43 @@ pub(crate) fn offscreen_canvas_get_context_callback<'s>(
rv.set_null();
return;
};
- let value = (match kind {
- CanvasContextKind::TwoD => super::backing_store::canvas_2d_context(scope, args.this())
- .or_else(|| build_offscreen_2d_context_object(scope))
- .map(Into::into),
- CanvasContextKind::WebGl => build_webgl_context_object(scope).map(Into::into),
- CanvasContextKind::WebGl2 => build_webgl2_context_object(scope).map(Into::into),
- })
- .unwrap_or_else(|| v8::null(scope).into());
- if matches!(
- kind,
- CanvasContextKind::TwoD | CanvasContextKind::WebGl | CanvasContextKind::WebGl2
- ) && let Ok(context) = v8::Local::<v8::Object>::try_from(value)
- {
- attach_canvas_like_context_object(scope, args.this(), context);
+ if let Some(context) = get_private_value(scope, args.this(), OFFSCREEN_CANVAS_CONTEXT_SLOT) {
+ let same_kind = get_private_value(scope, args.this(), OFFSCREEN_CANVAS_CONTEXT_KIND_SLOT)
+ .and_then(|value| value.to_string(scope))
+ .is_some_and(|value| value.to_rust_string_lossy(scope) == kind.label());
+ if same_kind {
+ rv.set(context);
+ } else {
+ rv.set_null();
+ }
+ return;
}
- rv.set(value);
+ let context = match kind {
+ CanvasContextKind::TwoD => build_offscreen_2d_context_object(scope),
+ CanvasContextKind::WebGl => build_webgl_context_object(scope),
+ CanvasContextKind::WebGl2 => build_webgl2_context_object(scope),
+ };
+ let Some(context) = context else {
+ rv.set_null();
+ return;
+ };
+ // Reacquiring a context must retain its GL state, and an OffscreenCanvas
+ // cannot switch context modes after the first successful acquisition.
+ set_private_value(
+ scope,
+ args.this(),
+ OFFSCREEN_CANVAS_CONTEXT_SLOT,
+ context.into(),
+ );
+ let kind = v8str(scope, kind.label());
+ set_private_value(
+ scope,
+ args.this(),
+ OFFSCREEN_CANVAS_CONTEXT_KIND_SLOT,
+ kind.into(),
+ );
+ attach_canvas_like_context_object(scope, args.this(), context);
+ rv.set(context.into());
}
pub(crate) fn offscreen_canvas_convert_to_blob_callback<'s>(
diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/webgl.rs b/moli-renderer-v8/src/context_bootstrap/canvas/webgl.rs
index 0d2ec8ea0..edf430596 100644
--- a/moli-renderer-v8/src/context_bootstrap/canvas/webgl.rs
+++ b/moli-renderer-v8/src/context_bootstrap/canvas/webgl.rs
@@ -7,6 +7,11 @@ use crate::{
use moli_webapi_declare::{WebApiObject, WebApiValue};
const WEBGL_HANDLE_KIND_SLOT: &str = "__moliWebGlHandleKind";
+const WEBGL_VIEWPORT_SLOT: &str = "__moliWebGlViewport";
+const WEBGL_ERROR_SLOT: &str = "__moliWebGlError";
+const WEBGL_VIEWPORT: u32 = 0x0BA2;
+const WEBGL_INVALID_VALUE: u32 = 0x0501;
+const WEBGL_MAX_VIEWPORT_DIMS: [i32; 2] = [8192, 8192];
const WEBGL2_CONTEXT_BRAND_SLOT: &str = "__moliWebGl2ContextBrand";
const WEBGL2_DRAWING_BUFFER_COLOR_SPACE_SLOT: &str = "__moliWebGl2DrawingBufferColorSpace";
const WEBGL2_UNPACK_COLOR_SPACE_SLOT: &str = "__moliWebGl2UnpackColorSpace";
@@ -37,6 +42,28 @@ struct WebGlGetParameterArgs {
pname: u32,
}
+#[derive(webidl::WebIdlArgs)]
+#[webidl(prefix = "WebGLRenderingContext.viewport")]
+struct WebGlViewportArgs {
+ #[webidl(required)]
+ x: i32,
+ #[webidl(required)]
+ y: i32,
+ #[webidl(required)]
+ width: i32,
+ #[webidl(required)]
+ height: i32,
+}
+
+#[derive(WebApiObject)]
+#[webapi(interface = "Object")]
+struct WebGlContextStateDeclaration<'s> {
+ #[webapi(slot = WEBGL_VIEWPORT_SLOT)]
+ viewport: v8::Local<'s, v8::Array>,
+ #[webapi(slot = WEBGL_ERROR_SLOT)]
+ error: u32,
+}
+
#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "WebGL2RenderingContext.getExtension")]
struct WebGl2GetExtensionArgs {
@@ -125,6 +152,9 @@ struct WebGl2ContextObjectDeclaration {
}
pub(crate) const WEBGL_CONSTANTS: &[(&str, u32)] = &[
+ ("VIEWPORT", WEBGL_VIEWPORT),
+ ("NO_ERROR", 0),
+ ("INVALID_VALUE", WEBGL_INVALID_VALUE),
("DEPTH_TEST", 0x0B71),
("LEQUAL", 0x0203),
("COLOR_BUFFER_BIT", 0x4000),
@@ -345,13 +375,11 @@ pub(crate) fn webgl_get_parameter_callback<'s>(
return;
};
match parsed.pname {
+ WEBGL_VIEWPORT => return_webgl_viewport(scope, args.this(), &mut rv),
0x846D | 0x846E => rv.set(
webgl_array_value(scope, &[1, 1]).unwrap_or_else(|| v8::Array::new(scope, 0).into()),
),
- 0x0D3A => rv.set(
- webgl_array_value(scope, &[300, 150])
- .unwrap_or_else(|| v8::Array::new(scope, 0).into()),
- ),
+ 0x0D3A => rv.set(webgl_int32_array(scope, &WEBGL_MAX_VIEWPORT_DIMS)),
0x0D52..=0x0D55 => rv.set(v8::Integer::new(scope, 8).into()),
0x0D56 => rv.set(v8::Integer::new(scope, 24).into()),
0x0D57 => rv.set(v8::Integer::new(scope, 0).into()),
@@ -378,6 +406,7 @@ pub(crate) fn webgl2_get_parameter_callback<'s>(
return;
};
match parsed.pname {
+ WEBGL_VIEWPORT => return_webgl_viewport(scope, args.this(), &mut rv),
0x8B9B => rv.set(v8::Integer::new(scope, 0x1908).into()),
0x8B9A => rv.set(v8::Integer::new(scope, 0x1401).into()),
0x8073 => rv.set(v8::Integer::new(scope, 2048).into()),
@@ -409,7 +438,7 @@ pub(crate) fn webgl2_get_parameter_callback<'s>(
}
0x86A3 => rv.set(webgl_uint32_array(scope, &[])),
0x0D33 | 0x84E8 | 0x851C => rv.set(v8::Integer::new(scope, 8192).into()),
- 0x0D3A => rv.set(webgl_int32_array(scope, &[8192, 8192])),
+ 0x0D3A => rv.set(webgl_int32_array(scope, &WEBGL_MAX_VIEWPORT_DIMS)),
0x846D | 0x846E => rv.set(webgl_int32_array(scope, &[1, 1])),
0x0D52..=0x0D55 => rv.set(v8::Integer::new(scope, 8).into()),
0x0D56 => rv.set(v8::Integer::new(scope, 24).into()),
@@ -566,12 +595,124 @@ pub(crate) fn webgl_get_attrib_location_callback(
rv.set(v8::Integer::new(scope, 0).into());
}
-pub(crate) fn webgl_zero_callback(
- scope: &mut v8::PinScope<'_, '_>,
- _args: v8::FunctionCallbackArguments<'_>,
+pub(crate) fn webgl_get_error_callback<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- rv.set(v8::Integer::new(scope, 0).into());
+ let Some(error) = get_private_value(scope, args.this(), WEBGL_ERROR_SLOT) else {
+ throw_type_error(scope, "Illegal invocation");
+ return;
+ };
+ rv.set(error);
+ set_private_value(
+ scope,
+ args.this(),
+ WEBGL_ERROR_SLOT,
+ v8::Integer::new(scope, 0).into(),
+ );
+}
+
+pub(crate) fn webgl_viewport_callback<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
+ _rv: v8::ReturnValue<'_, v8::Value>,
+) {
+ if get_private_value(scope, args.this(), WEBGL_VIEWPORT_SLOT).is_none() {
+ throw_type_error(scope, "Illegal invocation");
+ return;
+ }
+ let Some(parsed) = webidl::parse_args::<WebGlViewportArgs>(scope, &args) else {
+ return;
+ };
+ if parsed.width < 0 || parsed.height < 0 {
+ // GL errors preserve the previous viewport and remain pending until
+ // getError consumes them. WebIDL conversion failures throw instead.
+ set_private_value(
+ scope,
+ args.this(),
+ WEBGL_ERROR_SLOT,
+ v8::Integer::new_from_unsigned(scope, WEBGL_INVALID_VALUE).into(),
+ );
+ return;
+ }
+ set_webgl_viewport(
+ scope,
+ args.this(),
+ [
+ parsed.x,
+ parsed.y,
+ parsed.width.min(WEBGL_MAX_VIEWPORT_DIMS[0]),
+ parsed.height.min(WEBGL_MAX_VIEWPORT_DIMS[1]),
+ ],
+ );
+}
+
+fn set_webgl_viewport<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ context: v8::Local<'s, v8::Object>,
+ values: [i32; 4],
+) {
+ let values = values.map(|value| v8::Integer::new(scope, value).into());
+ let viewport = v8::Array::new_with_elements(scope, &values);
+ set_private_value(scope, context, WEBGL_VIEWPORT_SLOT, viewport.into());
+}
+
+fn return_webgl_viewport<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ context: v8::Local<'s, v8::Object>,
+ rv: &mut v8::ReturnValue<'_, v8::Value>,
+) {
+ let Some(viewport) = get_private_value(scope, context, WEBGL_VIEWPORT_SLOT)
+ .and_then(|value| v8::Local::<v8::Array>::try_from(value).ok())
+ else {
+ throw_type_error(scope, "Illegal invocation");
+ return;
+ };
+ let values = [0, 1, 2, 3].map(|index| {
+ viewport
+ .get_index(scope, index)
+ .and_then(|value| value.int32_value(scope))
+ .unwrap_or_default()
+ });
+ // Each query returns a copy; mutating or detaching the result cannot
+ // change the context's GL state. This does not claim GPU raster support.
+ rv.set(webgl_int32_array(scope, &values));
+}
+
+pub(super) fn init_webgl_context_object<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ context: v8::Local<'s, v8::Object>,
+) {
+ let values = [0, 0, 300, 150].map(|value| v8::Integer::new(scope, value).into());
+ let viewport = v8::Array::new_with_elements(scope, &values);
+ WebGlContextStateDeclaration::new(viewport, 0)
+ .initialize(scope, context)
+ .expect("WebGL context state should initialize");
+}
+
+pub(super) fn initialize_attached_webgl_viewport<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ canvas: v8::Local<'s, v8::Object>,
+ context: v8::Local<'s, v8::Object>,
+) {
+ if get_private_value(scope, context, WEBGL_VIEWPORT_SLOT).is_none() {
+ return;
+ }
+ // Only context creation takes the canvas dimensions as the initial
+ // viewport. Resizing the drawing buffer must not reset viewport state.
+ if let Some((width, height)) = super::backing_store::canvas_like_dimensions(scope, canvas) {
+ set_webgl_viewport(
+ scope,
+ context,
+ [
+ 0,
+ 0,
+ width.min(WEBGL_MAX_VIEWPORT_DIMS[0] as u32) as i32,
+ height.min(WEBGL_MAX_VIEWPORT_DIMS[1] as u32) as i32,
+ ],
+ );
+ }
}
pub(crate) fn webgl_boolean_callback(
@@ -690,6 +831,7 @@ pub(super) fn init_webgl2_context_object<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
) {
+ init_webgl_context_object(scope, object);
WebGl2ContextObjectDeclaration::new("srgb".to_owned(), "srgb".to_owned())
.initialize(scope, object)
.expect("WebGL2RenderingContext declaration should initialize object");
diff --git a/moli-renderer-v8/src/context_bootstrap/media_file_template.rs b/moli-renderer-v8/src/context_bootstrap/media_file_template.rs
index 05b8973ff..72465c1a3 100644
--- a/moli-renderer-v8/src/context_bootstrap/media_file_template.rs
+++ b/moli-renderer-v8/src/context_bootstrap/media_file_template.rs
@@ -37,10 +37,11 @@ use super::canvas::{
webgl_create_framebuffer_callback, webgl_create_program_callback,
webgl_create_renderbuffer_callback, webgl_create_shader_callback,
webgl_get_attrib_location_callback, webgl_get_context_attributes_callback,
- webgl_get_extension_callback, webgl_get_parameter_callback, webgl_get_shader_info_log_callback,
- webgl_get_shader_precision_format_callback, webgl_get_supported_extensions_callback,
- webgl_is_context_lost_callback, webgl_lose_context_noop_callback, webgl_noop_callback,
- webgl_uniform_location_callback, webgl_zero_callback, webgl2_color_space_getter_callback,
+ webgl_get_error_callback, webgl_get_extension_callback, webgl_get_parameter_callback,
+ webgl_get_shader_info_log_callback, webgl_get_shader_precision_format_callback,
+ webgl_get_supported_extensions_callback, webgl_is_context_lost_callback,
+ webgl_lose_context_noop_callback, webgl_noop_callback, webgl_uniform_location_callback,
+ webgl_viewport_callback, webgl2_color_space_getter_callback,
webgl2_color_space_setter_callback, webgl2_get_extension_callback,
webgl2_get_internalformat_parameter_callback, webgl2_get_parameter_callback,
webgl2_get_supported_extensions_callback,
@@ -414,6 +415,9 @@ struct CanvasGradientTemplateMethodsDeclaration {
#[derive(WebApiFunctionTemplate)]
#[webapi(name = "WebGLRenderingContext", enumerable)]
struct WebGlRenderingContextTemplateMethodsDeclaration {
+ #[webapi(method = "viewport", length = 4, callback = webgl_viewport_callback)]
+ viewport: (),
+
#[webapi(method = "clearColor", length = 4, callback = webgl_noop_callback)]
clear_color: (),
@@ -502,7 +506,7 @@ struct WebGlRenderingContextTemplateMethodsDeclaration {
#[webapi(method = "drawArrays", length = 3, callback = webgl_noop_callback)]
draw_arrays: (),
- #[webapi(method = "getError", length = 0, callback = webgl_zero_callback)]
+ #[webapi(method = "getError", length = 0, callback = webgl_get_error_callback)]
get_error: (),
#[webapi(method = "getShaderParameter", length = 2, callback = webgl_boolean_callback)]
diff --git a/moli-renderer-v8/src/script_vm/tests/canvas_webgl.rs b/moli-renderer-v8/src/script_vm/tests/canvas_webgl.rs
index 4db630770..aeffe3b83 100644
--- a/moli-renderer-v8/src/script_vm/tests/canvas_webgl.rs
+++ b/moli-renderer-v8/src/script_vm/tests/canvas_webgl.rs
@@ -108,6 +108,18 @@ fn create_image_bitmap_matches_chromium_offscreen_canvas_and_close_contract() {
);
}
+#[test]
+fn webgl_viewport_state_matches_chromium_on_html_and_offscreen_contexts() {
+ let mut vm = new_storage_test_vm("https://webgl-viewport.test/");
+ let result = vm
+ .eval(include_str!("../../../tests/fixtures/webgl-viewport.js"))
+ .expect("WebGL viewport state matrix should pass");
+ assert_eq!(
+ result,
+ r#"["html:webgl","offscreen:webgl","html:webgl2","offscreen:webgl2"]"#
+ );
+}
+
#[test]
fn webgl_context_exposes_context_attributes_and_loss_state() {
let mut vm = new_storage_test_vm("https://webgl-surface.test/");
@@ -435,7 +447,7 @@ fn webgl_fingerprint_pipeline_methods_are_available() {
assert_eq!(
result,
- r#"{"methods":["function","function","function","function","function"],"handles":["object","object","object","object"],"attrib":0,"constants":[34962,35044,35633,35632,5],"descriptor":[34962,true,false,false],"ownerCanvas":{"same":true,"ownEnumerable":false,"dataUrl":"string","hashTail":"SuQmCC"},"parameters":{"line":[1,1],"viewport":[300,150],"redBits":8,"vendor":"","version":"WebGL 1.0","missing":null},"precision":{"precision":23,"rangeMin":127,"rangeMax":127},"shaderStatus":true,"programStatus":true,"shaderLog":"","error":0}"#
+ r#"{"methods":["function","function","function","function","function"],"handles":["object","object","object","object"],"attrib":0,"constants":[34962,35044,35633,35632,5],"descriptor":[34962,true,false,false],"ownerCanvas":{"same":true,"ownEnumerable":false,"dataUrl":"string","hashTail":"SuQmCC"},"parameters":{"line":[1,1],"viewport":[8192,8192],"redBits":8,"vendor":"","version":"WebGL 1.0","missing":null},"precision":{"precision":23,"rangeMin":127,"rangeMax":127},"shaderStatus":true,"programStatus":true,"shaderLog":"","error":0}"#
);
}
diff --git a/moli-renderer-v8/tests/fixtures/webgl-viewport.js b/moli-renderer-v8/tests/fixtures/webgl-viewport.js
new file mode 100644
index 000000000..1ae27b915
--- /dev/null
+++ b/moli-renderer-v8/tests/fixtures/webgl-viewport.js
@@ -0,0 +1,73 @@
+// Run unchanged in the renderer regression and public CDP smoke. These are
+// observable GL state contracts, not evidence of GPU-backed rendering.
+(() => {
+ const results = [];
+ for (const kind of ['webgl', 'webgl2']) {
+ for (const offscreen of [false, true]) {
+ const label = `${offscreen ? 'offscreen' : 'html'}:${kind}`;
+ const check = (condition, message) => {
+ if (!condition) throw new Error(`${label}: ${message}`);
+ };
+ const equal = (actual, expected, message) =>
+ check(JSON.stringify(actual) === JSON.stringify(expected),
+ `${message}: ${JSON.stringify(actual)} != ${JSON.stringify(expected)}`);
+ const throwsTypeError = operation => {
+ try { operation(); } catch (error) { return error instanceof TypeError; }
+ return false;
+ };
+ const canvas = offscreen ? new OffscreenCanvas(320, 180) : document.createElement('canvas');
+ canvas.width = 320;
+ canvas.height = 180;
+ const gl = canvas.getContext(kind);
+ check(gl !== null, 'context acquisition');
+ check(typeof gl.viewport === 'function' && gl.viewport.length === 4, 'viewport interface');
+ equal([gl.VIEWPORT, gl.NO_ERROR, gl.INVALID_VALUE], [2978, 0, 1281], 'constants');
+ const view = () => Array.from(gl.getParameter(gl.VIEWPORT));
+ equal(view(), [0, 0, 320, 180], 'initial canvas dimensions');
+ check(gl.getParameter(gl.VIEWPORT) instanceof Int32Array, 'query type');
+ check(gl.viewport(-5, 8, 90, 70) === undefined, 'return value');
+ equal(view(), [-5, 8, 90, 70], 'negative origins are valid');
+ const copy = gl.getParameter(gl.VIEWPORT);
+ copy.fill(123);
+ equal(view(), [-5, 8, 90, 70], 'query is a copy');
+ canvas.width = 500;
+ canvas.height = 400;
+ check(canvas.getContext(kind) === gl, 'reacquisition preserves identity');
+ equal(view(), [-5, 8, 90, 70], 'resize preserves viewport');
+ for (const other of ['2d', 'webgl', 'webgl2'].filter(value => value !== kind)) {
+ check(canvas.getContext(other) === null, 'cannot switch context mode');
+ }
+ gl.viewport(1, 2, -3, 4);
+ equal(view(), [-5, 8, 90, 70], 'invalid width preserves state');
+ gl.viewport(0, 0, 10, 20);
+ equal([gl.getError(), gl.getError()], [gl.INVALID_VALUE, gl.NO_ERROR],
+ 'valid operation does not consume a pending GL error');
+ gl.viewport(1, 2, 3, -4);
+ equal(view(), [0, 0, 10, 20], 'invalid height preserves state');
+ equal([gl.getError(), gl.getError()], [gl.INVALID_VALUE, gl.NO_ERROR], 'error consumed once');
+ gl.viewport('2.8', undefined, NaN, Infinity);
+ equal(view(), [2, 0, 0, 0], 'WebIDL long conversion and zero dimensions');
+ check(throwsTypeError(() => gl.viewport(1, 2, 3)), 'required arguments');
+ check(throwsTypeError(() => gl.viewport(Symbol(), 0, 1, 1)), 'conversion exception');
+ check(throwsTypeError(() => gl.viewport.call({}, 0, 0, 1, 1)), 'viewport receiver');
+ check(throwsTypeError(() => gl.getError.call({})), 'getError receiver');
+ equal(view(), [2, 0, 0, 0], 'WebIDL errors preserve state');
+ check(gl.getError() === gl.NO_ERROR, 'WebIDL errors are not GL errors');
+ const maximum = gl.getParameter(gl.MAX_VIEWPORT_DIMS);
+ check(maximum instanceof Int32Array && maximum.length === 2, 'maximum dimensions type');
+ gl.viewport(0, 0, 2147483647, 2147483647);
+ equal(view(), [0, 0, ...maximum], 'dimensions clamp to advertised limits');
+ const otherCanvas = offscreen ? new OffscreenCanvas(10, 20) : document.createElement('canvas');
+ const other = otherCanvas.getContext(kind);
+ gl.viewport(0, 0, -1, 1);
+ check(other.getError() === other.NO_ERROR, 'error state is context-local');
+ equal(Array.from(other.getParameter(other.VIEWPORT)),
+ offscreen ? [0, 0, 10, 20] : [0, 0, 300, 150], 'viewport state is context-local');
+ check(gl.getError() === gl.INVALID_VALUE, 'other context does not consume error');
+ check(!Object.getOwnPropertyNames(gl).some(name => name.startsWith('__moliWebGl')),
+ 'GL state stays private');
+ results.push(label);
+ }
+ }
+ return JSON.stringify(results);
+})()