Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(media): expose media loading error state

ldm0516edcff626b
diff --git a/moli-cdp-smoke/README.md b/moli-cdp-smoke/README.md
index 387cadb58..65f076798 100644
--- a/moli-cdp-smoke/README.md
+++ b/moli-cdp-smoke/README.md
@@ -368,6 +368,7 @@ Runner layout:
coordinates, exact used frame viewport propagation, and Moli's nested-frame
UA scrollbar routing boundary.
- `groups/emulation_storage.py`: viewport and Playwright screenshot-clip boundary, storage/cookie isolation, IndexedDB baseline, and browser-context profile overrides.
+- `groups/media_error.py`: process-isolated HTMLMediaElement MediaError lifecycle contracts.
- `groups/target_semantics.py`: raw Target-domain identity, attachment,
activation, visibility, and lifecycle contracts calibrated against Chromium.
- `groups/browser_semantics.py`: page/runtime cross-engine contracts calibrated
@@ -441,6 +442,7 @@ uv run moli-cdp-smoke --group agent-episode
uv run moli-cdp-smoke --group fetch-runtime-teardown
uv run moli-cdp-smoke --group network-body-cache
uv run moli-cdp-smoke --group dom-input,emulation-storage
+uv run moli-cdp-smoke --group media-error
uv run moli-cdp-smoke --group document-content
uv run moli-cdp-smoke --group dom-snapshot
uv run moli-cdp-smoke --group dom-whitespace
diff --git a/moli-cdp-smoke/moli_cdp_smoke/groups/media_error.py b/moli-cdp-smoke/moli_cdp_smoke/groups/media_error.py
new file mode 100644
index 000000000..65d38afb2
--- /dev/null
+++ b/moli-cdp-smoke/moli_cdp_smoke/groups/media_error.py
@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..assertions import SmokeError, assert_equal, record_contract
+async def run_media_error_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)
+ await page.evaluate(
+ """() => {
+ const video = document.createElement('video');
+ globalThis.__moliMediaErrorProbe = {
+ video,
+ errors: [],
+ firstError: null,
+ };
+ video.addEventListener('error', () => {
+ const error = video.error;
+ __moliMediaErrorProbe.errors.push({
+ error,
+ code: error && error.code,
+ message: error && error.message,
+ stableDuringHandler: video.error === error,
+ });
+ if (!__moliMediaErrorProbe.firstError) {
+ __moliMediaErrorProbe.firstError = error;
+ }
+ });
+ video.src = 'http://[';
+ document.body.append(video);
+ }"""
+ )
+ await page.wait_for_function(
+ "globalThis.__moliMediaErrorProbe.errors.length === 1",
+ timeout=10_000,
+ )
+ first = await page.evaluate(
+ """() => {
+ const probe = __moliMediaErrorProbe;
+ const video = probe.video;
+ const error = probe.firstError;
+ const descriptor = Object.getOwnPropertyDescriptor(
+ MediaError.prototype,
+ 'code'
+ );
+ let receiverError = null;
+ try {
+ Reflect.get(MediaError.prototype, 'code', {});
+ } catch (caught) {
+ receiverError = caught.name;
+ }
+ let constructorError = null;
+ try {
+ new MediaError();
+ } catch (caught) {
+ constructorError = caught.name;
+ }
+ return {
+ eventCount: probe.errors.length,
+ eventCode: probe.errors[0].code,
+ eventMessage: probe.errors[0].message,
+ stableDuringHandler: probe.errors[0].stableDuringHandler,
+ instance: error instanceof MediaError,
+ code: error && error.code,
+ message: error && error.message,
+ stableAfterHandler: video.error === error,
+ networkState: video.networkState,
+ readyState: video.readyState,
+ constants: [
+ MediaError.MEDIA_ERR_ABORTED,
+ MediaError.MEDIA_ERR_NETWORK,
+ MediaError.MEDIA_ERR_DECODE,
+ MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED,
+ ],
+ descriptor: [
+ typeof descriptor.get,
+ descriptor.set === undefined,
+ descriptor.enumerable,
+ descriptor.configurable,
+ ],
+ receiverError,
+ constructorError,
+ };
+ }"""
+ )
+ assert_equal(first.get("eventCount"), 1, "media error event count")
+ assert_equal(first.get("eventCode"), 4, "MediaError is visible in the error handler")
+ if not first.get("eventMessage"):
+ raise SmokeError("MediaError.message is empty in the error handler")
+ assert_equal(first.get("stableDuringHandler"), True, "MediaError handler identity")
+ assert_equal(first.get("instance"), True, "HTMLMediaElement.error brand")
+ assert_equal(first.get("code"), 4, "unsupported media source error code")
+ if not first.get("message"):
+ raise SmokeError("HTMLMediaElement.error.message is empty")
+ assert_equal(first.get("stableAfterHandler"), True, "MediaError stable getter identity")
+ assert_equal(first.get("networkState"), 3, "failed media network state")
+ assert_equal(first.get("readyState"), 0, "failed media ready state")
+ assert_equal(first.get("constants"), [1, 2, 3, 4], "MediaError constants")
+ assert_equal(
+ first.get("descriptor"),
+ ["function", True, True, True],
+ "MediaError.code readonly Web IDL descriptor",
+ )
+ assert_equal(first.get("receiverError"), "TypeError", "MediaError receiver brand check")
+ assert_equal(first.get("constructorError"), "TypeError", "MediaError illegal constructor")
+
+ cleared = await page.evaluate(
+ """() => {
+ const probe = __moliMediaErrorProbe;
+ probe.video.load();
+ return probe.video.error === null;
+ }"""
+ )
+ assert_equal(cleared, True, "HTMLMediaElement.load clears MediaError synchronously")
+ await page.wait_for_function(
+ "globalThis.__moliMediaErrorProbe.errors.length === 2",
+ timeout=10_000,
+ )
+ reloaded = await page.evaluate(
+ """() => {
+ const probe = __moliMediaErrorProbe;
+ const second = probe.video.error;
+ const result = {
+ eventCount: probe.errors.length,
+ code: second && second.code,
+ newIdentity: second !== probe.firstError,
+ stableIdentity: second === probe.video.error,
+ };
+ probe.video.removeAttribute('src');
+ probe.video.load();
+ result.clearedWithoutSource = probe.video.error === null;
+ return result;
+ }"""
+ )
+ assert_equal(
+ reloaded,
+ {
+ "eventCount": 2,
+ "code": 4,
+ "newIdentity": True,
+ "stableIdentity": True,
+ "clearedWithoutSource": True,
+ },
+ "MediaError clear and repeated-failure lifecycle",
+ )
+ record_contract(
+ results,
+ "media_error_failure_lifecycle",
+ contract=(
+ "A terminal unsupported-source failure publishes a stable MediaError "
+ "before the error event, load() clears it synchronously, and a later "
+ "failure creates a fresh error object."
+ ),
+ source="Debian Chromium 145 executable oracle and HTML media element lifecycle",
+ commands=["Runtime.evaluate"],
+ observed={"first": first, "reloaded": reloaded},
+ )
+ 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 ce29909d6..ffdca0463 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.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
from .helpers import attach_cdp_event_collector
@@ -337,9 +338,15 @@ PAGE_GROUPS: tuple[SmokeGroup, ...] = (
)
BROWSER_GROUPS: tuple[SmokeGroup, ...] = (
+ SmokeGroup(
+ "media-error",
+ "HTMLMediaElement MediaError publication, identity, and reset lifecycle.",
+ "browser",
+ run_media_error_group,
+ ),
SmokeGroup(
"emulation-storage",
- "Playwright screenshot-clip boundary, viewport, storage/cookie isolation, IndexedDB, and profile overrides.",
+ "Viewport, storage, profile, and detailed locale/timezone override contracts.",
"browser",
run_emulation_storage_group,
),
diff --git a/moli-cdp-smoke/tests/test_group_selection.py b/moli-cdp-smoke/tests/test_group_selection.py
index a44597539..4f8b2aa97 100644
--- a/moli-cdp-smoke/tests/test_group_selection.py
+++ b/moli-cdp-smoke/tests/test_group_selection.py
@@ -31,6 +31,7 @@ class GroupSelectionTests(unittest.TestCase):
self.assertIn("file-chooser", DEFAULT_GROUP_NAMES)
self.assertIn("inspector-routing", DEFAULT_GROUP_NAMES)
self.assertIn("navigation-outcomes", DEFAULT_GROUP_NAMES)
+ self.assertIn("media-error", DEFAULT_GROUP_NAMES)
self.assertIn("multi-page", DEFAULT_GROUP_NAMES)
self.assertIn("puppeteer", DEFAULT_GROUP_NAMES)
self.assertEqual(
diff --git a/moli-dom/src/native/element/control_state.rs b/moli-dom/src/native/element/control_state.rs
index b9b4faaf7..136c0ed0c 100644
--- a/moli-dom/src/native/element/control_state.rs
+++ b/moli-dom/src/native/element/control_state.rs
@@ -153,6 +153,7 @@ pub struct ElementControlState {
media_current_time: Option<f64>,
media_ready_state: Option<u32>,
media_network_state: Option<u32>,
+ media_error_code: Option<u32>,
image_load_dispatched: bool,
cryptographic_nonce: Option<String>,
scroll_top: Option<f64>,
@@ -229,6 +230,7 @@ impl ElementControlState {
state.media_current_time = Some(0.0);
state.media_ready_state = Some(0);
state.media_network_state = Some(0);
+ state.media_error_code = None;
}
Some(state)
@@ -373,6 +375,10 @@ impl ElementControlState {
self.media_network_state
}
+ pub fn media_error_code(&self) -> Option<u32> {
+ self.media_error_code
+ }
+
pub fn scroll_top(&self) -> Option<f64> {
self.scroll_top
}
@@ -724,6 +730,14 @@ impl ElementControlState {
true
}
+ pub fn set_media_error_code(&mut self, error_code: Option<u32>) -> bool {
+ if self.media_error_code == error_code {
+ return false;
+ }
+ self.media_error_code = error_code;
+ true
+ }
+
pub fn set_image_load_dispatched(&mut self, dispatched: bool) -> bool {
if self.image_load_dispatched == dispatched {
return false;
diff --git a/moli-dom/src/native/element/mod.rs b/moli-dom/src/native/element/mod.rs
index 4057d9d60..18ab41dbb 100644
--- a/moli-dom/src/native/element/mod.rs
+++ b/moli-dom/src/native/element/mod.rs
@@ -912,6 +912,10 @@ impl Element {
self.control_state().media_network_state().unwrap_or(0)
}
+ pub fn media_error_code(&self) -> Option<u32> {
+ self.control_state().media_error_code()
+ }
+
pub fn scroll_top(&self) -> f64 {
self.control_state().scroll_top().unwrap_or(0.0)
}
@@ -1035,6 +1039,13 @@ impl Element {
.set_media_network_state(network_state)
}
+ pub fn set_media_error_code(&mut self, error_code: Option<u32>) -> bool {
+ if !self.is_html_media() {
+ return false;
+ }
+ self.control_state_mut().set_media_error_code(error_code)
+ }
+
pub fn option_value(&self, dom: &NativeDom, handle: NativeNodeId) -> String {
self.attribute_ns("", "value")
.map(str::to_owned)
diff --git a/moli-dom/src/native/host/clone.rs b/moli-dom/src/native/host/clone.rs
index ba22d330e..a8ea7e7af 100644
--- a/moli-dom/src/native/host/clone.rs
+++ b/moli-dom/src/native/host/clone.rs
@@ -579,6 +579,7 @@ impl DomHost {
let _ = clone_element.set_media_ready_state(element.media_ready_state());
let _ = clone_element.set_media_network_state(u32::MAX);
let _ = clone_element.set_media_network_state(element.media_network_state());
+ let _ = clone_element.set_media_error_code(element.media_error_code());
}
}
diff --git a/moli-dom/src/native/host/mutation/state.rs b/moli-dom/src/native/host/mutation/state.rs
index a6d65adbd..96fc0a11e 100644
--- a/moli-dom/src/native/host/mutation/state.rs
+++ b/moli-dom/src/native/host/mutation/state.rs
@@ -517,6 +517,22 @@ impl DomHost {
did_change
}
+ pub fn set_media_error_code(&mut self, handle: DomHandle, error_code: Option<u32>) -> bool {
+ let did_change = {
+ let Some(element) = self
+ .node_mut(handle)
+ .and_then(|node| node.data_mut().as_element_mut())
+ else {
+ return false;
+ };
+ element.set_media_error_code(error_code)
+ };
+ if did_change {
+ self.record_mutation(MutationScope::LocalState);
+ }
+ did_change
+ }
+
pub fn set_checked_state(&mut self, handle: DomHandle, checked: bool) -> bool {
!self
.set_checked_state_changed_handles(handle, checked)
diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs
index 8849bcc90..ebac85fd2 100644
--- a/moli-renderer-v8/src/context_bootstrap.rs
+++ b/moli-renderer-v8/src/context_bootstrap.rs
@@ -39,6 +39,7 @@ mod location_history_storage;
mod location_navigation;
mod location_runtime;
mod media_cues;
+pub(crate) use media_cues::new_media_error_value;
mod media_file_template;
mod media_queries;
mod media_source;
diff --git a/moli-renderer-v8/src/context_bootstrap/media_cues.rs b/moli-renderer-v8/src/context_bootstrap/media_cues.rs
index 813c71117..a678c3d54 100644
--- a/moli-renderer-v8/src/context_bootstrap/media_cues.rs
+++ b/moli-renderer-v8/src/context_bootstrap/media_cues.rs
@@ -22,6 +22,8 @@ const TEXT_TRACK_CUE_ALIGN_SLOT: &str = "__moliTextTrackCueAlign";
const TEXT_TRACK_CUE_ONENTER_SLOT: &str = "__moliTextTrackCueOnEnter";
const TEXT_TRACK_CUE_ONEXIT_SLOT: &str = "__moliTextTrackCueOnExit";
const TEXT_TRACK_CUE_TEXT_SLOT: &str = "__moliTextTrackCueText";
+const MEDIA_ERROR_CODE_SLOT: &str = "__moliMediaErrorCode";
+const MEDIA_ERROR_MESSAGE_SLOT: &str = "__moliMediaErrorMessage";
#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "VTTCue")]
@@ -203,6 +205,75 @@ struct MediaErrorConstantsDeclaration {
media_err_src_not_supported: (),
}
+#[derive(WebApiFunctionTemplate)]
+#[webapi(name = "MediaError", enumerable)]
+struct MediaErrorPrototypeDeclaration {
+ #[webapi(
+ accessor_property,
+ getter = media_error_code_getter_callback,
+ enumerable
+ )]
+ code: (),
+ #[webapi(
+ accessor_property,
+ getter = media_error_message_getter_callback,
+ enumerable
+ )]
+ message: (),
+}
+
+fn media_error_code_getter_callback<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
+ mut rv: v8::ReturnValue<'s, v8::Value>,
+) {
+ let Some(code) = get_private_value(scope, args.this(), MEDIA_ERROR_CODE_SLOT) else {
+ throw_type_error(scope, "Illegal invocation");
+ return;
+ };
+ rv.set(code);
+}
+
+fn media_error_message_getter_callback<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
+ mut rv: v8::ReturnValue<'s, v8::Value>,
+) {
+ let Some(message) = get_private_value(scope, args.this(), MEDIA_ERROR_MESSAGE_SLOT) else {
+ throw_type_error(scope, "Illegal invocation");
+ return;
+ };
+ rv.set(message);
+}
+
+pub(crate) fn new_media_error_value<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ code: u32,
+ message: &str,
+) -> Option<v8::Local<'s, v8::Object>> {
+ let global = scope.get_current_context().global(scope);
+ let constructor = global.get(scope, v8str(scope, "MediaError").into())?;
+ let constructor = v8::Local::<v8::Object>::try_from(constructor).ok()?;
+ let prototype = constructor.get(scope, v8str(scope, "prototype").into())?;
+ let object = v8::Object::new(scope);
+ if object.set_prototype(scope, prototype) != Some(true) {
+ return None;
+ }
+ set_private_value(
+ scope,
+ object,
+ MEDIA_ERROR_CODE_SLOT,
+ v8::Integer::new_from_unsigned(scope, code).into(),
+ );
+ set_private_value(
+ scope,
+ object,
+ MEDIA_ERROR_MESSAGE_SLOT,
+ v8_string(scope, message)?.into(),
+ );
+ Some(object)
+}
+
pub(super) fn text_track_cue_constructor_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
_args: v8::FunctionCallbackArguments<'s>,
@@ -1091,6 +1162,7 @@ pub(super) fn install_media_cue_template_bindings<'s>(
"MediaError" => {
MediaErrorConstantsDeclaration::initialize_template(scope, template);
MediaErrorConstantsDeclaration::initialize_prototype_template(scope, prototype);
+ MediaErrorPrototypeDeclaration::initialize_prototype_template(scope, prototype);
}
"TextTrackCue" => {
TextTrackCueTemplateDeclaration::initialize_prototype_template(scope, prototype)
diff --git a/moli-renderer-v8/src/document_runtime/mutation_commands.rs b/moli-renderer-v8/src/document_runtime/mutation_commands.rs
index c2168c36f..394a118bf 100644
--- a/moli-renderer-v8/src/document_runtime/mutation_commands.rs
+++ b/moli-renderer-v8/src/document_runtime/mutation_commands.rs
@@ -1515,6 +1515,14 @@ impl DocumentRuntime {
self.dom_host.set_media_network_state(handle, network_state)
}
+ pub(crate) fn set_media_error_code(
+ &mut self,
+ handle: DomHandle,
+ error_code: Option<u32>,
+ ) -> bool {
+ self.dom_host.set_media_error_code(handle, error_code)
+ }
+
pub(crate) fn set_checked_state_with_old_states(
&mut self,
scope: &mut v8::PinScope<'_, '_>,
diff --git a/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs b/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs
index 7e107a6e5..0c35bde13 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs
@@ -2002,6 +2002,14 @@ impl JsContextHost {
changed
}
+ pub(crate) fn set_media_error_code(
+ &mut self,
+ handle: DomHandle,
+ error_code: Option<u32>,
+ ) -> bool {
+ unsafe { DocumentRuntime::set_media_error_code(&mut *self.runtime, handle, error_code) }
+ }
+
pub(crate) fn set_media_muted(&mut self, handle: DomHandle, muted: bool) -> bool {
let old_state = self.retained_current_element_state(handle);
let changed =
diff --git a/moli-renderer-v8/src/native_bridge/element.rs b/moli-renderer-v8/src/native_bridge/element.rs
index def2520ee..fd8b134c1 100644
--- a/moli-renderer-v8/src/native_bridge/element.rs
+++ b/moli-renderer-v8/src/native_bridge/element.rs
@@ -533,12 +533,12 @@ pub(super) use media::{
media_cross_origin_getter_function, media_cross_origin_setter_function,
media_current_time_getter_function, media_current_time_setter_function,
media_default_muted_getter_function, media_default_muted_setter_function,
- media_duration_getter_function, media_ended_getter_function, media_height_getter_function,
- media_height_setter_function, media_load_callback, media_loading_getter_function,
- media_loading_setter_function, media_loop_getter_function, media_loop_setter_function,
- media_muted_getter_function, media_muted_setter_function, media_network_state_getter_function,
- media_pause_callback, media_paused_getter_function, media_play_callback,
- media_playback_rate_getter_function, media_playback_rate_setter_function,
+ media_duration_getter_function, media_ended_getter_function, media_error_getter_function,
+ media_height_getter_function, media_height_setter_function, media_load_callback,
+ media_loading_getter_function, media_loading_setter_function, media_loop_getter_function,
+ media_loop_setter_function, media_muted_getter_function, media_muted_setter_function,
+ media_network_state_getter_function, media_pause_callback, media_paused_getter_function,
+ media_play_callback, media_playback_rate_getter_function, media_playback_rate_setter_function,
media_plays_inline_getter_function, media_plays_inline_setter_function,
media_poster_getter_function, media_poster_setter_function, media_preload_getter_function,
media_preload_setter_function, media_ready_state_getter_function,
@@ -5234,6 +5234,8 @@ struct HtmlHtmlElementPrototypeDeclaration {
#[derive(WebApiFunctionTemplate)]
#[webapi(name = "HTMLMediaElement", enumerable)]
struct HtmlMediaElementPrototypeDeclaration {
+ #[webapi(accessor_property, getter = media_error_getter_function)]
+ error: (),
#[webapi(
accessor_property = "crossOrigin",
getter = media_cross_origin_getter_function,
diff --git a/moli-renderer-v8/src/native_bridge/element/media.rs b/moli-renderer-v8/src/native_bridge/element/media.rs
index 4a45e266d..b1b6aa1eb 100644
--- a/moli-renderer-v8/src/native_bridge/element/media.rs
+++ b/moli-renderer-v8/src/native_bridge/element/media.rs
@@ -25,11 +25,11 @@ pub(in crate::native_bridge) use methods::{
pub(crate) use state::{dispatch_media_seek_completion, dispatch_media_seeking_event};
pub(in crate::native_bridge) use state::{
media_current_time_getter_function, media_current_time_setter_function,
- media_duration_getter_function, media_ended_getter_function, media_muted_getter_function,
- media_muted_setter_function, media_network_state_getter_function, media_paused_getter_function,
- media_playback_rate_getter_function, media_playback_rate_setter_function,
- media_ready_state_getter_function, media_seeking_getter_function, media_volume_getter_function,
- media_volume_setter_function,
+ media_duration_getter_function, media_ended_getter_function, media_error_getter_function,
+ media_muted_getter_function, media_muted_setter_function, media_network_state_getter_function,
+ media_paused_getter_function, media_playback_rate_getter_function,
+ media_playback_rate_setter_function, media_ready_state_getter_function,
+ media_seeking_getter_function, media_volume_getter_function, media_volume_setter_function,
};
pub(crate) use text_tracks::{
apply_default_text_track_mode_for_track, apply_text_track_load_task,
diff --git a/moli-renderer-v8/src/native_bridge/element/media/attributes.rs b/moli-renderer-v8/src/native_bridge/element/media/attributes.rs
index 2841fa136..3e22fb2ce 100644
--- a/moli-renderer-v8/src/native_bridge/element/media/attributes.rs
+++ b/moli-renderer-v8/src/native_bridge/element/media/attributes.rs
@@ -458,6 +458,7 @@ fn start_media_load(
};
super::apply_default_text_track_modes_for_media(scope, runtime_ptr, handle);
super::queue_media_selection_text_track_loads(scope, runtime_ptr, handle, pending.id());
+ let _ = unsafe { &mut *runtime_ptr }.set_media_error_code(handle, None);
let _ = unsafe { &mut *runtime_ptr }.set_media_ready_state(handle, 0);
let _ = unsafe { &mut *runtime_ptr }.set_media_network_state(handle, 2);
if !queue_media_load_event_phase(
@@ -619,6 +620,7 @@ pub(crate) fn dispatch_media_load_event_phase(
let _ = unsafe { &mut *runtime_ptr }.set_media_network_state(handle, 1);
}
MediaLoadEventPhase::Error => {
+ let _ = unsafe { &mut *runtime_ptr }.set_media_error_code(handle, Some(4));
let _ = unsafe { &mut *runtime_ptr }.set_media_ready_state(handle, 0);
let _ = unsafe { &mut *runtime_ptr }.set_media_network_state(handle, 3);
}
diff --git a/moli-renderer-v8/src/native_bridge/element/media/methods.rs b/moli-renderer-v8/src/native_bridge/element/media/methods.rs
index 2d9c12965..d899bf5ac 100644
--- a/moli-renderer-v8/src/native_bridge/element/media/methods.rs
+++ b/moli-renderer-v8/src/native_bridge/element/media/methods.rs
@@ -83,12 +83,18 @@ pub(in crate::native_bridge) fn media_load_callback<'s>(
};
let runtime = unsafe { &mut *runtime_ptr };
let _ = runtime.cancel_pending_media_load_sequence(handle);
+ let error_changed = runtime.set_media_error_code(handle, None);
let paused_changed = runtime.set_media_paused(handle, true);
let time_changed = runtime.set_media_current_time(handle, 0.0);
let seeking_changed = runtime.set_media_seeking(handle, false);
let ready_changed = runtime.set_media_ready_state(handle, 0);
let network_changed = runtime.set_media_network_state(handle, 0);
- if (paused_changed || time_changed || seeking_changed || ready_changed || network_changed)
+ if (error_changed
+ || paused_changed
+ || time_changed
+ || seeking_changed
+ || ready_changed
+ || network_changed)
&& let Some(event) = construct_simple_event(scope, "emptied", false, false, false)
{
let _ = dispatch_public_event(scope, runtime_ptr, handle, event);
diff --git a/moli-renderer-v8/src/native_bridge/element/media/state.rs b/moli-renderer-v8/src/native_bridge/element/media/state.rs
index bf77c557c..998bbc79f 100644
--- a/moli-renderer-v8/src/native_bridge/element/media/state.rs
+++ b/moli-renderer-v8/src/native_bridge/element/media/state.rs
@@ -1,7 +1,11 @@
use crate::document_runtime::DomHandle;
use crate::dom::native::{Element, Node};
+use crate::util::{get_private_value, set_private_value};
use crate::webidl;
+const MEDIA_ERROR_OBJECT_SLOT: &str = "__moliMediaElementErrorObject";
+const MEDIA_ERROR_OBJECT_CODE_SLOT: &str = "__moliMediaElementErrorObjectCode";
+
use super::super::{
dispatch_text_control_event, html_media_element_getter_receiver,
html_media_element_setter_receiver, refresh_media_active_text_track_cues,
@@ -26,6 +30,68 @@ pub(in crate::native_bridge) fn media_paused_getter_function<'s>(
rv.set_bool(paused);
}
+pub(in crate::native_bridge) fn media_error_getter_function<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
+ mut rv: v8::ReturnValue<'s, v8::Value>,
+) {
+ let Some((runtime_ptr, handle)) =
+ html_media_element_getter_receiver(scope, args.this(), "error")
+ else {
+ rv.set_null();
+ return;
+ };
+ let error_code = unsafe { &*runtime_ptr }
+ .dom_host()
+ .node(handle)
+ .and_then(Node::as_element)
+ .and_then(Element::media_error_code);
+ let Some(error_code) = error_code else {
+ set_private_value(
+ scope,
+ args.this(),
+ MEDIA_ERROR_OBJECT_SLOT,
+ v8::undefined(scope).into(),
+ );
+ set_private_value(
+ scope,
+ args.this(),
+ MEDIA_ERROR_OBJECT_CODE_SLOT,
+ v8::undefined(scope).into(),
+ );
+ rv.set_null();
+ return;
+ };
+ let cached_code = get_private_value(scope, args.this(), MEDIA_ERROR_OBJECT_CODE_SLOT)
+ .and_then(|value| value.uint32_value(scope));
+ if cached_code == Some(error_code)
+ && let Some(error) = get_private_value(scope, args.this(), MEDIA_ERROR_OBJECT_SLOT)
+ && !error.is_undefined()
+ {
+ rv.set(error);
+ return;
+ }
+ let message = match error_code {
+ 1 => "The fetching process for the media resource was aborted by the user agent.",
+ 2 => "A network error prevented the media resource from being fetched.",
+ 3 => "An error occurred while decoding the media resource.",
+ _ => "The media resource could not be loaded because its format is not supported.",
+ };
+ let Some(error) = crate::context_bootstrap::new_media_error_value(scope, error_code, message)
+ else {
+ rv.set_null();
+ return;
+ };
+ set_private_value(scope, args.this(), MEDIA_ERROR_OBJECT_SLOT, error.into());
+ set_private_value(
+ scope,
+ args.this(),
+ MEDIA_ERROR_OBJECT_CODE_SLOT,
+ v8::Integer::new_from_unsigned(scope, error_code).into(),
+ );
+ rv.set(error.into());
+}
+
pub(in crate::native_bridge) fn media_volume_getter_function<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/media.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/media.rs
index 30ae07a0f..b11a60c0f 100644
--- a/moli-renderer-v8/src/script_vm/tests/browser_api/media.rs
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/media.rs
@@ -196,16 +196,50 @@ async fn media_invalid_request_url_fails_before_load() {
run_next_page_media_element_event_for_test(&mut vm, &loader, "invalid-URL media error turn")
.await;
+ assert_eq!(
+ vm.eval(
+ r#"(() => {
+ const firstError = __lmMediaInvalidUrlVideo.error;
+ globalThis.__lmMediaInvalidUrlFirstError = firstError;
+ const result = [
+ __lmMediaInvalidUrlEvents.join("|"),
+ __lmMediaInvalidUrlVideo.readyState,
+ __lmMediaInvalidUrlVideo.networkState,
+ firstError instanceof MediaError,
+ firstError && firstError.code,
+ firstError && firstError.message.length > 0,
+ __lmMediaInvalidUrlVideo.error === firstError
+ ].join("|");
+ __lmMediaInvalidUrlVideo.load();
+ return `${result}|${__lmMediaInvalidUrlVideo.error === null}`;
+})()"#,
+ )
+ .expect("invalid media URL events should evaluate"),
+ "error|0|3|true|4|true|true|true"
+ );
+
+ run_next_page_media_element_event_for_test(
+ &mut vm,
+ &loader,
+ "reloaded invalid-URL media loadstart turn",
+ )
+ .await;
+ run_next_page_media_element_event_for_test(
+ &mut vm,
+ &loader,
+ "reloaded invalid-URL media error turn",
+ )
+ .await;
assert_eq!(
vm.eval(
r#"[
- __lmMediaInvalidUrlEvents.join("|"),
- __lmMediaInvalidUrlVideo.readyState,
- __lmMediaInvalidUrlVideo.networkState
+ __lmMediaInvalidUrlVideo.error instanceof MediaError,
+ __lmMediaInvalidUrlVideo.error.code,
+ __lmMediaInvalidUrlVideo.error !== __lmMediaInvalidUrlFirstError
].join("|")"#,
)
- .expect("invalid media URL events should evaluate"),
- "error|0|3"
+ .expect("reloaded invalid media URL error should evaluate"),
+ "true|4|true"
);
}
@@ -892,6 +926,39 @@ fn media_error_constants_are_declared_on_constructor_and_prototype() {
);
}
+#[test]
+fn media_error_instance_attributes_are_readonly_prototype_accessors() {
+ let mut vm = new_storage_test_vm("https://media-error-attributes-declared.test/");
+
+ let result = vm
+ .eval(
+ r#"
+(() => {
+ const shape = name => {
+ const descriptor = Object.getOwnPropertyDescriptor(MediaError.prototype, name);
+ return [
+ typeof descriptor.get,
+ descriptor.set === undefined,
+ descriptor.enumerable,
+ descriptor.configurable
+ ].join(":");
+ };
+ let codeBrand;
+ let messageBrand;
+ try { Reflect.get(MediaError.prototype, "code", {}); } catch (error) { codeBrand = error.name; }
+ try { Reflect.get(MediaError.prototype, "message", {}); } catch (error) { messageBrand = error.name; }
+ return [shape("code"), shape("message"), codeBrand, messageBrand].join("|");
+})()
+"#,
+ )
+ .expect("MediaError attribute descriptor probe should evaluate");
+
+ assert_eq!(
+ result,
+ "function:true:true:true|function:true:true:true|TypeError|TypeError"
+ );
+}
+
#[test]
fn html_track_element_constants_are_declared_on_constructor_and_prototype() {
let mut vm = new_storage_test_vm("https://html-track-constants-declared.test/");