Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
use crate::web_api_interfaces;
use std::{
cell::{Cell, RefCell},
pin::pin,
rc::Rc,
};
use tokio::sync::mpsc;
use moli_webapi_declare::WebApiObject;
use crate::context_bootstrap::{
EVENT_STOP_IMMEDIATE_PROPAGATION_SLOT, EVENT_STOP_PROPAGATION_SLOT,
dispatch_message_port_events_for_port_collecting_errors,
dispatch_service_worker_controller_change, ensure_message_port_wrapper_for_id,
mark_event_trusted, runtime_message_allowed_for_current_target, set_event_internal_flag,
structured_deserialize_value_for_message_event,
};
use crate::exception_reporting::{V8ExceptionReport, log_unhandled_promise_rejection};
use crate::network_host::{
MaterializedResponseBody, MaterializedResponseHead,
build_navigation_preload_response_object_from_stream_for_request_mode,
close_pending_network_body_stream, enqueue_pending_network_body_chunk,
error_pending_network_body_stream_with_reason, materialize_response_object_body,
materialize_response_object_body_with_chunk_callback,
materialize_response_object_head_for_service_worker_respond_with,
materialized_body_bytes_from_value, new_network_body_source_id,
set_request_destination_for_service_worker_fetch_event,
set_request_mode_for_service_worker_fetch_event,
set_request_reload_navigation_for_service_worker_fetch_event,
};
use crate::runtime::{
MaterializedServiceWorkerFetchResponseHead, ServiceWorkerEventId, ServiceWorkerFetchCompletion,
ServiceWorkerFetchEvent, ServiceWorkerFetchResponse, ServiceWorkerFetchResult,
ServiceWorkerFetchStreamChunk, ServiceWorkerFetchStreamStarted,
ServiceWorkerLifecycleCompletion, ServiceWorkerLifecycleEvent, ServiceWorkerLifecycleEventKind,
ServiceWorkerMessageCompletion, ServiceWorkerMessageEvent,
ServiceWorkerNavigationPreloadFailure, ServiceWorkerNavigationPreloadResponseStarted,
ServiceWorkerNavigationPreloadStreamChunk, ServiceWorkerNavigationPreloadStreamFinished,
ServiceWorkerNotificationCompletion, ServiceWorkerNotificationEvent,
ServiceWorkerPeriodicSyncCompletion, ServiceWorkerPeriodicSyncEvent,
ServiceWorkerPushCompletion, ServiceWorkerPushEvent, ServiceWorkerSyncCompletion,
ServiceWorkerSyncEvent, service_worker_exposed_client_id,
};
use crate::structured_clone::V8StructuredClonePayload;
use crate::types::{BroadcastChannelId, MessagePortId, NetworkBodySourceId};
use crate::util::{
get_private_value, serialize_v8_array, set_private_value, throw_type_error, v8str,
};
use crate::webidl::v8_string;
use crate::worker::abort::{
abort_worker_signal_by_id, worker_abort_error_value, worker_abort_signal_id,
};
use tracing::trace;
use super::super::global_scope::{
PendingServiceWorkerFetchEvent, PendingServiceWorkerLifecycleEvent,
PendingServiceWorkerMessageEvent, PendingServiceWorkerNavigationPreload,
PendingServiceWorkerNotificationEvent, PendingServiceWorkerPeriodicSyncEvent,
PendingServiceWorkerPushEvent, PendingServiceWorkerSyncEvent, WORKER_EXCEPTION_COLUMN_SLOT,
WORKER_EXCEPTION_LINE_SLOT, WORKER_EXCEPTION_SOURCE_SLOT, get_worker_state,
register_shared_worker_connection_port, worker_exception_report_target,
};
use super::super::handle::{
WorkerErrorPhase, WorkerErrorSource, WorkerMessage, WorkerParentErrorEventKind,
WorkerToParentMessage,
};
use super::super::timer_callback::WorkerTimerCallbackOutcome;
use super::ActiveTimer;
const SERVICE_WORKER_LIFECYCLE_EVENT_ID_SLOT: &str = "__lmServiceWorkerLifecycleEventId";
const SERVICE_WORKER_FETCH_EVENT_ID_SLOT: &str = "__lmServiceWorkerFetchEventId";
const SERVICE_WORKER_MESSAGE_EVENT_ID_SLOT: &str = "__lmServiceWorkerMessageEventId";
const SERVICE_WORKER_NOTIFICATION_EVENT_ID_SLOT: &str = "__lmServiceWorkerNotificationEventId";
const SERVICE_WORKER_PUSH_EVENT_ID_SLOT: &str = "__lmServiceWorkerPushEventId";
const SERVICE_WORKER_PUSH_MESSAGE_DATA_BYTES_SLOT: &str = "__lmServiceWorkerPushMessageDataBytes";
const SERVICE_WORKER_SYNC_EVENT_ID_SLOT: &str = "__lmServiceWorkerSyncEventId";
const SERVICE_WORKER_PERIODIC_SYNC_EVENT_ID_SLOT: &str = "__lmServiceWorkerPeriodicSyncEventId";
// Retain enough reported rejections to populate `rejectionhandled.reason`
// without letting long-lived workers accumulate unbounded promise state.
const MAX_REPORTED_WORKER_PROMISE_REJECTIONS: usize = 1024;
#[derive(WebApiObject)]
#[webapi(plain)]
struct WorkerPromiseRejectionEventInitDeclaration<'scope> {
#[webapi(data_property, enumerable)]
cancelable: bool,
#[webapi(data_property, enumerable)]
promise: v8::Local<'scope, v8::Promise>,
#[webapi(data_property, enumerable)]
reason: v8::Local<'scope, v8::Value>,
}
#[derive(WebApiObject)]
#[webapi(interface = web_api_interfaces::PromiseRejectionEvent, prototype = "Object")]
struct WorkerPromiseRejectionEventFallbackDeclaration<'scope> {
#[webapi(data_property, enumerable)]
promise: v8::Local<'scope, v8::Promise>,
#[webapi(data_property, enumerable)]
reason: v8::Local<'scope, v8::Value>,
}
#[derive(WebApiObject)]
#[webapi(interface = web_api_interfaces::Event, prototype = "Object")]
struct WorkerBasicEventDeclaration<'scope> {
#[webapi(data_property, enumerable)]
r#type: v8::Local<'scope, v8::String>,
#[webapi(data_property, enumerable, constructor_default = false)]
default_prevented: bool,
#[webapi(method, enumerable, callback = worker_event_prevent_default_callback)]
prevent_default: (),
}
#[derive(WebApiObject)]
#[webapi(interface = web_api_interfaces::ExtendableEvent, prototype = "Object",)]
struct ServiceWorkerLifecycleEventDeclaration<'scope> {
#[webapi(data_property, enumerable)]
r#type: v8::Local<'scope, v8::String>,
#[webapi(data_property, enumerable)]
default_prevented: bool,
#[webapi(method, enumerable, callback = worker_event_prevent_default_callback)]
prevent_default: (),
#[webapi(method, enumerable, callback = service_worker_wait_until_callback)]
wait_until: (),
}
#[derive(WebApiObject)]
#[webapi(
interface = web_api_interfaces::FetchEvent,
prototype = "Object",)]
struct ServiceWorkerFetchEventDeclaration<'scope> {
#[webapi(data_property, enumerable)]
r#type: v8::Local<'scope, v8::String>,
#[webapi(data_property, enumerable)]
default_prevented: bool,
#[webapi(data_property, enumerable)]
handled: v8::Local<'scope, v8::Promise>,
#[webapi(data_property, enumerable)]
preload_response: v8::Local<'scope, v8::Promise>,
#[webapi(data_property, enumerable)]
request: v8::Local<'scope, v8::Object>,
#[webapi(data_property, enumerable)]
client_id: v8::Local<'scope, v8::String>,
#[webapi(data_property, enumerable)]
resulting_client_id: v8::Local<'scope, v8::String>,
#[webapi(data_property, enumerable)]
is_reload: bool,
#[webapi(method, enumerable, callback = worker_event_prevent_default_callback)]
prevent_default: (),
#[webapi(method, enumerable, callback = service_worker_wait_until_callback)]
wait_until: (),
#[webapi(method, enumerable, callback = service_worker_respond_with_callback)]
respond_with: (),
}
#[derive(WebApiObject)]
#[webapi(
interface = web_api_interfaces::ExtendableMessageEvent,
prototype = "Object",)]
struct ServiceWorkerMessageEventDeclaration<'scope> {
#[webapi(data_property, enumerable)]
r#type: v8::Local<'scope, v8::String>,
#[webapi(data_property, enumerable)]
data: v8::Local<'scope, v8::Value>,
#[webapi(data_property, enumerable)]
source: v8::Local<'scope, v8::Value>,
#[webapi(data_property, enumerable)]
origin: v8::Local<'scope, v8::String>,
#[webapi(data_property, enumerable)]
ports: v8::Local<'scope, v8::Array>,
#[webapi(data_property, enumerable)]
default_prevented: bool,
#[webapi(method, enumerable, callback = worker_event_prevent_default_callback)]
prevent_default: (),
#[webapi(method, enumerable, callback = service_worker_wait_until_callback)]
wait_until: (),
}
#[derive(WebApiObject)]
#[webapi(plain)]
struct ServiceWorkerExtendableMessageEventInitDeclaration<'scope> {
#[webapi(data_property, enumerable)]
data: v8::Local<'scope, v8::Value>,
#[webapi(data_property, enumerable)]
origin: v8::Local<'scope, v8::String>,
#[webapi(data_property = "lastEventId", enumerable)]
last_event_id: v8::Local<'scope, v8::String>,
#[webapi(data_property, enumerable)]
source: v8::Local<'scope, v8::Value>,
#[webapi(data_property, enumerable)]
ports: v8::Local<'scope, v8::Array>,
}
#[derive(Default, WebApiObject)]
#[webapi(plain)]
struct ServiceWorkerMessageDispatchMethodsDeclaration {
#[webapi(
method = "preventDefault",
callback = worker_event_prevent_default_callback,
length = 1
)]
prevent_default: (),
#[webapi(
method = "waitUntil",
callback = service_worker_wait_until_callback,
length = 1
)]
wait_until: (),
}
#[derive(WebApiObject)]
#[webapi(
interface = web_api_interfaces::NotificationEvent,
prototype = "Object",)]
struct ServiceWorkerNotificationEventDeclaration<'scope> {
#[webapi(data_property, enumerable)]
r#type: v8::Local<'scope, v8::String>,
#[webapi(data_property, enumerable)]
notification: v8::Local<'scope, v8::Object>,
#[webapi(data_property, enumerable)]
action: v8::Local<'scope, v8::String>,
#[webapi(data_property, enumerable)]
default_prevented: bool,
#[webapi(method, enumerable, callback = worker_event_prevent_default_callback)]
prevent_default: (),
#[webapi(method, enumerable, callback = service_worker_wait_until_callback)]
wait_until: (),
}
#[derive(WebApiObject)]
#[webapi(
interface = web_api_interfaces::PushEvent,
prototype = "Object",)]
struct ServiceWorkerPushEventDeclaration<'scope> {
#[webapi(data_property, enumerable)]
r#type: v8::Local<'scope, v8::String>,
#[webapi(data_property, enumerable)]
data: v8::Local<'scope, v8::Value>,
#[webapi(data_property, enumerable)]
default_prevented: bool,
#[webapi(method, enumerable, callback = worker_event_prevent_default_callback)]
prevent_default: (),
#[webapi(method, enumerable, callback = service_worker_wait_until_callback)]
wait_until: (),
}
#[derive(WebApiObject)]
#[webapi(interface = web_api_interfaces::PushMessageData)]
struct ServiceWorkerPushMessageDataDeclaration {
#[webapi(method = "arrayBuffer", length = 0, callback = push_message_data_array_buffer_callback)]
array_buffer: (),
#[webapi(method = "bytes", length = 0, callback = push_message_data_bytes_callback)]
bytes: (),
#[webapi(method = "text", length = 0, callback = push_message_data_text_callback)]
text: (),
#[webapi(method = "json", length = 0, callback = push_message_data_json_callback)]
json: (),
}
#[derive(WebApiObject)]
#[webapi(
interface = web_api_interfaces::SyncEvent,
prototype = "Object",)]
struct ServiceWorkerSyncEventDeclaration<'scope> {
#[webapi(data_property, enumerable)]
r#type: v8::Local<'scope, v8::String>,
#[webapi(data_property, enumerable)]
tag: v8::Local<'scope, v8::String>,
#[webapi(data_property = "lastChance", enumerable)]
last_chance: bool,
#[webapi(data_property, enumerable)]
default_prevented: bool,
#[webapi(method, enumerable, callback = worker_event_prevent_default_callback)]
prevent_default: (),
#[webapi(method, enumerable, callback = service_worker_wait_until_callback)]
wait_until: (),
}
#[derive(WebApiObject)]
#[webapi(
interface = web_api_interfaces::PeriodicSyncEvent,
prototype = "Object",)]
struct ServiceWorkerPeriodicSyncEventDeclaration<'scope> {
#[webapi(data_property, enumerable)]
r#type: v8::Local<'scope, v8::String>,
#[webapi(data_property, enumerable)]
tag: v8::Local<'scope, v8::String>,
#[webapi(data_property, enumerable)]
default_prevented: bool,
#[webapi(method, enumerable, callback = worker_event_prevent_default_callback)]
prevent_default: (),
#[webapi(method, enumerable, callback = service_worker_wait_until_callback)]
wait_until: (),
}
#[derive(WebApiObject)]
#[webapi(plain)]
struct ServiceWorkerRespondWithCallbackDataDeclaration<'scope> {
#[webapi(data_property, enumerable)]
event_id: v8::Local<'scope, v8::BigInt>,
#[webapi(data_property, enumerable)]
fulfilled: bool,
}
#[derive(WebApiObject)]
#[webapi(plain)]
struct ServiceWorkerRespondWithLifetimeCallbackDataDeclaration<'scope> {
#[webapi(data_property, enumerable)]
event_id: v8::Local<'scope, v8::BigInt>,
}
#[derive(WebApiObject)]
#[webapi(plain)]
struct ServiceWorkerRespondWithBodyCallbackDataDeclaration<'scope> {
#[webapi(data_property, enumerable)]
event_id: v8::Local<'scope, v8::BigInt>,
}
#[derive(WebApiObject)]
#[webapi(plain)]
struct ServiceWorkerRespondWithStreamChunkCallbackDataDeclaration<'scope> {
#[webapi(data_property, enumerable)]
event_id: v8::Local<'scope, v8::BigInt>,
#[webapi(data_property, enumerable)]
body_source_id: v8::Local<'scope, v8::BigInt>,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum ServiceWorkerWaitUntilEventKind {
Lifecycle,
Fetch,
Message,
Notification,
Push,
Sync,
PeriodicSync,
}
#[derive(Clone)]
struct PendingWorkerPromiseRejection {
promise: v8::Global<v8::Promise>,
reason: Option<v8::Global<v8::Value>>,
}
struct WorkerPromiseRejectDispatchSlot {
worker_wake_tx: mpsc::UnboundedSender<WorkerMessage>,
pending_unhandled_rejections: Rc<RefCell<Vec<PendingWorkerPromiseRejection>>>,
reported_unhandled_rejections: Rc<RefCell<Vec<PendingWorkerPromiseRejection>>>,
unhandled_rejection_task_queued: Rc<Cell<bool>>,
}
pub(super) fn install_worker_promise_rejection_dispatch(
isolate: &mut v8::OwnedIsolate,
worker_wake_tx: mpsc::UnboundedSender<WorkerMessage>,
) {
isolate.set_slot(WorkerPromiseRejectDispatchSlot {
worker_wake_tx,
pending_unhandled_rejections: Rc::new(RefCell::new(Vec::new())),
reported_unhandled_rejections: Rc::new(RefCell::new(Vec::new())),
unhandled_rejection_task_queued: Rc::new(Cell::new(false)),
});
isolate.set_promise_reject_callback(worker_promise_reject_callback);
}
fn worker_promise_reject_dispatch_state(
scope: &mut v8::PinScope<'_, '_>,
) -> Option<(
Rc<RefCell<Vec<PendingWorkerPromiseRejection>>>,
Rc<RefCell<Vec<PendingWorkerPromiseRejection>>>,
Rc<Cell<bool>>,
)> {
scope
.get_slot::<WorkerPromiseRejectDispatchSlot>()
.map(|slot| {
(
slot.pending_unhandled_rejections.clone(),
slot.reported_unhandled_rejections.clone(),
slot.unhandled_rejection_task_queued.clone(),
)
})
}
fn worker_promise_reject_task_state(
scope: &mut v8::PinScope<'_, '_>,
) -> Option<(
mpsc::UnboundedSender<WorkerMessage>,
Rc<RefCell<Vec<PendingWorkerPromiseRejection>>>,
Rc<Cell<bool>>,
)> {
scope
.get_slot::<WorkerPromiseRejectDispatchSlot>()
.map(|slot| {
(
slot.worker_wake_tx.clone(),
slot.pending_unhandled_rejections.clone(),
slot.unhandled_rejection_task_queued.clone(),
)
})
}
fn pending_worker_promise_rejection_matches<'s>(
scope: &mut v8::PinScope<'s, '_>,
rejection: &PendingWorkerPromiseRejection,
promise: v8::Local<'s, v8::Promise>,
) -> bool {
v8::Local::new(scope, &rejection.promise).strict_equals(promise.into())
}
pub(super) fn perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(
scope: &mut v8::PinScope<'_, '_>,
) {
scope.perform_microtask_checkpoint();
queue_pending_worker_promise_rejection_task(scope);
crate::context_bootstrap::run_end_of_microtask_checkpoint_tasks(scope);
}
fn queue_pending_worker_promise_rejection_task(scope: &mut v8::PinScope<'_, '_>) {
let Some((worker_wake_tx, pending_unhandled_rejections, task_queued)) =
worker_promise_reject_task_state(scope)
else {
return;
};
if pending_unhandled_rejections.borrow().is_empty() || task_queued.get() {
return;
}
task_queued.set(true);
let _ = worker_wake_tx.send(WorkerMessage::DispatchPendingPromiseRejections);
}
pub(super) fn dispatch_queued_worker_promise_rejections(scope: &mut v8::PinScope<'_, '_>) {
if let Some((_, _, task_queued)) = worker_promise_reject_task_state(scope) {
task_queued.set(false);
}
flush_pending_worker_promise_rejections(scope);
}
fn flush_pending_worker_promise_rejections(scope: &mut v8::PinScope<'_, '_>) {
let Some((pending_unhandled_rejections, reported_unhandled_rejections, _task_queued)) =
worker_promise_reject_dispatch_state(scope)
else {
return;
};
let pending = std::mem::take(&mut *pending_unhandled_rejections.borrow_mut());
for rejection in pending {
let promise = v8::Local::new(scope, &rejection.promise);
let reason = rejection
.reason
.as_ref()
.map(|reason| v8::Local::new(scope, reason));
let allows_default =
dispatch_worker_promise_rejection_event(scope, "unhandledrejection", promise, reason);
// Do not expose a `rejectionhandled` transition when the handler was
// attached by the `unhandledrejection` listener itself.
if !promise.has_handler() {
remember_reported_worker_promise_rejection(
&reported_unhandled_rejections,
rejection.clone(),
);
}
if allows_default {
log_unhandled_promise_rejection(scope, reason);
}
}
}
fn remember_reported_worker_promise_rejection(
reported_unhandled_rejections: &Rc<RefCell<Vec<PendingWorkerPromiseRejection>>>,
rejection: PendingWorkerPromiseRejection,
) {
let mut reported = reported_unhandled_rejections.borrow_mut();
if reported.len() >= MAX_REPORTED_WORKER_PROMISE_REJECTIONS {
reported.remove(0);
}
reported.push(rejection);
}
unsafe extern "C" fn worker_promise_reject_callback(message: v8::PromiseRejectMessage<'_>) {
let scope = pin!(unsafe { v8::CallbackScope::new(&message) });
let scope = &mut scope.init();
let context = scope.get_current_context();
let scope = &mut v8::ContextScope::new(scope, context);
let Some((pending_unhandled_rejections, reported_unhandled_rejections, _task_queued)) =
worker_promise_reject_dispatch_state(scope)
else {
return;
};
match message.get_event() {
v8::PromiseRejectEvent::PromiseRejectWithNoHandler => {
let promise = message.get_promise();
let mut pending = pending_unhandled_rejections.borrow_mut();
if pending.iter().any(|rejection| {
pending_worker_promise_rejection_matches(scope, rejection, promise)
}) {
return;
}
pending.push(PendingWorkerPromiseRejection {
promise: v8::Global::new(scope, promise),
reason: message
.get_value()
.map(|reason| v8::Global::new(scope, reason)),
});
}
v8::PromiseRejectEvent::PromiseHandlerAddedAfterReject => {
let promise = message.get_promise();
let mut pending = pending_unhandled_rejections.borrow_mut();
if let Some(index) = pending.iter().position(|rejection| {
pending_worker_promise_rejection_matches(scope, rejection, promise)
}) {
pending.swap_remove(index);
return;
}
drop(pending);
let reported = {
let mut reported = reported_unhandled_rejections.borrow_mut();
reported
.iter()
.position(|rejection| {
pending_worker_promise_rejection_matches(scope, rejection, promise)
})
.map(|index| reported.swap_remove(index))
};
let Some(rejection) = reported else {
return;
};
let reason = rejection
.reason
.as_ref()
.map(|reason| v8::Local::new(scope, reason))
.or_else(|| message.get_value());
let _ =
dispatch_worker_promise_rejection_event(scope, "rejectionhandled", promise, reason);
}
_ => {}
}
}
pub(super) fn event_bool_property(
scope: &mut v8::PinScope<'_, '_>,
event: v8::Local<'_, v8::Object>,
key: &str,
) -> bool {
let key = v8::String::new(scope, key).unwrap();
crate::context_bootstrap::event_backing(scope, event)
.get(scope, key.into())
.is_some_and(|value| value.is_true())
}
fn set_event_stop_immediate_propagation(
scope: &mut v8::PinScope<'_, '_>,
event: v8::Local<'_, v8::Object>,
) {
set_event_internal_flag(scope, event, EVENT_STOP_PROPAGATION_SLOT, true);
set_event_internal_flag(scope, event, EVENT_STOP_IMMEDIATE_PROPAGATION_SLOT, true);
}
fn worker_event_prevent_default_callback(
scope: &mut v8::PinScope<'_, '_>,
args: v8::FunctionCallbackArguments<'_>,
_rv: v8::ReturnValue<'_, v8::Value>,
) {
let event = args.this();
let _ = crate::context_bootstrap::event_backing(scope, event).set(
scope,
v8str(scope, "defaultPrevented").into(),
v8::Boolean::new(scope, true).into(),
);
}
fn new_worker_event_object<'s>(
scope: &mut v8::PinScope<'s, '_>,
event_type: &str,
) -> v8::Local<'s, v8::Object> {
WorkerBasicEventDeclaration::new(v8::String::new(scope, event_type).unwrap())
.bind(scope)
.expect("worker basic Event declaration should bind")
}
fn new_worker_message_event<'s>(
scope: &mut v8::PinScope<'s, '_>,
event_type: &str,
data: v8::Local<'s, v8::Value>,
source: Option<v8::Local<'s, v8::Value>>,
ports: v8::Local<'s, v8::Array>,
) -> v8::Local<'s, v8::Object> {
let source = source.unwrap_or_else(|| v8::null(scope).into());
crate::context_bootstrap::construct_original_message_event(
scope,
event_type,
data,
"",
&[],
source,
ports,
)
.expect("worker MessageEvent should initialize")
}
fn new_worker_error_event<'s>(
scope: &mut v8::PinScope<'s, '_>,
report: &V8ExceptionReport,
default_url: &str,
exception: Option<v8::Local<'s, v8::Value>>,
) -> v8::Local<'s, v8::Object> {
let error = exception.unwrap_or_else(|| v8::undefined(scope).into());
crate::context_bootstrap::construct_original_error_event(
scope,
&report.summary,
report.source.as_deref().unwrap_or(default_url),
report.line.unwrap_or(0) as u32,
report.column.unwrap_or(0) as u32,
error,
)
.expect("native Worker ErrorEvent should initialize")
}
fn new_worker_promise_rejection_event<'s>(
scope: &mut v8::PinScope<'s, '_>,
event_type: &str,
promise: v8::Local<'s, v8::Promise>,
reason: Option<v8::Local<'s, v8::Value>>,
) -> v8::Local<'s, v8::Object> {
let global = scope.get_current_context().global(scope);
if let Some(event_ctor) = global
.get(scope, v8str(scope, "PromiseRejectionEvent").into())
.and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())
{
let init = WorkerPromiseRejectionEventInitDeclaration::new(
event_type == "unhandledrejection",
promise,
reason.unwrap_or_else(|| v8::null(scope).into()),
)
.bind(scope)
.expect("worker PromiseRejectionEvent init declaration should bind");
if let Some(type_value) = v8::String::new(scope, event_type)
&& let Some(event) = event_ctor.new_instance(scope, &[type_value.into(), init.into()])
{
return event;
}
}
let event = new_worker_event_object(scope, event_type);
let _ = WorkerPromiseRejectionEventFallbackDeclaration::new(
promise,
reason.unwrap_or_else(|| v8::null(scope).into()),
)
.initialize(scope, event);
event
}
fn dispatch_worker_event<'s>(
scope: &mut v8::PinScope<'s, '_>,
target: v8::Local<'s, v8::Object>,
event: v8::Local<'s, v8::Object>,
event_type: &str,
checkpoint: bool,
) {
mark_event_trusted(scope, event);
if checkpoint {
crate::context_bootstrap::dispatch_simple_event_target_event_with_checkpoint(
scope,
target,
event_type,
event,
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections,
);
} else {
crate::context_bootstrap::dispatch_simple_event_target_event(
scope, target, event_type, event,
);
}
}
fn dispatch_worker_promise_rejection_event<'s>(
scope: &mut v8::PinScope<'s, '_>,
event_type: &str,
promise: v8::Local<'s, v8::Promise>,
reason: Option<v8::Local<'s, v8::Value>>,
) -> bool {
let global = scope.get_current_context().global(scope);
let event = new_worker_promise_rejection_event(scope, event_type, promise, reason);
dispatch_worker_event(scope, global, event, event_type, false);
!event_bool_property(scope, event, "defaultPrevented")
}
pub(super) fn report_exception_to_parent(
report: &V8ExceptionReport,
script_url: &str,
event_kind: WorkerParentErrorEventKind,
parent_tx: &mpsc::UnboundedSender<WorkerToParentMessage>,
) {
report_exception_to_parent_with_phase(
report,
script_url,
event_kind,
WorkerErrorPhase::Runtime,
parent_tx,
);
}
pub(super) fn report_exception_to_parent_with_phase(
report: &V8ExceptionReport,
script_url: &str,
event_kind: WorkerParentErrorEventKind,
phase: WorkerErrorPhase,
parent_tx: &mpsc::UnboundedSender<WorkerToParentMessage>,
) {
report_exception_to_parent_with_phase_and_source(
report,
script_url,
event_kind,
phase,
WorkerErrorSource::Runtime,
parent_tx,
);
}
pub(super) fn report_exception_to_parent_with_phase_and_source(
report: &V8ExceptionReport,
script_url: &str,
event_kind: WorkerParentErrorEventKind,
phase: WorkerErrorPhase,
source: WorkerErrorSource,
parent_tx: &mpsc::UnboundedSender<WorkerToParentMessage>,
) {
let _ = parent_tx.send(WorkerToParentMessage::Error {
message: report.summary.clone(),
filename: report
.source
.clone()
.unwrap_or_else(|| script_url.to_owned()),
lineno: report.line.unwrap_or(0) as u32,
colno: report.column.unwrap_or(0) as u32,
event_kind,
phase,
source,
});
}
fn worker_exception_source_override<'s>(
scope: &mut v8::PinScope<'s, '_>,
exception: v8::Local<'s, v8::Value>,
) -> Option<String> {
let object = v8::Local::<v8::Object>::try_from(exception).ok()?;
get_private_value(scope, object, WORKER_EXCEPTION_SOURCE_SLOT)?
.to_string(scope)
.map(|value| value.to_rust_string_lossy(scope))
.filter(|value| !value.is_empty())
}
fn worker_exception_number_override<'s>(
scope: &mut v8::PinScope<'s, '_>,
exception: v8::Local<'s, v8::Value>,
slot: &str,
) -> Option<usize> {
let object = v8::Local::<v8::Object>::try_from(exception).ok()?;
let value = get_private_value(scope, object, slot)?;
let number = value.number_value(scope)?;
if !number.is_finite() || number < 0.0 {
return None;
}
Some(number as usize)
}
fn apply_worker_exception_location_overrides<'s>(
scope: &mut v8::PinScope<'s, '_>,
report: &mut V8ExceptionReport,
exception: Option<v8::Local<'s, v8::Value>>,
) {
let Some(exception) = exception else {
return;
};
if let Some(source) = worker_exception_source_override(scope, exception) {
report.source = Some(source);
}
if let Some(line) =
worker_exception_number_override(scope, exception, WORKER_EXCEPTION_LINE_SLOT)
{
report.line = Some(line);
}
if let Some(column) =
worker_exception_number_override(scope, exception, WORKER_EXCEPTION_COLUMN_SLOT)
{
report.column = Some(column);
}
}
struct WorkerErrorReportingScope(Rc<RefCell<super::WorkerGlobalState>>);
impl Drop for WorkerErrorReportingScope {
fn drop(&mut self) {
self.0.borrow_mut().in_error_reporting_mode = false;
}
}
pub(super) fn dispatch_worker_error_event<'s>(
scope: &mut v8::PinScope<'s, '_>,
global: v8::Local<'s, v8::Object>,
report: &V8ExceptionReport,
exception: Option<v8::Local<'s, v8::Value>>,
script_url: &str,
) -> bool {
let _reporting_scope = if let Some(state) = get_worker_state(scope) {
if state.borrow().in_error_reporting_mode {
// A nested exception remains unhandled and propagates to the
// parent, without recursively firing another local error event.
return false;
}
state.borrow_mut().in_error_reporting_mode = true;
Some(WorkerErrorReportingScope(state))
} else {
None
};
let event = new_worker_error_event(scope, report, script_url, exception);
mark_event_trusted(scope, event);
!crate::context_bootstrap::dispatch_simple_event_target_event(scope, global, "error", event)
}
pub(super) fn dispatch_service_worker_lifecycle_event(
isolate: &mut v8::OwnedIsolate,
context: &v8::Global<v8::Context>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
event: ServiceWorkerLifecycleEvent,
) {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let ctx = v8::Local::new(scope, context);
let scope = &mut v8::ContextScope::new(scope, ctx);
let global = ctx.global(scope);
dispatch_service_worker_lifecycle_event_in_context(scope, global, state, event);
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
pub(super) fn dispatch_service_worker_fetch_event(
isolate: &mut v8::OwnedIsolate,
context: &v8::Global<v8::Context>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
event: ServiceWorkerFetchEvent,
parent_tx: &mpsc::UnboundedSender<WorkerToParentMessage>,
) {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let ctx = v8::Local::new(scope, context);
let scope = &mut v8::ContextScope::new(scope, ctx);
let global = ctx.global(scope);
dispatch_service_worker_fetch_event_in_context(scope, global, state, event, parent_tx);
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
pub(super) fn cancel_service_worker_fetch_stream(
isolate: &mut v8::OwnedIsolate,
context: &v8::Global<v8::Context>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
body_source_id: NetworkBodySourceId,
) {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let ctx = v8::Local::new(scope, context);
let scope = &mut v8::ContextScope::new(scope, ctx);
cancel_service_worker_fetch_stream_in_context(scope, state, event_id, body_source_id);
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
pub(super) fn abort_service_worker_fetch_request_signal(
isolate: &mut v8::OwnedIsolate,
context: &v8::Global<v8::Context>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
reason: Option<V8StructuredClonePayload>,
) {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let ctx = v8::Local::new(scope, context);
let scope = &mut v8::ContextScope::new(scope, ctx);
abort_service_worker_fetch_request_signal_in_context(scope, state, event_id, reason);
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
pub(super) fn dispatch_service_worker_message_event(
isolate: &mut v8::OwnedIsolate,
context: &v8::Global<v8::Context>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
event: ServiceWorkerMessageEvent,
) {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let ctx = v8::Local::new(scope, context);
let scope = &mut v8::ContextScope::new(scope, ctx);
let global = ctx.global(scope);
dispatch_service_worker_message_event_in_context(scope, global, state, event);
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
pub(super) fn dispatch_service_worker_controller_change_event(
isolate: &mut v8::OwnedIsolate,
context: &v8::Global<v8::Context>,
) {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let ctx = v8::Local::new(scope, context);
let scope = &mut v8::ContextScope::new(scope, ctx);
dispatch_service_worker_controller_change(scope, crate::native_bridge::OwnerDispatchScope::Top);
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
pub(super) fn dispatch_service_worker_notification_event(
isolate: &mut v8::OwnedIsolate,
context: &v8::Global<v8::Context>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
event: ServiceWorkerNotificationEvent,
parent_tx: &mpsc::UnboundedSender<WorkerToParentMessage>,
) {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let ctx = v8::Local::new(scope, context);
let scope = &mut v8::ContextScope::new(scope, ctx);
let global = ctx.global(scope);
dispatch_service_worker_notification_event_in_context(scope, global, state, event, parent_tx);
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
pub(super) fn dispatch_service_worker_push_event(
isolate: &mut v8::OwnedIsolate,
context: &v8::Global<v8::Context>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
event: ServiceWorkerPushEvent,
parent_tx: &mpsc::UnboundedSender<WorkerToParentMessage>,
) {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let ctx = v8::Local::new(scope, context);
let scope = &mut v8::ContextScope::new(scope, ctx);
let global = ctx.global(scope);
dispatch_service_worker_push_event_in_context(scope, global, state, event, parent_tx);
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
pub(super) fn dispatch_service_worker_sync_event(
isolate: &mut v8::OwnedIsolate,
context: &v8::Global<v8::Context>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
event: ServiceWorkerSyncEvent,
parent_tx: &mpsc::UnboundedSender<WorkerToParentMessage>,
) {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let ctx = v8::Local::new(scope, context);
let scope = &mut v8::ContextScope::new(scope, ctx);
let global = ctx.global(scope);
dispatch_service_worker_sync_event_in_context(scope, global, state, event, parent_tx);
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
pub(super) fn dispatch_service_worker_periodic_sync_event(
isolate: &mut v8::OwnedIsolate,
context: &v8::Global<v8::Context>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
event: ServiceWorkerPeriodicSyncEvent,
parent_tx: &mpsc::UnboundedSender<WorkerToParentMessage>,
) {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let ctx = v8::Local::new(scope, context);
let scope = &mut v8::ContextScope::new(scope, ctx);
let global = ctx.global(scope);
dispatch_service_worker_periodic_sync_event_in_context(scope, global, state, event, parent_tx);
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
fn dispatch_service_worker_lifecycle_event_in_context<'s>(
scope: &mut v8::PinScope<'s, '_>,
global: v8::Local<'s, v8::Object>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
event: ServiceWorkerLifecycleEvent,
) {
let event_object = new_service_worker_lifecycle_event(scope, event.kind);
set_service_worker_event_id(scope, event_object, event.event_id);
{
let mut state = state.borrow_mut();
state.pending_service_worker_lifecycle_events.insert(
event.event_id,
PendingServiceWorkerLifecycleEvent {
completion: ServiceWorkerLifecycleCompletion {
event_id: event.event_id,
owner: event.owner.clone(),
kind: event.kind,
result: Ok(()),
},
pending_wait_until_count: 0,
dispatch_finished: false,
},
);
}
let event_type = event.kind.as_str();
dispatch_worker_event(scope, global, event_object, event_type, true);
mark_service_worker_lifecycle_dispatch_finished(state, event.event_id);
maybe_send_service_worker_lifecycle_completion(state, event.event_id);
}
fn dispatch_service_worker_fetch_event_in_context<'s>(
scope: &mut v8::PinScope<'s, '_>,
global: v8::Local<'s, v8::Object>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
event: ServiceWorkerFetchEvent,
parent_tx: &mpsc::UnboundedSender<WorkerToParentMessage>,
) {
let Some((request, request_signal_id)) =
new_service_worker_fetch_request(scope, global, &event)
else {
let _ = parent_tx.send(WorkerToParentMessage::ServiceWorkerFetchCompleted(
ServiceWorkerFetchCompletion {
event_id: event.event_id,
owner: event.owner.clone(),
result: ServiceWorkerFetchResult::Failure(
"failed to construct service worker FetchEvent request".to_owned(),
),
},
));
return;
};
let Some(handled_resolver) = v8::PromiseResolver::new(scope) else {
let _ = parent_tx.send(WorkerToParentMessage::ServiceWorkerFetchCompleted(
ServiceWorkerFetchCompletion {
event_id: event.event_id,
owner: event.owner.clone(),
result: ServiceWorkerFetchResult::Failure(
"failed to construct service worker FetchEvent.handled promise".to_owned(),
),
},
));
return;
};
let handled = handled_resolver.get_promise(scope);
let Some((preload_response, preload_response_resolver)) =
new_service_worker_preload_response_promise(scope, event.navigation_preload_sent)
else {
let _ = parent_tx.send(WorkerToParentMessage::ServiceWorkerFetchCompleted(
ServiceWorkerFetchCompletion {
event_id: event.event_id,
owner: event.owner.clone(),
result: ServiceWorkerFetchResult::Failure(
"failed to construct service worker FetchEvent.preloadResponse promise"
.to_owned(),
),
},
));
return;
};
let event_object =
new_service_worker_fetch_event(scope, &event, request, handled, preload_response);
set_service_worker_fetch_event_id(scope, event_object, event.event_id);
{
let mut state = state.borrow_mut();
let mut pending = PendingServiceWorkerFetchEvent::fallback(
ServiceWorkerFetchCompletion {
event_id: event.event_id,
owner: event.owner.clone(),
result: ServiceWorkerFetchResult::Fallback,
},
event.request.request_mode,
event.request.destination,
);
pending.handled_resolver = Some(v8::Global::new(scope, handled_resolver));
if event.navigation_preload_sent {
state.pending_service_worker_navigation_preloads.insert(
event.event_id,
PendingServiceWorkerNavigationPreload {
owner: event.owner.clone(),
_promise: v8::Global::new(scope, preload_response),
resolver: Some(v8::Global::new(scope, preload_response_resolver)),
body_source_id: None,
},
);
}
pending.request_signal_id = request_signal_id;
state
.pending_service_worker_fetch_events
.insert(event.event_id, pending);
}
dispatch_worker_event(scope, global, event_object, "fetch", true);
let default_prevented_without_response =
event_bool_property(scope, event_object, "defaultPrevented");
if default_prevented_without_response {
mark_service_worker_fetch_default_prevented(state, event.event_id);
}
mark_service_worker_fetch_dispatch_finished(state, event.event_id);
settle_service_worker_fetch_handled_after_dispatch(scope, state, event.event_id);
maybe_send_service_worker_fetch_completion(state, event.event_id, scope);
}
fn dispatch_service_worker_message_event_in_context<'s>(
scope: &mut v8::PinScope<'s, '_>,
global: v8::Local<'s, v8::Object>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
event: ServiceWorkerMessageEvent,
) {
let (event_type, event_object) = new_service_worker_message_event(scope, &event)
.unwrap_or_else(|| {
(
"messageerror",
new_service_worker_messageerror_event(scope, &event),
)
});
set_service_worker_message_event_id(scope, event_object, event.event_id);
{
let mut state = state.borrow_mut();
state.pending_service_worker_message_events.insert(
event.event_id,
PendingServiceWorkerMessageEvent {
completion: ServiceWorkerMessageCompletion {
event_id: event.event_id,
owner: event.owner.clone(),
result: Ok(()),
},
pending_wait_until_count: 0,
dispatch_finished: false,
window_interaction_allowed: event.window_interaction_allowed,
},
);
if event.window_interaction_allowed {
state.service_worker_window_interaction_allowed_count = state
.service_worker_window_interaction_allowed_count
.saturating_add(1);
}
}
dispatch_worker_event(scope, global, event_object, event_type, true);
mark_service_worker_message_dispatch_finished(state, event.event_id);
maybe_send_service_worker_message_completion(state, event.event_id);
}
fn dispatch_service_worker_notification_event_in_context<'s>(
scope: &mut v8::PinScope<'s, '_>,
global: v8::Local<'s, v8::Object>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
event: ServiceWorkerNotificationEvent,
parent_tx: &mpsc::UnboundedSender<WorkerToParentMessage>,
) {
let Some(event_object) = new_service_worker_notification_event(scope, global, &event) else {
let _ = parent_tx.send(WorkerToParentMessage::ServiceWorkerNotificationCompleted(
ServiceWorkerNotificationCompletion {
event_id: event.event_id,
owner: event.owner.clone(),
result: Err("failed to construct service worker notification event".to_owned()),
},
));
return;
};
set_service_worker_notification_event_id(scope, event_object, event.event_id);
{
let mut state = state.borrow_mut();
let window_interaction_allowed = event.kind.grants_window_interaction();
state.pending_service_worker_notification_events.insert(
event.event_id,
PendingServiceWorkerNotificationEvent {
completion: ServiceWorkerNotificationCompletion {
event_id: event.event_id,
owner: event.owner.clone(),
result: Ok(()),
},
pending_wait_until_count: 0,
dispatch_finished: false,
window_interaction_allowed,
},
);
if window_interaction_allowed {
state.service_worker_window_interaction_allowed_count = state
.service_worker_window_interaction_allowed_count
.saturating_add(1);
}
}
let event_type = event.kind.as_str();
dispatch_worker_event(scope, global, event_object, event_type, true);
mark_service_worker_notification_dispatch_finished(state, event.event_id);
maybe_send_service_worker_notification_completion(state, event.event_id);
}
fn dispatch_service_worker_push_event_in_context<'s>(
scope: &mut v8::PinScope<'s, '_>,
global: v8::Local<'s, v8::Object>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
event: ServiceWorkerPushEvent,
parent_tx: &mpsc::UnboundedSender<WorkerToParentMessage>,
) {
let Some(event_object) = new_service_worker_push_event(scope, &event) else {
let _ = parent_tx.send(WorkerToParentMessage::ServiceWorkerPushCompleted(
ServiceWorkerPushCompletion {
event_id: event.event_id,
owner: event.owner.clone(),
result: Err("failed to construct service worker push event".to_owned()),
},
));
return;
};
set_service_worker_push_event_id(scope, event_object, event.event_id);
{
let mut state = state.borrow_mut();
state.pending_service_worker_push_events.insert(
event.event_id,
PendingServiceWorkerPushEvent {
completion: ServiceWorkerPushCompletion {
event_id: event.event_id,
owner: event.owner.clone(),
result: Ok(()),
},
pending_wait_until_count: 0,
dispatch_finished: false,
},
);
}
dispatch_worker_event(scope, global, event_object, "push", true);
mark_service_worker_push_dispatch_finished(state, event.event_id);
maybe_send_service_worker_push_completion(state, event.event_id);
}
fn dispatch_service_worker_sync_event_in_context<'s>(
scope: &mut v8::PinScope<'s, '_>,
global: v8::Local<'s, v8::Object>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
event: ServiceWorkerSyncEvent,
parent_tx: &mpsc::UnboundedSender<WorkerToParentMessage>,
) {
let Some(event_object) = new_service_worker_sync_event(scope, &event) else {
let _ = parent_tx.send(WorkerToParentMessage::ServiceWorkerSyncCompleted(
ServiceWorkerSyncCompletion {
event_id: event.event_id,
registration_id: event.registration_id,
owner: event.owner.clone(),
tag: event.tag,
result: Err("failed to construct service worker sync event".to_owned()),
},
));
return;
};
set_service_worker_sync_event_id(scope, event_object, event.event_id);
{
let mut state = state.borrow_mut();
state.pending_service_worker_sync_events.insert(
event.event_id,
PendingServiceWorkerSyncEvent {
completion: ServiceWorkerSyncCompletion {
event_id: event.event_id,
registration_id: event.registration_id,
owner: event.owner.clone(),
tag: event.tag.clone(),
result: Ok(()),
},
pending_wait_until_count: 0,
dispatch_finished: false,
},
);
}
dispatch_worker_event(scope, global, event_object, "sync", true);
mark_service_worker_sync_dispatch_finished(state, event.event_id);
maybe_send_service_worker_sync_completion(state, event.event_id);
}
fn dispatch_service_worker_periodic_sync_event_in_context<'s>(
scope: &mut v8::PinScope<'s, '_>,
global: v8::Local<'s, v8::Object>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
event: ServiceWorkerPeriodicSyncEvent,
parent_tx: &mpsc::UnboundedSender<WorkerToParentMessage>,
) {
let Some(event_object) = new_service_worker_periodic_sync_event(scope, &event) else {
let _ = parent_tx.send(WorkerToParentMessage::ServiceWorkerPeriodicSyncCompleted(
ServiceWorkerPeriodicSyncCompletion {
event_id: event.event_id,
registration_id: event.registration_id,
owner: event.owner.clone(),
tag: event.tag,
result: Err("failed to construct service worker periodic sync event".to_owned()),
},
));
return;
};
set_service_worker_periodic_sync_event_id(scope, event_object, event.event_id);
{
let mut state = state.borrow_mut();
state.pending_service_worker_periodic_sync_events.insert(
event.event_id,
PendingServiceWorkerPeriodicSyncEvent {
completion: ServiceWorkerPeriodicSyncCompletion {
event_id: event.event_id,
registration_id: event.registration_id,
owner: event.owner.clone(),
tag: event.tag.clone(),
result: Ok(()),
},
pending_wait_until_count: 0,
dispatch_finished: false,
},
);
}
dispatch_worker_event(scope, global, event_object, "periodicsync", true);
mark_service_worker_periodic_sync_dispatch_finished(state, event.event_id);
maybe_send_service_worker_periodic_sync_completion(state, event.event_id);
}
fn new_service_worker_lifecycle_event<'s>(
scope: &mut v8::PinScope<'s, '_>,
kind: ServiceWorkerLifecycleEventKind,
) -> v8::Local<'s, v8::Object> {
ServiceWorkerLifecycleEventDeclaration {
r#type: v8::String::new(scope, kind.as_str()).unwrap(),
default_prevented: false,
prevent_default: (),
wait_until: (),
}
.bind(scope)
.expect("service worker lifecycle event declaration should bind")
}
fn new_service_worker_fetch_event<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: &ServiceWorkerFetchEvent,
request: v8::Local<'s, v8::Object>,
handled: v8::Local<'s, v8::Promise>,
preload_response: v8::Local<'s, v8::Promise>,
) -> v8::Local<'s, v8::Object> {
let client_id = v8::String::new(
scope,
&service_worker_exposed_client_id(event.request.client_id),
)
.unwrap_or_else(|| v8::String::empty(scope));
let resulting_client_id = event
.request
.resulting_client_id
.map(service_worker_exposed_client_id)
.and_then(|client_id| v8::String::new(scope, &client_id))
.unwrap_or_else(|| v8::String::empty(scope));
ServiceWorkerFetchEventDeclaration {
r#type: v8::String::new(scope, "fetch").unwrap(),
default_prevented: false,
handled,
preload_response,
request,
client_id,
resulting_client_id,
is_reload: event.request.is_reload,
prevent_default: (),
wait_until: (),
respond_with: (),
}
.bind(scope)
.expect("service worker fetch event declaration should bind")
}
fn new_service_worker_preload_response_promise<'s>(
scope: &mut v8::PinScope<'s, '_>,
navigation_preload_sent: bool,
) -> Option<(
v8::Local<'s, v8::Promise>,
v8::Local<'s, v8::PromiseResolver>,
)> {
let resolver = v8::PromiseResolver::new(scope)?;
let promise = resolver.get_promise(scope);
if !navigation_preload_sent {
let _ = resolver.resolve(scope, v8::undefined(scope).into());
}
Some((promise, resolver))
}
fn new_service_worker_message_event<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: &ServiceWorkerMessageEvent,
) -> Option<(&'static str, v8::Local<'s, v8::Object>)> {
if !runtime_message_allowed_for_current_target(scope, &event.payload) {
return None;
}
let (data, ports) = structured_deserialize_value_for_message_event(scope, &event.payload)?;
Some((
"message",
new_service_worker_message_event_with_parts(scope, event, "message", data, ports),
))
}
fn new_service_worker_messageerror_event<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: &ServiceWorkerMessageEvent,
) -> v8::Local<'s, v8::Object> {
let data = v8::null(scope).into();
let ports = v8::Array::new(scope, 0);
new_service_worker_message_event_with_parts(scope, event, "messageerror", data, ports)
}
fn new_service_worker_message_event_with_parts<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: &ServiceWorkerMessageEvent,
event_type: &'static str,
data: v8::Local<'s, v8::Value>,
ports: v8::Local<'s, v8::Array>,
) -> v8::Local<'s, v8::Object> {
let source = if let Some(source_client) = event.source_client_snapshot.as_ref() {
super::super::global_scope::build_service_worker_client_object_from_snapshot(
scope,
source_client,
)
.map(v8::Local::into)
.unwrap_or_else(|| v8::null(scope).into())
} else if let Some(source_worker) = event.source_worker.as_ref() {
super::super::global_scope::build_service_worker_global_service_worker(scope, source_worker)
.map(v8::Local::into)
.unwrap_or_else(|_| v8::null(scope).into())
} else {
event
.source_client_id
.map(|client_id| {
let url = event
.source_client_url
.as_ref()
.map(|url| url.as_str())
.unwrap_or_default();
super::super::global_scope::build_service_worker_client_object(
scope,
client_id,
&crate::runtime::service_worker_exposed_client_id(client_id),
url,
"window",
"top-level",
"visible",
false,
)
.map(v8::Local::into)
})
.unwrap_or_else(|| Some(v8::null(scope).into()))
.unwrap_or_else(|| v8::null(scope).into())
};
if let Some(event_object) = new_service_worker_extendable_message_event_with_parts(
scope,
event_type,
data,
source,
ports,
&event.source_origin,
) {
install_service_worker_message_dispatch_methods(scope, event_object);
return event_object;
}
ServiceWorkerMessageEventDeclaration {
r#type: v8::String::new(scope, event_type).unwrap_or_else(|| v8::String::empty(scope)),
data,
source,
origin: v8_string(scope, &event.source_origin).unwrap_or_else(|| v8::String::empty(scope)),
ports,
default_prevented: false,
prevent_default: (),
wait_until: (),
}
.bind(scope)
.expect("service worker message event declaration should bind")
}
fn new_service_worker_extendable_message_event_with_parts<'s>(
scope: &mut v8::PinScope<'s, '_>,
event_type: &'static str,
data: v8::Local<'s, v8::Value>,
source: v8::Local<'s, v8::Value>,
ports: v8::Local<'s, v8::Array>,
origin: &str,
) -> Option<v8::Local<'s, v8::Object>> {
let global = scope.get_current_context().global(scope);
let constructor = global
.get(scope, v8str(scope, "ExtendableMessageEvent").into())
.and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())?;
let event_type = v8::String::new(scope, event_type)?;
let origin = v8_string(scope, origin)?;
let last_event_id = v8::String::empty(scope);
let init = ServiceWorkerExtendableMessageEventInitDeclaration::new(
data,
origin,
last_event_id,
source,
ports,
)
.bind(scope)
.ok()?;
constructor.new_instance(scope, &[event_type.into(), init.into()])
}
fn install_service_worker_message_dispatch_methods<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) {
let _ = ServiceWorkerMessageDispatchMethodsDeclaration::default().initialize(scope, event);
}
fn new_service_worker_notification_event<'s>(
scope: &mut v8::PinScope<'s, '_>,
_global: v8::Local<'s, v8::Object>,
event: &ServiceWorkerNotificationEvent,
) -> Option<v8::Local<'s, v8::Object>> {
let snapshot = crate::runtime::ServiceWorkerNotificationSnapshot {
id: event.notification_id,
registration_id: event.registration_id,
title: event.title.clone(),
tag: event.tag.clone(),
metadata: event.metadata.clone(),
actions: event.actions.clone(),
data: event.data.clone(),
};
let notification =
crate::context_bootstrap::build_notification_object_from_snapshot(scope, &snapshot)?;
ServiceWorkerNotificationEventDeclaration {
r#type: v8str(scope, event.kind.as_str()),
notification,
action: v8_string(scope, &event.action).unwrap_or_else(|| v8::String::empty(scope)),
default_prevented: false,
prevent_default: (),
wait_until: (),
}
.bind(scope)
.ok()
}
fn new_service_worker_push_event<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: &ServiceWorkerPushEvent,
) -> Option<v8::Local<'s, v8::Object>> {
let data = event
.data
.as_deref()
.map(|bytes| new_service_worker_push_message_data(scope, bytes).map(v8::Local::into))
.unwrap_or_else(|| Some(v8::null(scope).into()))?;
ServiceWorkerPushEventDeclaration {
r#type: v8str(scope, "push"),
data,
default_prevented: false,
prevent_default: (),
wait_until: (),
}
.bind(scope)
.ok()
}
fn new_service_worker_push_message_data<'s>(
scope: &mut v8::PinScope<'s, '_>,
bytes: &[u8],
) -> Option<v8::Local<'s, v8::Object>> {
let object = ServiceWorkerPushMessageDataDeclaration {
array_buffer: (),
bytes: (),
text: (),
json: (),
}
.bind(scope)
.ok()?;
let buffer = array_buffer_from_bytes(scope, bytes.to_vec());
set_private_value(
scope,
object,
SERVICE_WORKER_PUSH_MESSAGE_DATA_BYTES_SLOT,
buffer.into(),
);
Some(object)
}
fn push_message_data_bytes_from_this<'s>(
scope: &mut v8::PinScope<'s, '_>,
this: v8::Local<'s, v8::Object>,
) -> Option<Vec<u8>> {
let value = get_private_value(scope, this, SERVICE_WORKER_PUSH_MESSAGE_DATA_BYTES_SLOT)?;
let buffer = v8::Local::<v8::ArrayBuffer>::try_from(value).ok()?;
let view = v8::Uint8Array::new(scope, buffer, 0, buffer.byte_length())?;
let mut bytes = vec![0; view.byte_length()];
let written = view.copy_contents(&mut bytes);
bytes.truncate(written);
Some(bytes)
}
fn array_buffer_from_bytes<'s>(
scope: &mut v8::PinScope<'s, '_>,
bytes: Vec<u8>,
) -> v8::Local<'s, v8::ArrayBuffer> {
let backing_store = v8::ArrayBuffer::new_backing_store_from_vec(bytes).make_shared();
v8::ArrayBuffer::with_backing_store(scope, &backing_store)
}
fn uint8_array_from_bytes<'s>(
scope: &mut v8::PinScope<'s, '_>,
bytes: Vec<u8>,
) -> Option<v8::Local<'s, v8::Uint8Array>> {
let len = bytes.len();
let buffer = array_buffer_from_bytes(scope, bytes);
v8::Uint8Array::new(scope, buffer, 0, len)
}
fn push_message_data_array_buffer_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(bytes) = push_message_data_bytes_from_this(scope, args.this()) else {
return;
};
let buffer = array_buffer_from_bytes(scope, bytes);
rv.set(buffer.into());
}
fn push_message_data_bytes_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(bytes) = push_message_data_bytes_from_this(scope, args.this()) else {
return;
};
let Some(array) = uint8_array_from_bytes(scope, bytes) else {
return;
};
rv.set(array.into());
}
fn push_message_data_text_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(bytes) = push_message_data_bytes_from_this(scope, args.this()) else {
return;
};
let text = String::from_utf8_lossy(&bytes);
let Some(value) = v8_string(scope, text.as_ref()) else {
return;
};
rv.set(value.into());
}
fn push_message_data_json_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(bytes) = push_message_data_bytes_from_this(scope, args.this()) else {
return;
};
let text = String::from_utf8_lossy(&bytes);
let Some(source) = v8_string(scope, text.as_ref()) else {
return;
};
let Some(value) = v8::json::parse(scope, source) else {
let message = v8str(
scope,
"PushMessageData.json() could not parse the payload as JSON.",
);
let exception = v8::Exception::syntax_error(scope, message);
scope.throw_exception(exception);
return;
};
rv.set(value);
}
fn new_service_worker_sync_event<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: &ServiceWorkerSyncEvent,
) -> Option<v8::Local<'s, v8::Object>> {
ServiceWorkerSyncEventDeclaration {
r#type: v8str(scope, "sync"),
tag: v8_string(scope, &event.tag).unwrap_or_else(|| v8::String::empty(scope)),
last_chance: event.last_chance,
default_prevented: false,
prevent_default: (),
wait_until: (),
}
.bind(scope)
.ok()
}
fn new_service_worker_periodic_sync_event<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: &ServiceWorkerPeriodicSyncEvent,
) -> Option<v8::Local<'s, v8::Object>> {
ServiceWorkerPeriodicSyncEventDeclaration {
r#type: v8str(scope, "periodicsync"),
tag: v8_string(scope, &event.tag).unwrap_or_else(|| v8::String::empty(scope)),
default_prevented: false,
prevent_default: (),
wait_until: (),
}
.bind(scope)
.ok()
}
fn new_service_worker_fetch_request<'s>(
scope: &mut v8::PinScope<'s, '_>,
global: v8::Local<'s, v8::Object>,
event: &ServiceWorkerFetchEvent,
) -> Option<(v8::Local<'s, v8::Object>, Option<u32>)> {
let request_ctor = global
.get(scope, v8str(scope, "Request").into())
.and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())?;
let init = v8::Object::new(scope);
set_object_string(scope, init, "method", &event.request.method);
let constructible_mode = if event.request.request_mode == moli_fetch::RequestMode::Navigate {
"same-origin"
} else {
event.request.request_mode.into()
};
set_object_string(scope, init, "mode", constructible_mode);
set_object_string(
scope,
init,
"credentials",
event.request.credentials_mode.into(),
);
set_object_string(scope, init, "redirect", event.request.redirect_mode.into());
set_object_string(scope, init, "cache", &event.request.metadata.cache);
set_object_string(scope, init, "referrer", &event.request.metadata.referrer);
set_object_string(
scope,
init,
"referrerPolicy",
&event.request.metadata.referrer_policy,
);
set_object_string(scope, init, "integrity", &event.request.metadata.integrity);
set_object_bool(scope, init, "keepalive", event.request.metadata.keepalive);
if let Some(priority) = event.request.priority {
let priority: &'static str = priority.into();
set_object_string(scope, init, "priority", priority);
}
let headers = v8::Object::new(scope);
for (name, value) in &event.request.headers {
set_object_string(scope, headers, name, value);
}
let _ = init.set(scope, v8str(scope, "headers").into(), headers.into());
if !matches!(event.request.method.as_str(), "GET" | "HEAD")
&& let Some(body) = event.request.body.clone()
{
// The mutable JS buffer must not alias shared immutable upload bytes.
let backing_store = v8::ArrayBuffer::new_backing_store_from_vec(body.into()).make_shared();
let body = v8::ArrayBuffer::with_backing_store(scope, &backing_store);
let _ = init.set(scope, v8str(scope, "body").into(), body.into());
}
let url = v8::String::new(scope, event.request.url.as_str())?;
let request = request_ctor.new_instance(scope, &[url.into(), init.into()])?;
set_request_destination_for_service_worker_fetch_event(
scope,
request,
event.request.destination.as_str(),
);
set_request_mode_for_service_worker_fetch_event(
scope,
request,
event.request.request_mode.into(),
);
set_request_reload_navigation_for_service_worker_fetch_event(
scope,
request,
event.request.is_reload,
);
let request_signal_id = request
.get(scope, v8str(scope, "signal").into())
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
.and_then(|signal| worker_abort_signal_id(scope, signal));
Some((request, request_signal_id))
}
fn set_object_string(
scope: &mut v8::PinScope<'_, '_>,
object: v8::Local<'_, v8::Object>,
key: &str,
value: &str,
) {
let Some(value) = v8::String::new(scope, value) else {
return;
};
let Some(key) = v8::String::new(scope, key) else {
return;
};
let _ = object.set(scope, key.into(), value.into());
}
fn set_object_bool(
scope: &mut v8::PinScope<'_, '_>,
object: v8::Local<'_, v8::Object>,
key: &str,
value: bool,
) {
let Some(key) = v8::String::new(scope, key) else {
return;
};
let _ = object.set(scope, key.into(), v8::Boolean::new(scope, value).into());
}
fn set_service_worker_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
event_id: ServiceWorkerEventId,
) {
crate::context_bootstrap::set_event_private_value(
scope,
event,
SERVICE_WORKER_LIFECYCLE_EVENT_ID_SLOT,
v8::BigInt::new_from_u64(scope, event_id.as_u64()).into(),
);
}
fn service_worker_lifecycle_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) -> Option<ServiceWorkerEventId> {
let value = crate::context_bootstrap::event_private_value(
scope,
event,
SERVICE_WORKER_LIFECYCLE_EVENT_ID_SLOT,
)?;
let id = service_worker_event_id_value(scope, value)?;
Some(ServiceWorkerEventId::from_u64_for_worker(id))
}
fn set_service_worker_fetch_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
event_id: ServiceWorkerEventId,
) {
crate::context_bootstrap::set_event_private_value(
scope,
event,
SERVICE_WORKER_FETCH_EVENT_ID_SLOT,
v8::BigInt::new_from_u64(scope, event_id.as_u64()).into(),
);
}
fn service_worker_fetch_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) -> Option<ServiceWorkerEventId> {
let value = crate::context_bootstrap::event_private_value(
scope,
event,
SERVICE_WORKER_FETCH_EVENT_ID_SLOT,
)?;
let id = service_worker_event_id_value(scope, value)?;
Some(ServiceWorkerEventId::from_u64_for_worker(id))
}
fn set_service_worker_message_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
event_id: ServiceWorkerEventId,
) {
crate::context_bootstrap::set_event_private_value(
scope,
event,
SERVICE_WORKER_MESSAGE_EVENT_ID_SLOT,
v8::BigInt::new_from_u64(scope, event_id.as_u64()).into(),
);
}
fn service_worker_message_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) -> Option<ServiceWorkerEventId> {
let value = crate::context_bootstrap::event_private_value(
scope,
event,
SERVICE_WORKER_MESSAGE_EVENT_ID_SLOT,
)?;
let id = service_worker_event_id_value(scope, value)?;
Some(ServiceWorkerEventId::from_u64_for_worker(id))
}
fn set_service_worker_notification_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
event_id: ServiceWorkerEventId,
) {
crate::context_bootstrap::set_event_private_value(
scope,
event,
SERVICE_WORKER_NOTIFICATION_EVENT_ID_SLOT,
v8::BigInt::new_from_u64(scope, event_id.as_u64()).into(),
);
}
fn service_worker_notification_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) -> Option<ServiceWorkerEventId> {
let value = crate::context_bootstrap::event_private_value(
scope,
event,
SERVICE_WORKER_NOTIFICATION_EVENT_ID_SLOT,
)?;
let id = service_worker_event_id_value(scope, value)?;
Some(ServiceWorkerEventId::from_u64_for_worker(id))
}
fn set_service_worker_push_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
event_id: ServiceWorkerEventId,
) {
crate::context_bootstrap::set_event_private_value(
scope,
event,
SERVICE_WORKER_PUSH_EVENT_ID_SLOT,
v8::BigInt::new_from_u64(scope, event_id.as_u64()).into(),
);
}
fn service_worker_push_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) -> Option<ServiceWorkerEventId> {
let value = crate::context_bootstrap::event_private_value(
scope,
event,
SERVICE_WORKER_PUSH_EVENT_ID_SLOT,
)?;
let id = service_worker_event_id_value(scope, value)?;
Some(ServiceWorkerEventId::from_u64_for_worker(id))
}
fn set_service_worker_sync_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
event_id: ServiceWorkerEventId,
) {
crate::context_bootstrap::set_event_private_value(
scope,
event,
SERVICE_WORKER_SYNC_EVENT_ID_SLOT,
v8::BigInt::new_from_u64(scope, event_id.as_u64()).into(),
);
}
fn service_worker_sync_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) -> Option<ServiceWorkerEventId> {
let value = crate::context_bootstrap::event_private_value(
scope,
event,
SERVICE_WORKER_SYNC_EVENT_ID_SLOT,
)?;
let id = service_worker_event_id_value(scope, value)?;
Some(ServiceWorkerEventId::from_u64_for_worker(id))
}
fn set_service_worker_periodic_sync_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
event_id: ServiceWorkerEventId,
) {
crate::context_bootstrap::set_event_private_value(
scope,
event,
SERVICE_WORKER_PERIODIC_SYNC_EVENT_ID_SLOT,
v8::BigInt::new_from_u64(scope, event_id.as_u64()).into(),
);
}
fn service_worker_periodic_sync_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) -> Option<ServiceWorkerEventId> {
let value = crate::context_bootstrap::event_private_value(
scope,
event,
SERVICE_WORKER_PERIODIC_SYNC_EVENT_ID_SLOT,
)?;
let id = service_worker_event_id_value(scope, value)?;
Some(ServiceWorkerEventId::from_u64_for_worker(id))
}
fn service_worker_event_id_value(
_scope: &mut v8::PinScope<'_, '_>,
value: v8::Local<'_, v8::Value>,
) -> Option<u64> {
let big = v8::Local::<v8::BigInt>::try_from(value).ok()?;
let (id, lossless) = big.u64_value();
lossless.then_some(id)
}
fn service_worker_wait_until_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
_rv: v8::ReturnValue<'_, v8::Value>,
) {
let event = args.this();
let lifecycle_event_id = service_worker_lifecycle_event_id(scope, event);
let fetch_event_id = service_worker_fetch_event_id(scope, event);
let message_event_id = service_worker_message_event_id(scope, event);
let notification_event_id = service_worker_notification_event_id(scope, event);
let push_event_id = service_worker_push_event_id(scope, event);
let sync_event_id = service_worker_sync_event_id(scope, event);
let periodic_sync_event_id = service_worker_periodic_sync_event_id(scope, event);
let Some((event_id, event_kind)) = lifecycle_event_id
.map(|event_id| (event_id, ServiceWorkerWaitUntilEventKind::Lifecycle))
.or_else(|| {
fetch_event_id.map(|event_id| (event_id, ServiceWorkerWaitUntilEventKind::Fetch))
})
.or_else(|| {
message_event_id.map(|event_id| (event_id, ServiceWorkerWaitUntilEventKind::Message))
})
.or_else(|| {
notification_event_id
.map(|event_id| (event_id, ServiceWorkerWaitUntilEventKind::Notification))
})
.or_else(|| push_event_id.map(|event_id| (event_id, ServiceWorkerWaitUntilEventKind::Push)))
.or_else(|| sync_event_id.map(|event_id| (event_id, ServiceWorkerWaitUntilEventKind::Sync)))
.or_else(|| {
periodic_sync_event_id
.map(|event_id| (event_id, ServiceWorkerWaitUntilEventKind::PeriodicSync))
})
else {
throw_service_worker_wait_until_invalid_state(scope);
return;
};
let is_event_active = get_worker_state(scope).is_some_and(|state| {
let state = state.borrow();
match event_kind {
ServiceWorkerWaitUntilEventKind::Lifecycle => state
.pending_service_worker_lifecycle_events
.get(&event_id)
.is_some_and(|pending| {
!pending.dispatch_finished || pending.pending_wait_until_count > 0
}),
ServiceWorkerWaitUntilEventKind::Fetch => state
.pending_service_worker_fetch_events
.get(&event_id)
.is_some_and(|pending| {
!pending.dispatch_finished || pending.pending_wait_until_count > 0
}),
ServiceWorkerWaitUntilEventKind::Message => state
.pending_service_worker_message_events
.get(&event_id)
.is_some_and(|pending| {
!pending.dispatch_finished || pending.pending_wait_until_count > 0
}),
ServiceWorkerWaitUntilEventKind::Notification => state
.pending_service_worker_notification_events
.get(&event_id)
.is_some_and(|pending| {
!pending.dispatch_finished || pending.pending_wait_until_count > 0
}),
ServiceWorkerWaitUntilEventKind::Push => state
.pending_service_worker_push_events
.get(&event_id)
.is_some_and(|pending| {
!pending.dispatch_finished || pending.pending_wait_until_count > 0
}),
ServiceWorkerWaitUntilEventKind::Sync => state
.pending_service_worker_sync_events
.get(&event_id)
.is_some_and(|pending| {
!pending.dispatch_finished || pending.pending_wait_until_count > 0
}),
ServiceWorkerWaitUntilEventKind::PeriodicSync => state
.pending_service_worker_periodic_sync_events
.get(&event_id)
.is_some_and(|pending| {
!pending.dispatch_finished || pending.pending_wait_until_count > 0
}),
}
});
if !is_event_active {
throw_service_worker_wait_until_invalid_state(scope);
return;
}
let Some(on_fulfilled) = build_service_worker_wait_until_callback(
scope,
event_id,
event_kind,
true,
service_worker_wait_until_fulfilled_callback,
) else {
return;
};
let Some(on_rejected) = build_service_worker_wait_until_callback(
scope,
event_id,
event_kind,
false,
service_worker_wait_until_rejected_callback,
) else {
return;
};
let did_register = if let Some(state) = get_worker_state(scope) {
let mut state = state.borrow_mut();
match event_kind {
ServiceWorkerWaitUntilEventKind::Lifecycle => {
if let Some(pending) = state
.pending_service_worker_lifecycle_events
.get_mut(&event_id)
{
pending.pending_wait_until_count += 1;
true
} else {
false
}
}
ServiceWorkerWaitUntilEventKind::Fetch => {
if let Some(pending) = state.pending_service_worker_fetch_events.get_mut(&event_id)
{
pending.pending_wait_until_count += 1;
true
} else {
false
}
}
ServiceWorkerWaitUntilEventKind::Message => {
if let Some(pending) = state
.pending_service_worker_message_events
.get_mut(&event_id)
{
pending.pending_wait_until_count += 1;
true
} else {
false
}
}
ServiceWorkerWaitUntilEventKind::Notification => {
if let Some(pending) = state
.pending_service_worker_notification_events
.get_mut(&event_id)
{
pending.pending_wait_until_count += 1;
true
} else {
false
}
}
ServiceWorkerWaitUntilEventKind::Push => {
if let Some(pending) = state.pending_service_worker_push_events.get_mut(&event_id) {
pending.pending_wait_until_count += 1;
true
} else {
false
}
}
ServiceWorkerWaitUntilEventKind::Sync => {
if let Some(pending) = state.pending_service_worker_sync_events.get_mut(&event_id) {
pending.pending_wait_until_count += 1;
true
} else {
false
}
}
ServiceWorkerWaitUntilEventKind::PeriodicSync => {
if let Some(pending) = state
.pending_service_worker_periodic_sync_events
.get_mut(&event_id)
{
pending.pending_wait_until_count += 1;
true
} else {
false
}
}
}
} else {
false
};
if !did_register {
throw_service_worker_wait_until_invalid_state(scope);
return;
}
if !promise_resolve_then2_after_wait_until_microtask(
scope,
args.get(0),
on_fulfilled,
on_rejected,
) {
service_worker_wait_until_settled_for_event(scope, event_id, event_kind, false);
}
}
fn throw_service_worker_wait_until_invalid_state(scope: &mut v8::PinScope<'_, '_>) {
let exception = crate::context_bootstrap::new_dom_exception_value(
scope,
"The event handler is already finished and no extend lifetime promises are outstanding.",
"InvalidStateError",
);
scope.throw_exception(exception);
}
fn promise_resolve_then2<'s>(
scope: &mut v8::PinScope<'s, '_>,
value: v8::Local<'s, v8::Value>,
on_fulfilled: v8::Local<'s, v8::Function>,
on_rejected: v8::Local<'s, v8::Function>,
) -> Option<v8::Local<'s, v8::Promise>> {
let promise = promise_resolve_value(scope, value)?;
promise.then2(scope, on_fulfilled, on_rejected)
}
fn promise_resolve_then2_after_wait_until_microtask<'s>(
scope: &mut v8::PinScope<'s, '_>,
value: v8::Local<'s, v8::Value>,
on_fulfilled: v8::Local<'s, v8::Function>,
on_rejected: v8::Local<'s, v8::Function>,
) -> bool {
let Some(extra_fulfilled) =
v8::Function::builder(service_worker_wait_until_extra_fulfilled_callback).build(scope)
else {
return false;
};
let Some(extra_rejected) =
v8::Function::builder(service_worker_wait_until_extra_rejected_callback).build(scope)
else {
return false;
};
let Some(promise) = promise_resolve_value(scope, value) else {
return false;
};
let Some(wait_until_promise) = promise.then2(scope, extra_fulfilled, extra_rejected) else {
return false;
};
wait_until_promise
.then2(scope, on_fulfilled, on_rejected)
.is_some()
}
fn promise_resolve_value<'s>(
scope: &mut v8::PinScope<'s, '_>,
value: v8::Local<'s, v8::Value>,
) -> Option<v8::Local<'s, v8::Promise>> {
let promise = if let Ok(promise) = v8::Local::<v8::Promise>::try_from(value) {
promise
} else {
let resolver = v8::PromiseResolver::new(scope)?;
let promise = resolver.get_promise(scope);
if resolver.resolve(scope, value) != Some(true) {
return None;
}
promise
};
Some(promise)
}
fn service_worker_wait_until_extra_fulfilled_callback<'s>(
_scope: &mut v8::PinScope<'s, '_>,
_args: v8::FunctionCallbackArguments<'s>,
_rv: v8::ReturnValue<'_, v8::Value>,
) {
}
fn service_worker_wait_until_extra_rejected_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
_rv: v8::ReturnValue<'_, v8::Value>,
) {
scope.throw_exception(args.get(0));
}
fn build_service_worker_wait_until_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
event_id: ServiceWorkerEventId,
event_kind: ServiceWorkerWaitUntilEventKind,
fulfilled: bool,
callback: impl v8::MapFnTo<v8::FunctionCallback>,
) -> Option<v8::Local<'s, v8::Function>> {
let data = ServiceWorkerWaitUntilCallbackDataDeclaration {
event_id: v8::BigInt::new_from_u64(scope, event_id.as_u64()),
event_kind: v8::String::new(scope, service_worker_wait_until_event_kind_name(event_kind))?,
fulfilled,
}
.bind(scope)
.ok()?;
v8::Function::builder(callback)
.data(data.into())
.build(scope)
}
#[derive(WebApiObject)]
#[webapi(plain)]
struct ServiceWorkerWaitUntilCallbackDataDeclaration<'scope> {
#[webapi(data_property, enumerable)]
event_id: v8::Local<'scope, v8::BigInt>,
#[webapi(data_property, enumerable)]
event_kind: v8::Local<'scope, v8::String>,
#[webapi(data_property, enumerable)]
fulfilled: bool,
}
fn service_worker_wait_until_event_kind_name(
event_kind: ServiceWorkerWaitUntilEventKind,
) -> &'static str {
match event_kind {
ServiceWorkerWaitUntilEventKind::Lifecycle => "lifecycle",
ServiceWorkerWaitUntilEventKind::Fetch => "fetch",
ServiceWorkerWaitUntilEventKind::Message => "message",
ServiceWorkerWaitUntilEventKind::Notification => "notification",
ServiceWorkerWaitUntilEventKind::Push => "push",
ServiceWorkerWaitUntilEventKind::Sync => "sync",
ServiceWorkerWaitUntilEventKind::PeriodicSync => "periodicsync",
}
}
fn service_worker_wait_until_event_kind_from_value(
scope: &mut v8::PinScope<'_, '_>,
value: v8::Local<'_, v8::Value>,
) -> Option<ServiceWorkerWaitUntilEventKind> {
match value.to_string(scope)?.to_rust_string_lossy(scope).as_str() {
"lifecycle" => Some(ServiceWorkerWaitUntilEventKind::Lifecycle),
"fetch" => Some(ServiceWorkerWaitUntilEventKind::Fetch),
"message" => Some(ServiceWorkerWaitUntilEventKind::Message),
"notification" => Some(ServiceWorkerWaitUntilEventKind::Notification),
"push" => Some(ServiceWorkerWaitUntilEventKind::Push),
"sync" => Some(ServiceWorkerWaitUntilEventKind::Sync),
"periodicsync" => Some(ServiceWorkerWaitUntilEventKind::PeriodicSync),
_ => None,
}
}
fn service_worker_wait_until_fulfilled_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
_rv: v8::ReturnValue<'_, v8::Value>,
) {
service_worker_wait_until_settled(scope, &args, true);
}
fn service_worker_wait_until_rejected_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
_rv: v8::ReturnValue<'_, v8::Value>,
) {
service_worker_wait_until_settled(scope, &args, false);
}
fn service_worker_wait_until_settled<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: &v8::FunctionCallbackArguments<'s>,
fulfilled: bool,
) {
let Some(data) = v8::Local::<v8::Object>::try_from(args.data()).ok() else {
return;
};
let Some(event_id) = data
.get(scope, v8str(scope, "eventId").into())
.and_then(|value| service_worker_event_id_value(scope, value))
.map(ServiceWorkerEventId::from_u64_for_worker)
else {
return;
};
let Some(event_kind) = data
.get(scope, v8str(scope, "eventKind").into())
.and_then(|value| service_worker_wait_until_event_kind_from_value(scope, value))
else {
return;
};
service_worker_wait_until_settled_for_event(scope, event_id, event_kind, fulfilled);
}
fn service_worker_wait_until_settled_for_event(
scope: &mut v8::PinScope<'_, '_>,
event_id: ServiceWorkerEventId,
event_kind: ServiceWorkerWaitUntilEventKind,
fulfilled: bool,
) {
let Some(state) = get_worker_state(scope) else {
return;
};
{
let mut state = state.borrow_mut();
match event_kind {
ServiceWorkerWaitUntilEventKind::Lifecycle => {
let Some(pending) = state
.pending_service_worker_lifecycle_events
.get_mut(&event_id)
else {
return;
};
pending.pending_wait_until_count =
pending.pending_wait_until_count.saturating_sub(1);
if !fulfilled {
pending.completion.result =
Err("service worker waitUntil promise rejected".to_owned());
}
}
ServiceWorkerWaitUntilEventKind::Fetch => {
let Some(pending) = state.pending_service_worker_fetch_events.get_mut(&event_id)
else {
return;
};
pending.pending_wait_until_count =
pending.pending_wait_until_count.saturating_sub(1);
}
ServiceWorkerWaitUntilEventKind::Message => {
let Some(pending) = state
.pending_service_worker_message_events
.get_mut(&event_id)
else {
return;
};
pending.pending_wait_until_count =
pending.pending_wait_until_count.saturating_sub(1);
if !fulfilled {
pending.completion.result =
Err("service worker waitUntil promise rejected".to_owned());
}
}
ServiceWorkerWaitUntilEventKind::Notification => {
let Some(pending) = state
.pending_service_worker_notification_events
.get_mut(&event_id)
else {
return;
};
pending.pending_wait_until_count =
pending.pending_wait_until_count.saturating_sub(1);
if !fulfilled {
pending.completion.result =
Err("service worker waitUntil promise rejected".to_owned());
}
}
ServiceWorkerWaitUntilEventKind::Push => {
let Some(pending) = state.pending_service_worker_push_events.get_mut(&event_id)
else {
return;
};
pending.pending_wait_until_count =
pending.pending_wait_until_count.saturating_sub(1);
if !fulfilled {
pending.completion.result =
Err("service worker waitUntil promise rejected".to_owned());
}
}
ServiceWorkerWaitUntilEventKind::Sync => {
let Some(pending) = state.pending_service_worker_sync_events.get_mut(&event_id)
else {
return;
};
pending.pending_wait_until_count =
pending.pending_wait_until_count.saturating_sub(1);
if !fulfilled {
pending.completion.result =
Err("service worker waitUntil promise rejected".to_owned());
}
}
ServiceWorkerWaitUntilEventKind::PeriodicSync => {
let Some(pending) = state
.pending_service_worker_periodic_sync_events
.get_mut(&event_id)
else {
return;
};
pending.pending_wait_until_count =
pending.pending_wait_until_count.saturating_sub(1);
if !fulfilled {
pending.completion.result =
Err("service worker waitUntil promise rejected".to_owned());
}
}
}
}
match event_kind {
ServiceWorkerWaitUntilEventKind::Lifecycle => {
maybe_send_service_worker_lifecycle_completion(&state, event_id);
}
ServiceWorkerWaitUntilEventKind::Fetch => {
maybe_send_service_worker_fetch_completion(&state, event_id, scope);
}
ServiceWorkerWaitUntilEventKind::Message => {
maybe_send_service_worker_message_completion(&state, event_id);
}
ServiceWorkerWaitUntilEventKind::Notification => {
maybe_send_service_worker_notification_completion(&state, event_id);
}
ServiceWorkerWaitUntilEventKind::Push => {
maybe_send_service_worker_push_completion(&state, event_id);
}
ServiceWorkerWaitUntilEventKind::Sync => {
maybe_send_service_worker_sync_completion(&state, event_id);
}
ServiceWorkerWaitUntilEventKind::PeriodicSync => {
maybe_send_service_worker_periodic_sync_completion(&state, event_id);
}
}
}
fn service_worker_respond_with_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
_rv: v8::ReturnValue<'_, v8::Value>,
) {
let event = args.this();
let Some(event_id) = service_worker_fetch_event_id(scope, event) else {
throw_service_worker_wait_until_invalid_state(scope);
return;
};
let is_event_active = get_worker_state(scope).is_some_and(|state| {
let state = state.borrow();
state
.pending_service_worker_fetch_events
.get(&event_id)
.is_some_and(|pending| !pending.dispatch_finished && !pending.respond_with_called)
});
if !is_event_active {
throw_service_worker_wait_until_invalid_state(scope);
return;
}
let Some(on_fulfilled) = build_service_worker_respond_with_callback(
scope,
event_id,
true,
service_worker_respond_with_fulfilled_callback,
) else {
return;
};
let Some(on_rejected) = build_service_worker_respond_with_callback(
scope,
event_id,
false,
service_worker_respond_with_rejected_callback,
) else {
return;
};
let Some(on_lifetime_fulfilled) = build_service_worker_respond_with_lifetime_callback(
scope,
event_id,
service_worker_respond_with_lifetime_fulfilled_callback,
) else {
return;
};
let Some(on_lifetime_rejected) = build_service_worker_respond_with_lifetime_callback(
scope,
event_id,
service_worker_respond_with_lifetime_rejected_callback,
) else {
return;
};
let did_register = if let Some(state) = get_worker_state(scope) {
let mut state = state.borrow_mut();
if let Some(pending) = state.pending_service_worker_fetch_events.get_mut(&event_id) {
pending.respond_with_called = true;
pending.pending_respond_with = true;
pending.pending_wait_until_count += 1;
true
} else {
false
}
} else {
false
};
if !did_register {
throw_service_worker_wait_until_invalid_state(scope);
return;
}
set_event_stop_immediate_propagation(scope, event);
let Some(settlement_promise) =
promise_resolve_then2(scope, args.get(0), on_fulfilled, on_rejected)
else {
service_worker_respond_with_settled_for_event(
scope,
event_id,
ServiceWorkerFetchResult::Failure(
"FetchEvent.respondWith failed to attach promise reactions".to_owned(),
),
);
service_worker_respond_with_lifetime_settled_for_event(scope, event_id);
return;
};
if settlement_promise
.then2(scope, on_lifetime_fulfilled, on_lifetime_rejected)
.is_none()
{
service_worker_respond_with_lifetime_settled_for_event(scope, event_id);
}
}
fn build_service_worker_respond_with_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
event_id: ServiceWorkerEventId,
fulfilled: bool,
callback: impl v8::MapFnTo<v8::FunctionCallback>,
) -> Option<v8::Local<'s, v8::Function>> {
let data = ServiceWorkerRespondWithCallbackDataDeclaration {
event_id: v8::BigInt::new_from_u64(scope, event_id.as_u64()),
fulfilled,
}
.bind(scope)
.ok()?;
v8::Function::builder(callback)
.data(data.into())
.build(scope)
}
fn service_worker_respond_with_fulfilled_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
_rv: v8::ReturnValue<'_, v8::Value>,
) {
service_worker_respond_with_settled(scope, &args, true);
}
fn service_worker_respond_with_rejected_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
_rv: v8::ReturnValue<'_, v8::Value>,
) {
service_worker_respond_with_settled(scope, &args, false);
}
fn service_worker_respond_with_settled<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: &v8::FunctionCallbackArguments<'s>,
fulfilled: bool,
) {
let Some(data) = v8::Local::<v8::Object>::try_from(args.data()).ok() else {
return;
};
let Some(event_id) = data
.get(scope, v8str(scope, "eventId").into())
.and_then(|value| service_worker_event_id_value(scope, value))
.map(ServiceWorkerEventId::from_u64_for_worker)
else {
return;
};
let result = if fulfilled {
match materialize_response_object_head_for_service_worker_respond_with(
scope,
args.get(0),
"FetchEvent.respondWith",
) {
Ok((head, response)) => {
if let Some(error) =
service_worker_respond_with_response_head_rejection(scope, event_id, &head)
{
service_worker_respond_with_settled_for_event(
scope,
event_id,
ServiceWorkerFetchResult::Failure(error),
);
return;
}
let body_source_id = new_network_body_source_id();
let (body, stream_cancel_handle) =
build_service_worker_respond_with_stream_chunk_callback(
scope,
event_id,
body_source_id,
)
.map(|callback| {
materialize_response_object_body_with_chunk_callback(
scope,
response,
"FetchEvent.respondWith",
callback,
)
})
.unwrap_or_else(|| {
(
materialize_response_object_body(
scope,
response,
"FetchEvent.respondWith",
),
None,
)
});
match body {
MaterializedResponseBody::Ready(body) => ServiceWorkerFetchResult::Response(
service_worker_fetch_response_from_materialized(head, body),
),
MaterializedResponseBody::Pending(promise) => {
let stream_body = stream_cancel_handle.is_some();
let started_head = stream_body
.then(|| service_worker_fetch_response_head_from_materialized(&head));
let stream_cancel_handle =
stream_cancel_handle.map(|handle| (body_source_id, handle));
if service_worker_respond_with_pending_body(
scope,
event_id,
head,
promise,
stream_cancel_handle,
) {
if stream_body {
resolve_service_worker_fetch_handled_for_event(scope, event_id);
}
if let Some(started_head) = started_head {
send_service_worker_fetch_stream_started(
scope,
event_id,
body_source_id,
started_head,
);
}
return;
}
ServiceWorkerFetchResult::Failure(
"FetchEvent.respondWith failed to attach response body reactions"
.to_owned(),
)
}
MaterializedResponseBody::Failure(error) => {
ServiceWorkerFetchResult::Failure(error)
}
}
}
Err(error) => ServiceWorkerFetchResult::Failure(error),
}
} else {
ServiceWorkerFetchResult::Failure(format!(
"FetchEvent.respondWith promise rejected: {}",
js_value_error_string(scope, args.get(0))
))
};
service_worker_respond_with_settled_for_event(scope, event_id, result);
}
fn service_worker_respond_with_response_head_rejection(
scope: &mut v8::PinScope<'_, '_>,
event_id: ServiceWorkerEventId,
head: &MaterializedResponseHead,
) -> Option<String> {
if head.response_type != "opaque" {
return None;
}
let state = get_worker_state(scope)?;
let state = state.borrow();
let pending = state.pending_service_worker_fetch_events.get(&event_id)?;
crate::service_worker_runtime::service_worker_opaque_response_rejection(
pending.request_mode,
pending.request_destination,
)
}
fn build_service_worker_respond_with_lifetime_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
event_id: ServiceWorkerEventId,
callback: impl v8::MapFnTo<v8::FunctionCallback>,
) -> Option<v8::Local<'s, v8::Function>> {
let data = ServiceWorkerRespondWithLifetimeCallbackDataDeclaration {
event_id: v8::BigInt::new_from_u64(scope, event_id.as_u64()),
}
.bind(scope)
.ok()?;
v8::Function::builder(callback)
.data(data.into())
.build(scope)
}
fn service_worker_respond_with_lifetime_fulfilled_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
_rv: v8::ReturnValue<'_, v8::Value>,
) {
service_worker_respond_with_lifetime_settled(scope, &args);
}
fn service_worker_respond_with_lifetime_rejected_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
_rv: v8::ReturnValue<'_, v8::Value>,
) {
service_worker_respond_with_lifetime_settled(scope, &args);
}
fn service_worker_respond_with_lifetime_settled<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: &v8::FunctionCallbackArguments<'s>,
) {
let Some(data) = v8::Local::<v8::Object>::try_from(args.data()).ok() else {
return;
};
let Some(event_id) = data
.get(scope, v8str(scope, "eventId").into())
.and_then(|value| service_worker_event_id_value(scope, value))
.map(ServiceWorkerEventId::from_u64_for_worker)
else {
return;
};
service_worker_respond_with_lifetime_settled_for_event(scope, event_id);
}
fn service_worker_respond_with_lifetime_settled_for_event(
scope: &mut v8::PinScope<'_, '_>,
event_id: ServiceWorkerEventId,
) {
let Some(state) = get_worker_state(scope) else {
return;
};
{
let mut state = state.borrow_mut();
let Some(pending) = state.pending_service_worker_fetch_events.get_mut(&event_id) else {
return;
};
pending.pending_wait_until_count = pending.pending_wait_until_count.saturating_sub(1);
}
maybe_send_service_worker_fetch_completion(&state, event_id, scope);
}
fn service_worker_fetch_response_from_materialized(
head: MaterializedResponseHead,
body: Vec<u8>,
) -> ServiceWorkerFetchResponse {
let response = head.with_body(body);
ServiceWorkerFetchResponse {
final_url: response.final_url,
response_type: response.response_type,
redirected: response.redirected,
status: response.status,
status_text: response.status_text,
headers: response.headers,
body: response.body,
}
}
fn service_worker_fetch_response_head_from_materialized(
head: &MaterializedResponseHead,
) -> MaterializedServiceWorkerFetchResponseHead {
MaterializedServiceWorkerFetchResponseHead {
status_text: head.status_text.clone(),
final_url: head.final_url.clone(),
response_type: head.response_type.clone(),
redirected: head.redirected,
status: head.status,
headers: head.headers.clone(),
}
}
fn send_service_worker_fetch_stream_started(
scope: &mut v8::PinScope<'_, '_>,
event_id: ServiceWorkerEventId,
body_source_id: NetworkBodySourceId,
response_head: MaterializedServiceWorkerFetchResponseHead,
) {
let Some(state) = get_worker_state(scope) else {
return;
};
let Some((parent_tx, version_id, run)) = ({
let state = state.borrow();
state
.pending_service_worker_fetch_events
.get(&event_id)
.map(|pending| {
(
state.parent_tx.clone(),
pending.completion.owner.version_id(),
pending.completion.owner.cloned_run_identity(),
)
})
}) else {
return;
};
let _ = parent_tx.send(WorkerToParentMessage::ServiceWorkerFetchStreamStarted(
ServiceWorkerFetchStreamStarted {
event_id,
owner: crate::service_worker_runtime::ServiceWorkerRunOwner::new(version_id, run),
body_source_id,
response_head,
},
));
}
fn service_worker_respond_with_pending_body<'s>(
scope: &mut v8::PinScope<'s, '_>,
event_id: ServiceWorkerEventId,
head: MaterializedResponseHead,
promise: v8::Local<'s, v8::Promise>,
stream_cancel_handle: Option<(NetworkBodySourceId, v8::Global<v8::Object>)>,
) -> bool {
let Some(on_fulfilled) = build_service_worker_respond_with_body_callback(
scope,
event_id,
service_worker_respond_with_body_fulfilled_callback,
) else {
return false;
};
let Some(on_rejected) = build_service_worker_respond_with_body_callback(
scope,
event_id,
service_worker_respond_with_body_rejected_callback,
) else {
return false;
};
let Some(state) = get_worker_state(scope) else {
return true;
};
{
let mut state = state.borrow_mut();
let Some(pending) = state.pending_service_worker_fetch_events.get_mut(&event_id) else {
return true;
};
pending.pending_respond_with_response = Some(head);
if let Some((body_source_id, cancel_handle)) = stream_cancel_handle {
pending.pending_respond_with_stream_body_source_id = Some(body_source_id);
pending.pending_respond_with_stream_cancel_handle = Some(cancel_handle);
} else {
pending.pending_respond_with_stream_body_source_id = None;
pending.pending_respond_with_stream_cancel_handle = None;
}
}
if promise.then2(scope, on_fulfilled, on_rejected).is_some() {
return true;
}
if let Some(state) = get_worker_state(scope)
&& let Some(pending) = state
.borrow_mut()
.pending_service_worker_fetch_events
.get_mut(&event_id)
{
pending.pending_respond_with_response = None;
pending.pending_respond_with_stream_body_source_id = None;
pending.pending_respond_with_stream_cancel_handle = None;
}
false
}
fn cancel_service_worker_fetch_stream_in_context(
scope: &mut v8::PinScope<'_, '_>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
body_source_id: NetworkBodySourceId,
) {
let cancel_handle = {
let mut state = state.borrow_mut();
let Some(pending) = state.pending_service_worker_fetch_events.get_mut(&event_id) else {
return;
};
if pending.pending_respond_with_stream_body_source_id != Some(body_source_id) {
return;
}
pending.pending_respond_with_stream_body_source_id = None;
pending.pending_respond_with_stream_cancel_handle.take()
};
let Some(cancel_handle) = cancel_handle else {
return;
};
let stream = v8::Local::new(scope, &cancel_handle);
let reason = "The operation was aborted.";
let reason_value: v8::Local<'_, v8::Value> = match v8_string(scope, reason) {
Some(reason) => reason.into(),
None => v8::undefined(scope).into(),
};
crate::context_bootstrap::cancel_readable_stream(scope, stream, reason_value);
service_worker_respond_with_body_settled_for_event(
scope,
event_id,
Err(format!(
"FetchEvent.respondWith stream body was canceled: {reason}"
)),
);
}
fn abort_service_worker_fetch_request_signal_in_context(
scope: &mut v8::PinScope<'_, '_>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
reason_payload: Option<V8StructuredClonePayload>,
) {
let Some(signal_id) = state
.borrow()
.pending_service_worker_fetch_events
.get(&event_id)
.and_then(|pending| pending.request_signal_id)
else {
return;
};
let reason = reason_payload
.as_ref()
.and_then(|payload| {
structured_deserialize_value_for_message_event(scope, payload).map(|(value, _)| value)
})
.unwrap_or_else(|| worker_abort_error_value(scope));
abort_worker_signal_by_id(scope, signal_id, reason);
}
pub(super) fn start_service_worker_navigation_preload_response(
isolate: &mut v8::OwnedIsolate,
context: &v8::Global<v8::Context>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
started: ServiceWorkerNavigationPreloadResponseStarted,
) {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let ctx = v8::Local::new(scope, context);
let scope = &mut v8::ContextScope::new(scope, ctx);
start_service_worker_navigation_preload_response_in_context(scope, state, started);
}
fn start_service_worker_navigation_preload_response_in_context(
scope: &mut v8::PinScope<'_, '_>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
started: ServiceWorkerNavigationPreloadResponseStarted,
) {
let Some(resolver) = ({
let mut state = state.borrow_mut();
let Some(preload) = state
.pending_service_worker_navigation_preloads
.get_mut(&started.event_id)
else {
return;
};
if preload.owner != started.owner || preload.body_source_id.is_some() {
return;
}
preload.body_source_id = Some(started.body_source_id);
preload.resolver.take()
}) else {
return;
};
let head = moli_fetch::ResponseHead {
status_text: Some(started.response_head.status_text.clone()),
final_url: started
.response_head
.final_url
.clone()
.unwrap_or_else(|| started.request_url.clone()),
status: started.response_head.status,
headers: started.response_head.headers.clone(),
request_cookie_report: None,
cookie_set_reports: Vec::new(),
redirected: started.response_head.redirected,
redirect_chain: Vec::new(),
from_cache: false,
negotiated_http_version: None,
};
let response_object = build_navigation_preload_response_object_from_stream_for_request_mode(
scope,
&started.request_url,
crate::network_host::FetchResponseRequest {
method: &started.request_method,
mode: started.request_mode,
},
head,
started.body_source_id,
);
let resolver = v8::Local::new(scope, resolver);
let _ = resolver.resolve(scope, response_object.into());
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
pub(super) fn enqueue_service_worker_navigation_preload_stream_chunk(
isolate: &mut v8::OwnedIsolate,
context: &v8::Global<v8::Context>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
chunk: ServiceWorkerNavigationPreloadStreamChunk,
) {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let ctx = v8::Local::new(scope, context);
let scope = &mut v8::ContextScope::new(scope, ctx);
if !service_worker_navigation_preload_chunk_matches_pending_event(state, &chunk) {
return;
}
enqueue_pending_network_body_chunk(scope, chunk.body_source_id, chunk.bytes);
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
fn service_worker_navigation_preload_chunk_matches_pending_event(
state: &Rc<RefCell<super::WorkerGlobalState>>,
chunk: &ServiceWorkerNavigationPreloadStreamChunk,
) -> bool {
state
.borrow()
.pending_service_worker_navigation_preloads
.get(&chunk.event_id)
.is_some_and(|preload| preload.body_source_id == Some(chunk.body_source_id))
}
pub(super) fn finish_service_worker_navigation_preload_stream(
isolate: &mut v8::OwnedIsolate,
context: &v8::Global<v8::Context>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
finished: ServiceWorkerNavigationPreloadStreamFinished,
) {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let ctx = v8::Local::new(scope, context);
let scope = &mut v8::ContextScope::new(scope, ctx);
if !service_worker_navigation_preload_finish_matches_pending_event(state, &finished) {
return;
}
match finished.result {
Ok(()) => {
close_pending_network_body_stream(scope, finished.body_source_id);
}
Err(message) => {
let reason = v8_string(scope, &message)
.map(|message| v8::Exception::type_error(scope, message))
.unwrap_or_else(|| v8::undefined(scope).into());
error_pending_network_body_stream_with_reason(
scope,
finished.body_source_id,
message,
reason,
);
}
}
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
state
.borrow_mut()
.pending_service_worker_navigation_preloads
.remove(&finished.event_id);
}
fn service_worker_navigation_preload_finish_matches_pending_event(
state: &Rc<RefCell<super::WorkerGlobalState>>,
finished: &ServiceWorkerNavigationPreloadStreamFinished,
) -> bool {
let state = state.borrow();
let Some(preload) = state
.pending_service_worker_navigation_preloads
.get(&finished.event_id)
else {
return false;
};
!(preload.owner != finished.owner || preload.body_source_id != Some(finished.body_source_id))
}
pub(super) fn fail_service_worker_navigation_preload_response(
isolate: &mut v8::OwnedIsolate,
context: &v8::Global<v8::Context>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
failure: ServiceWorkerNavigationPreloadFailure,
) {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let ctx = v8::Local::new(scope, context);
let scope = &mut v8::ContextScope::new(scope, ctx);
fail_service_worker_navigation_preload_response_in_context(scope, state, failure);
}
fn fail_service_worker_navigation_preload_response_in_context(
scope: &mut v8::PinScope<'_, '_>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
failure: ServiceWorkerNavigationPreloadFailure,
) {
let Some(resolver) = ({
let mut state = state.borrow_mut();
let Some(preload) = state
.pending_service_worker_navigation_preloads
.get_mut(&failure.event_id)
else {
return;
};
if preload.owner != failure.owner {
return;
}
preload.resolver.take()
}) else {
return;
};
let resolver = v8::Local::new(scope, resolver);
let reason =
crate::context_bootstrap::new_dom_exception_value(scope, &failure.message, "NetworkError");
let _ = resolver.reject(scope, reason);
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
state
.borrow_mut()
.pending_service_worker_navigation_preloads
.remove(&failure.event_id);
}
fn build_service_worker_respond_with_stream_chunk_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
event_id: ServiceWorkerEventId,
body_source_id: NetworkBodySourceId,
) -> Option<v8::Local<'s, v8::Function>> {
let data = ServiceWorkerRespondWithStreamChunkCallbackDataDeclaration {
event_id: v8::BigInt::new_from_u64(scope, event_id.as_u64()),
body_source_id: v8::BigInt::new_from_u64(scope, body_source_id),
}
.bind(scope)
.ok()?;
v8::Function::builder(service_worker_respond_with_stream_chunk_callback)
.data(data.into())
.build(scope)
}
fn service_worker_respond_with_stream_chunk_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
_rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(data) = v8::Local::<v8::Object>::try_from(args.data()).ok() else {
return;
};
let Some(event_id) = data
.get(scope, v8str(scope, "eventId").into())
.and_then(|value| service_worker_event_id_value(scope, value))
.map(ServiceWorkerEventId::from_u64_for_worker)
else {
return;
};
let Some(body_source_id) = data
.get(scope, v8str(scope, "bodySourceId").into())
.and_then(|value| service_worker_event_id_value(scope, value))
else {
return;
};
let Some(state) = get_worker_state(scope) else {
return;
};
if !service_worker_stream_chunk_matches_pending_event(&state, event_id, body_source_id) {
return;
}
let Some(bytes) = crate::blob::buffer_source_bytes_from_value(scope, args.get(0)) else {
throw_type_error(scope, "ReadableStream body chunk bytes are unavailable.");
return;
};
let parent_tx = state.borrow().parent_tx.clone();
let _ = parent_tx.send(WorkerToParentMessage::ServiceWorkerFetchStreamChunk(
ServiceWorkerFetchStreamChunk {
event_id,
body_source_id,
bytes,
},
));
}
fn service_worker_stream_chunk_matches_pending_event(
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
body_source_id: NetworkBodySourceId,
) -> bool {
state
.borrow()
.pending_service_worker_fetch_events
.get(&event_id)
.is_some_and(|pending| {
pending.pending_respond_with_stream_body_source_id == Some(body_source_id)
})
}
fn build_service_worker_respond_with_body_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
event_id: ServiceWorkerEventId,
callback: impl v8::MapFnTo<v8::FunctionCallback>,
) -> Option<v8::Local<'s, v8::Function>> {
let data = ServiceWorkerRespondWithBodyCallbackDataDeclaration {
event_id: v8::BigInt::new_from_u64(scope, event_id.as_u64()),
}
.bind(scope)
.ok()?;
v8::Function::builder(callback)
.data(data.into())
.build(scope)
}
fn service_worker_respond_with_body_fulfilled_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
_rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(event_id) = service_worker_respond_with_body_callback_event_id(scope, &args) else {
return;
};
let body = materialized_body_bytes_from_value(scope, args.get(0))
.map_err(|error| format!("FetchEvent.respondWith {error}"));
service_worker_respond_with_body_settled_for_event(scope, event_id, body);
}
fn service_worker_respond_with_body_rejected_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
_rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(event_id) = service_worker_respond_with_body_callback_event_id(scope, &args) else {
return;
};
let reason = js_value_error_string(scope, args.get(0));
service_worker_respond_with_body_settled_for_event(
scope,
event_id,
Err(format!(
"FetchEvent.respondWith failed to materialize Response body: {reason}"
)),
);
}
fn service_worker_respond_with_body_callback_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: &v8::FunctionCallbackArguments<'s>,
) -> Option<ServiceWorkerEventId> {
v8::Local::<v8::Object>::try_from(args.data())
.ok()
.and_then(|data| {
data.get(scope, v8str(scope, "eventId").into())
.and_then(|value| service_worker_event_id_value(scope, value))
})
.map(ServiceWorkerEventId::from_u64_for_worker)
}
fn service_worker_respond_with_body_settled_for_event(
scope: &mut v8::PinScope<'_, '_>,
event_id: ServiceWorkerEventId,
body: Result<Vec<u8>, String>,
) {
let Some(state) = get_worker_state(scope) else {
return;
};
let handled_settled = {
let mut state = state.borrow_mut();
let Some(pending) = state.pending_service_worker_fetch_events.get_mut(&event_id) else {
return;
};
let result = match body {
Ok(body) => {
let Some(head) = pending.pending_respond_with_response.take() else {
return;
};
pending.pending_respond_with_stream_body_source_id = None;
pending.pending_respond_with_stream_cancel_handle = None;
ServiceWorkerFetchResult::Response(service_worker_fetch_response_from_materialized(
head, body,
))
}
Err(error) => {
pending.pending_respond_with_response = None;
pending.pending_respond_with_stream_body_source_id = None;
pending.pending_respond_with_stream_cancel_handle = None;
ServiceWorkerFetchResult::Failure(error)
}
};
pending.pending_respond_with = false;
pending.completion.result = result;
settle_service_worker_fetch_handled_for_pending(scope, pending)
};
if handled_settled {
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
maybe_send_service_worker_fetch_completion(&state, event_id, scope);
}
fn service_worker_respond_with_settled_for_event(
scope: &mut v8::PinScope<'_, '_>,
event_id: ServiceWorkerEventId,
result: ServiceWorkerFetchResult,
) {
let Some(state) = get_worker_state(scope) else {
return;
};
let handled_settled = {
let mut state = state.borrow_mut();
let Some(pending) = state.pending_service_worker_fetch_events.get_mut(&event_id) else {
return;
};
pending.pending_respond_with_response = None;
pending.pending_respond_with_stream_body_source_id = None;
pending.pending_respond_with_stream_cancel_handle = None;
pending.pending_respond_with = false;
pending.completion.result = result;
settle_service_worker_fetch_handled_for_pending(scope, pending)
};
if handled_settled {
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
maybe_send_service_worker_fetch_completion(&state, event_id, scope);
}
fn settle_service_worker_fetch_handled_for_pending(
scope: &mut v8::PinScope<'_, '_>,
pending: &mut PendingServiceWorkerFetchEvent,
) -> bool {
let Some(resolver) = pending.handled_resolver.take() else {
return false;
};
let resolver = v8::Local::new(scope, resolver);
match &pending.completion.result {
ServiceWorkerFetchResult::Response(_) | ServiceWorkerFetchResult::Fallback => {
let value = v8::undefined(scope);
let _ = resolver.resolve(scope, value.into());
}
ServiceWorkerFetchResult::Failure(message) => {
let reason =
crate::context_bootstrap::new_dom_exception_value(scope, message, "NetworkError");
let _ = resolver.reject(scope, reason);
}
}
true
}
fn resolve_service_worker_fetch_handled_for_event(
scope: &mut v8::PinScope<'_, '_>,
event_id: ServiceWorkerEventId,
) {
let Some(state) = get_worker_state(scope) else {
return;
};
let handled_settled = {
let mut state = state.borrow_mut();
let Some(pending) = state.pending_service_worker_fetch_events.get_mut(&event_id) else {
return;
};
let Some(resolver) = pending.handled_resolver.take() else {
return;
};
let resolver = v8::Local::new(scope, resolver);
let value = v8::undefined(scope);
let _ = resolver.resolve(scope, value.into());
true
};
if handled_settled {
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
}
fn settle_service_worker_fetch_handled_after_dispatch(
scope: &mut v8::PinScope<'_, '_>,
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
) {
let handled_settled = {
let mut state = state.borrow_mut();
let Some(pending) = state.pending_service_worker_fetch_events.get_mut(&event_id) else {
return;
};
if !pending.dispatch_finished || pending.pending_respond_with {
return;
}
settle_service_worker_fetch_handled_for_pending(scope, pending)
};
if handled_settled {
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
}
fn js_value_error_string<'s>(
scope: &mut v8::PinScope<'s, '_>,
value: v8::Local<'s, v8::Value>,
) -> String {
value
.to_string(scope)
.map(|value| value.to_rust_string_lossy(scope))
.filter(|value| !value.is_empty())
.unwrap_or_else(|| "unknown rejection".to_owned())
}
fn mark_service_worker_lifecycle_dispatch_finished(
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
) {
let mut state = state.borrow_mut();
if let Some(pending) = state
.pending_service_worker_lifecycle_events
.get_mut(&event_id)
{
pending.dispatch_finished = true;
}
}
fn mark_service_worker_fetch_dispatch_finished(
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
) {
let mut state = state.borrow_mut();
if let Some(pending) = state.pending_service_worker_fetch_events.get_mut(&event_id) {
pending.dispatch_finished = true;
}
}
fn mark_service_worker_fetch_default_prevented(
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
) {
let mut state = state.borrow_mut();
if let Some(pending) = state.pending_service_worker_fetch_events.get_mut(&event_id)
&& !pending.respond_with_called
{
pending.completion.result = ServiceWorkerFetchResult::Failure(
"FetchEvent was canceled without respondWith().".to_owned(),
);
}
}
fn mark_service_worker_message_dispatch_finished(
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
) {
let mut state = state.borrow_mut();
if let Some(pending) = state
.pending_service_worker_message_events
.get_mut(&event_id)
{
pending.dispatch_finished = true;
}
}
fn mark_service_worker_notification_dispatch_finished(
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
) {
let mut state = state.borrow_mut();
if let Some(pending) = state
.pending_service_worker_notification_events
.get_mut(&event_id)
{
pending.dispatch_finished = true;
}
}
fn mark_service_worker_push_dispatch_finished(
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
) {
let mut state = state.borrow_mut();
if let Some(pending) = state.pending_service_worker_push_events.get_mut(&event_id) {
pending.dispatch_finished = true;
}
}
fn mark_service_worker_sync_dispatch_finished(
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
) {
let mut state = state.borrow_mut();
if let Some(pending) = state.pending_service_worker_sync_events.get_mut(&event_id) {
pending.dispatch_finished = true;
}
}
fn mark_service_worker_periodic_sync_dispatch_finished(
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
) {
let mut state = state.borrow_mut();
if let Some(pending) = state
.pending_service_worker_periodic_sync_events
.get_mut(&event_id)
{
pending.dispatch_finished = true;
}
}
fn maybe_send_service_worker_lifecycle_completion(
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
) {
let (parent_tx, completion) = {
let mut state = state.borrow_mut();
let Some(pending) = state.pending_service_worker_lifecycle_events.get(&event_id) else {
return;
};
if !pending.dispatch_finished || pending.pending_wait_until_count > 0 {
return;
}
let completion = pending.completion.clone();
state
.pending_service_worker_lifecycle_events
.remove(&event_id);
(state.parent_tx.clone(), completion)
};
let _ = parent_tx.send(WorkerToParentMessage::ServiceWorkerLifecycleCompleted(
completion,
));
}
fn maybe_send_service_worker_fetch_completion(
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
scope: &mut v8::PinScope<'_, '_>,
) {
let (parent_tx, completion, handled_settled) = {
let mut state = state.borrow_mut();
let Some(pending) = state.pending_service_worker_fetch_events.get_mut(&event_id) else {
return;
};
if !pending.dispatch_finished
|| pending.pending_respond_with
|| pending.pending_wait_until_count > 0
{
return;
}
let handled_settled = settle_service_worker_fetch_handled_for_pending(scope, pending);
let completion = pending.completion.clone();
state.pending_service_worker_fetch_events.remove(&event_id);
(state.parent_tx.clone(), completion, handled_settled)
};
if handled_settled {
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
let _ = parent_tx.send(WorkerToParentMessage::ServiceWorkerFetchCompleted(
completion,
));
}
fn maybe_send_service_worker_message_completion(
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
) {
let (parent_tx, completion) = {
let mut state = state.borrow_mut();
let Some(pending) = state.pending_service_worker_message_events.get(&event_id) else {
return;
};
if !pending.dispatch_finished || pending.pending_wait_until_count > 0 {
return;
}
let completion = pending.completion.clone();
let window_interaction_allowed = pending.window_interaction_allowed;
state
.pending_service_worker_message_events
.remove(&event_id);
if window_interaction_allowed {
state.service_worker_window_interaction_allowed_count = state
.service_worker_window_interaction_allowed_count
.saturating_sub(1);
}
(state.parent_tx.clone(), completion)
};
let message = WorkerToParentMessage::ServiceWorkerMessageCompleted(completion);
let _ = parent_tx.send(message);
}
fn maybe_send_service_worker_notification_completion(
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
) {
let (parent_tx, completion) = {
let mut state = state.borrow_mut();
let Some(pending) = state
.pending_service_worker_notification_events
.get(&event_id)
else {
return;
};
if !pending.dispatch_finished || pending.pending_wait_until_count > 0 {
return;
}
let completion = pending.completion.clone();
let window_interaction_allowed = pending.window_interaction_allowed;
state
.pending_service_worker_notification_events
.remove(&event_id);
if window_interaction_allowed {
state.service_worker_window_interaction_allowed_count = state
.service_worker_window_interaction_allowed_count
.saturating_sub(1);
}
(state.parent_tx.clone(), completion)
};
let message = WorkerToParentMessage::ServiceWorkerNotificationCompleted(completion);
let _ = parent_tx.send(message);
}
fn maybe_send_service_worker_push_completion(
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
) {
let (parent_tx, completion) = {
let mut state = state.borrow_mut();
let Some(pending) = state.pending_service_worker_push_events.get(&event_id) else {
return;
};
if !pending.dispatch_finished || pending.pending_wait_until_count > 0 {
return;
}
let completion = pending.completion.clone();
state.pending_service_worker_push_events.remove(&event_id);
(state.parent_tx.clone(), completion)
};
let message = WorkerToParentMessage::ServiceWorkerPushCompleted(completion);
let _ = parent_tx.send(message);
}
fn maybe_send_service_worker_sync_completion(
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
) {
let (parent_tx, completion) = {
let mut state = state.borrow_mut();
let Some(pending) = state.pending_service_worker_sync_events.get(&event_id) else {
return;
};
if !pending.dispatch_finished || pending.pending_wait_until_count > 0 {
return;
}
let completion = pending.completion.clone();
state.pending_service_worker_sync_events.remove(&event_id);
(state.parent_tx.clone(), completion)
};
let message = WorkerToParentMessage::ServiceWorkerSyncCompleted(completion);
let _ = parent_tx.send(message);
}
fn maybe_send_service_worker_periodic_sync_completion(
state: &Rc<RefCell<super::WorkerGlobalState>>,
event_id: ServiceWorkerEventId,
) {
let (parent_tx, completion) = {
let mut state = state.borrow_mut();
let Some(pending) = state
.pending_service_worker_periodic_sync_events
.get(&event_id)
else {
return;
};
if !pending.dispatch_finished || pending.pending_wait_until_count > 0 {
return;
}
let completion = pending.completion.clone();
state
.pending_service_worker_periodic_sync_events
.remove(&event_id);
(state.parent_tx.clone(), completion)
};
let message = WorkerToParentMessage::ServiceWorkerPeriodicSyncCompleted(completion);
let _ = parent_tx.send(message);
}
pub(super) fn dispatch_worker_exception<'s>(
scope: &mut v8::PinScope<'s, '_>,
global: v8::Local<'s, v8::Object>,
report: V8ExceptionReport,
exception: Option<v8::Local<'s, v8::Value>>,
parent_event_kind: WorkerParentErrorEventKind,
parent_tx: &mpsc::UnboundedSender<WorkerToParentMessage>,
script_url: &str,
) -> bool {
dispatch_worker_exception_with_phase(
scope,
global,
report,
exception,
parent_event_kind,
WorkerErrorPhase::Runtime,
parent_tx,
script_url,
)
}
pub(crate) fn dispatch_current_worker_callback_exception(
scope: &mut v8::PinScope<'_, '_>,
report: V8ExceptionReport,
) -> bool {
let Some((parent_tx, script_url)) = worker_exception_report_target(scope) else {
return false;
};
let global = scope.get_current_context().global(scope);
let exception = report
.exception
.as_ref()
.map(|exception| v8::Local::new(scope, exception));
dispatch_worker_exception(
scope,
global,
report,
exception,
WorkerParentErrorEventKind::ErrorEvent,
&parent_tx,
&script_url,
)
}
pub(super) fn dispatch_worker_exception_with_phase<'s>(
scope: &mut v8::PinScope<'s, '_>,
global: v8::Local<'s, v8::Object>,
report: V8ExceptionReport,
exception: Option<v8::Local<'s, v8::Value>>,
parent_event_kind: WorkerParentErrorEventKind,
parent_phase: WorkerErrorPhase,
parent_tx: &mpsc::UnboundedSender<WorkerToParentMessage>,
script_url: &str,
) -> bool {
dispatch_worker_exception_with_phase_and_source(
scope,
global,
report,
exception,
parent_event_kind,
parent_phase,
WorkerErrorSource::Runtime,
parent_tx,
script_url,
)
}
pub(super) fn dispatch_worker_exception_with_phase_and_source<'s>(
scope: &mut v8::PinScope<'s, '_>,
global: v8::Local<'s, v8::Object>,
mut report: V8ExceptionReport,
exception: Option<v8::Local<'s, v8::Value>>,
parent_event_kind: WorkerParentErrorEventKind,
parent_phase: WorkerErrorPhase,
source: WorkerErrorSource,
parent_tx: &mpsc::UnboundedSender<WorkerToParentMessage>,
script_url: &str,
) -> bool {
apply_worker_exception_location_overrides(scope, &mut report, exception);
let handled = dispatch_worker_error_event(scope, global, &report, exception, script_url);
if !handled {
report_exception_to_parent_with_phase_and_source(
&report,
script_url,
parent_event_kind,
parent_phase,
source,
parent_tx,
);
}
handled
}
fn dispatch_worker_global_message_event<'s>(
scope: &mut v8::PinScope<'s, '_>,
global: v8::Local<'s, v8::Object>,
event_type: &str,
data: v8::Local<'s, v8::Value>,
ports: v8::Local<'s, v8::Array>,
) {
let event = new_worker_message_event(scope, event_type, data, None, ports);
dispatch_worker_event(scope, global, event, event_type, false);
}
/// Dispatch a parent `postMessage()` delivery into the worker global.
pub(super) fn dispatch_message_event(
isolate: &mut v8::OwnedIsolate,
context: &v8::Global<v8::Context>,
payload: &V8StructuredClonePayload,
) {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let ctx = v8::Local::new(scope, context);
let scope = &mut v8::ContextScope::new(scope, ctx);
{
let try_catch = pin!(v8::TryCatch::new(scope));
let mut scope = try_catch.init();
let global = ctx.global(&scope);
if let Some((data, ports)) =
structured_deserialize_value_for_message_event(&mut scope, payload)
{
dispatch_worker_global_message_event(&mut scope, global, "message", data, ports);
} else {
// `postMessage` delivery failures are reported to the receiver as a
// `messageerror` event. This matters for secure-context-only host
// objects such as CryptoKey: an insecure worker cannot deserialize
// the object, but the failure must not be hidden as a normal
// message with `undefined` data.
if scope.has_caught() {
scope.reset();
}
let data = v8::null(&scope).into();
let ports = v8::Array::new(&scope, 0);
dispatch_worker_global_message_event(&mut scope, global, "messageerror", data, ports);
}
}
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
pub(super) fn dispatch_shared_worker_connect_event(
isolate: &mut v8::OwnedIsolate,
context: &v8::Global<v8::Context>,
port_id: MessagePortId,
) {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let ctx = v8::Local::new(scope, context);
let scope = &mut v8::ContextScope::new(scope, ctx);
let global = ctx.global(scope);
let mut source = None;
let ports = if let Some(port) = ensure_message_port_wrapper_for_id(scope, port_id) {
register_shared_worker_connection_port(scope, port_id);
source = Some(port.into());
serialize_v8_array(scope, [port]).unwrap_or_else(|| v8::Array::new(scope, 1))
} else {
v8::Array::new(scope, 1)
};
let _ = ports.set_integrity_level(scope, v8::IntegrityLevel::Frozen);
let data = v8str(scope, "").into();
let event = new_worker_message_event(scope, "connect", data, source, ports);
dispatch_worker_event(scope, global, event, "connect", false);
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
pub(super) fn dispatch_message_port_event(
isolate: &mut v8::OwnedIsolate,
context: &v8::Global<v8::Context>,
port_id: MessagePortId,
parent_tx: &mpsc::UnboundedSender<WorkerToParentMessage>,
script_url: &str,
) -> bool {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let ctx = v8::Local::new(scope, context);
let scope = &mut v8::ContextScope::new(scope, ctx);
if crate::worker::worker_termination_requested(scope) {
return true;
}
let mut callback_errors = Vec::new();
let callback_dispatched = dispatch_message_port_events_for_port_collecting_errors(
scope,
port_id,
Some(&mut callback_errors),
);
if scope.is_execution_terminating() || crate::worker::worker_termination_requested(scope) {
return true;
}
if callback_dispatched {
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
if scope.is_execution_terminating() || crate::worker::worker_termination_requested(scope) {
return true;
}
if callback_errors.is_empty() {
return false;
}
let global = ctx.global(scope);
for mut report in callback_errors {
let exception_global = report.exception.take();
let exception = exception_global
.as_ref()
.map(|exception| v8::Local::new(scope, exception));
dispatch_worker_exception(
scope,
global,
report,
exception,
WorkerParentErrorEventKind::ErrorEvent,
parent_tx,
script_url,
);
if scope.is_execution_terminating() || crate::worker::worker_termination_requested(scope) {
return true;
}
}
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
scope.is_execution_terminating() || crate::worker::worker_termination_requested(scope)
}
pub(super) fn dispatch_broadcast_channel_event(
isolate: &mut v8::OwnedIsolate,
context: &v8::Global<v8::Context>,
channel_id: BroadcastChannelId,
) {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let ctx = v8::Local::new(scope, context);
let scope = &mut v8::ContextScope::new(scope, ctx);
if crate::context_bootstrap::dispatch_broadcast_channel_events_for_channel(scope, channel_id) {
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
}
/// Fire a timer callback.
pub(super) fn fire_timer_callback(
isolate: &mut v8::OwnedIsolate,
timer: &ActiveTimer,
parent_tx: &mpsc::UnboundedSender<WorkerToParentMessage>,
script_url: &str,
) {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let ctx = timer.callback.target_context(scope);
let scope = &mut v8::ContextScope::new(scope, ctx);
let global = ctx.global(scope);
let callback_error = match timer.callback.invoke(scope, &timer.extra_args) {
WorkerTimerCallbackOutcome::Returned => None,
WorkerTimerCallbackOutcome::Threw(report) => {
trace!(
timer_id = timer.id,
message = report.summary.as_str(),
"timer callback error"
);
Some(report)
}
};
if let Some(report) = callback_error {
let exception = report
.exception
.as_ref()
.map(|value| v8::Local::new(scope, value));
dispatch_worker_exception(
scope,
global,
*report,
exception,
WorkerParentErrorEventKind::ErrorEvent,
parent_tx,
script_url,
);
}
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
}
/// Create a V8 ScriptOrigin for error reporting.
pub(super) fn create_script_origin<'s>(
scope: &mut v8::PinScope<'s, '_>,
url: &str,
) -> v8::ScriptOrigin<'s> {
create_script_origin_with_kind(scope, url, false)
}
pub(super) fn create_script_origin_with_kind<'s>(
scope: &mut v8::PinScope<'s, '_>,
url: &str,
is_module: bool,
) -> v8::ScriptOrigin<'s> {
let name = v8::String::new(scope, url).unwrap();
v8::ScriptOrigin::new(
scope,
name.into(),
0,
0,
false,
-1,
None,
false,
false,
is_module,
None,
)
}