Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
fix(canvas): implement WebGL viewport state
ldm070b4b330f61e
diff --git a/moli-cdp-smoke/README.md b/moli-cdp-smoke/README.mdindex 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-basedThe 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`, anddiff --git a/moli-cdp-smoke/moli_cdp_smoke/groups/webgl_viewport.py b/moli-cdp-smoke/moli_cdp_smoke/groups/webgl_viewport.pynew file mode 100644index 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.pyindex 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_groupfrom .groups.target_semantics import run_target_semantics_groupfrom .groups.tracing import run_raw_tracing_group, run_tracing_groupfrom .groups.url_policy import run_url_policy_group+from .groups.webgl_viewport import run_webgl_viewport_groupfrom .groups.media_error import run_media_error_groupfrom .groups.workers import run_workers_groupfrom .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.pyindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.jsnew file mode 100644index 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);+})()