use core::fmt;
#[cfg(feature = "webgpu")]
use std::cell::RefCell;
use std::option::Option;
use std::result::Result;
use base::id::PipelineId;
#[cfg(feature = "bluetooth")]
use bluetooth_traits::BluetoothRequest;
use crossbeam_channel::{select, Receiver, SendError, Sender};
use devtools_traits::{DevtoolScriptControlMsg, ScriptToDevtoolsControlMsg};
use ipc_channel::ipc::IpcSender;
use net_traits::image_cache::PendingImageResponse;
use net_traits::FetchResponseMsg;
use profile_traits::mem::{self as profile_mem, OpaqueSender, ReportsChan};
use profile_traits::time::{self as profile_time};
use script_traits::{LayoutMsg, Painter, ScriptMsg, ScriptThreadMessage};
use servo_atoms::Atom;
use timers::TimerScheduler;
#[cfg(feature = "webgpu")]
use webgpu::WebGPUMsg;
use crate::dom::abstractworker::WorkerScriptMsg;
use crate::dom::bindings::trace::CustomTraceable;
use crate::dom::dedicatedworkerglobalscope::DedicatedWorkerScriptMsg;
use crate::dom::serviceworkerglobalscope::ServiceWorkerScriptMsg;
use crate::dom::worker::TrustedWorkerAddress;
use crate::script_runtime::ScriptThreadEventCategory;
use crate::task::TaskBox;
use crate::task_queue::{QueuedTask, QueuedTaskConversion, TaskQueue};
use crate::task_source::TaskSourceName;
#[derive(Debug)]
pub(crate) enum MixedMessage {
FromConstellation(ScriptThreadMessage),
FromScript(MainThreadScriptMsg),
FromDevtools(DevtoolScriptControlMsg),
FromImageCache(PendingImageResponse),
#[cfg(feature = "webgpu")]
FromWebGPUServer(WebGPUMsg),
TimerFired,
}
impl MixedMessage {
pub(crate) fn pipeline_id(&self) -> Option<PipelineId> {
match self {
MixedMessage::FromConstellation(ref inner_msg) => match *inner_msg {
ScriptThreadMessage::StopDelayingLoadEventsMode(id) => Some(id),
ScriptThreadMessage::AttachLayout(ref new_layout_info) => new_layout_info
.parent_info
.or(Some(new_layout_info.new_pipeline_id)),
ScriptThreadMessage::Resize(id, ..) => Some(id),
ScriptThreadMessage::ThemeChange(id, ..) => Some(id),
ScriptThreadMessage::ResizeInactive(id, ..) => Some(id),
ScriptThreadMessage::UnloadDocument(id) => Some(id),
ScriptThreadMessage::ExitPipeline(id, ..) => Some(id),
ScriptThreadMessage::ExitScriptThread => None,
ScriptThreadMessage::SendInputEvent(id, ..) => Some(id),
ScriptThreadMessage::Viewport(id, ..) => Some(id),
ScriptThreadMessage::GetTitle(id) => Some(id),
ScriptThreadMessage::SetDocumentActivity(id, ..) => Some(id),
ScriptThreadMessage::SetThrottled(id, ..) => Some(id),
ScriptThreadMessage::SetThrottledInContainingIframe(id, ..) => Some(id),
ScriptThreadMessage::NavigateIframe(id, ..) => Some(id),
ScriptThreadMessage::PostMessage { target: id, .. } => Some(id),
ScriptThreadMessage::UpdatePipelineId(_, _, _, id, _) => Some(id),
ScriptThreadMessage::UpdateHistoryState(id, ..) => Some(id),
ScriptThreadMessage::RemoveHistoryStates(id, ..) => Some(id),
ScriptThreadMessage::FocusIFrame(id, ..) => Some(id),
ScriptThreadMessage::WebDriverScriptCommand(id, ..) => Some(id),
ScriptThreadMessage::TickAllAnimations(id, ..) => Some(id),
ScriptThreadMessage::WebFontLoaded(id, ..) => Some(id),
ScriptThreadMessage::DispatchIFrameLoadEvent {
target: _,
parent: id,
child: _,
} => Some(id),
ScriptThreadMessage::DispatchStorageEvent(id, ..) => Some(id),
ScriptThreadMessage::ReportCSSError(id, ..) => Some(id),
ScriptThreadMessage::Reload(id, ..) => Some(id),
ScriptThreadMessage::PaintMetric(id, ..) => Some(id),
ScriptThreadMessage::ExitFullScreen(id, ..) => Some(id),
ScriptThreadMessage::MediaSessionAction(..) => None,
#[cfg(feature = "webgpu")]
ScriptThreadMessage::SetWebGPUPort(..) => None,
ScriptThreadMessage::SetScrollStates(id, ..) => Some(id),
ScriptThreadMessage::SetEpochPaintTime(id, ..) => Some(id),
},
MixedMessage::FromScript(ref inner_msg) => match *inner_msg {
MainThreadScriptMsg::Common(CommonScriptMsg::Task(_, _, pipeline_id, _)) => {
pipeline_id
},
MainThreadScriptMsg::Common(CommonScriptMsg::CollectReports(_)) => None,
MainThreadScriptMsg::NavigationResponse { pipeline_id, .. } => Some(pipeline_id),
MainThreadScriptMsg::WorkletLoaded(pipeline_id) => Some(pipeline_id),
MainThreadScriptMsg::RegisterPaintWorklet { pipeline_id, .. } => Some(pipeline_id),
MainThreadScriptMsg::Inactive => None,
MainThreadScriptMsg::WakeUp => None,
},
MixedMessage::FromImageCache(response) => Some(response.pipeline_id),
MixedMessage::FromDevtools(_) | MixedMessage::TimerFired => None,
#[cfg(feature = "webgpu")]
MixedMessage::FromWebGPUServer(..) => None,
}
}
}
#[derive(Debug)]
pub(crate) enum MainThreadScriptMsg {
Common(CommonScriptMsg),
WorkletLoaded(PipelineId),
NavigationResponse {
pipeline_id: PipelineId,
message: Box<FetchResponseMsg>,
},
RegisterPaintWorklet {
pipeline_id: PipelineId,
name: Atom,
properties: Vec<Atom>,
painter: Box<dyn Painter>,
},
Inactive,
WakeUp,
}
pub(crate) enum CommonScriptMsg {
CollectReports(ReportsChan),
Task(
ScriptThreadEventCategory,
Box<dyn TaskBox>,
Option<PipelineId>,
TaskSourceName,
),
}
impl fmt::Debug for CommonScriptMsg {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CommonScriptMsg::CollectReports(_) => write!(f, "CollectReports(...)"),
CommonScriptMsg::Task(ref category, ref task, _, _) => {
f.debug_tuple("Task").field(category).field(task).finish()
},
}
}
}
#[derive(Clone, JSTraceable, MallocSizeOf)]
pub(crate) enum ScriptEventLoopSender {
MainThread(Sender<MainThreadScriptMsg>),
ServiceWorker(Sender<ServiceWorkerScriptMsg>),
DedicatedWorker {
sender: Sender<DedicatedWorkerScriptMsg>,
main_thread_worker: TrustedWorkerAddress,
},
}
impl ScriptEventLoopSender {
pub(crate) fn send(&self, message: CommonScriptMsg) -> Result<(), SendError<()>> {
match self {
Self::MainThread(sender) => sender
.send(MainThreadScriptMsg::Common(message))
.map_err(|_| SendError(())),
Self::ServiceWorker(sender) => sender
.send(ServiceWorkerScriptMsg::CommonWorker(
WorkerScriptMsg::Common(message),
))
.map_err(|_| SendError(())),
Self::DedicatedWorker {
sender,
main_thread_worker,
} => {
let common_message = WorkerScriptMsg::Common(message);
sender
.send(DedicatedWorkerScriptMsg::CommonWorker(
main_thread_worker.clone(),
common_message,
))
.map_err(|_| SendError(()))
},
}
}
}
pub(crate) enum ScriptEventLoopReceiver {
MainThread(Receiver<MainThreadScriptMsg>),
DedicatedWorker(Receiver<DedicatedWorkerScriptMsg>),
}
impl ScriptEventLoopReceiver {
pub(crate) fn recv(&self) -> Result<CommonScriptMsg, ()> {
match self {
Self::MainThread(receiver) => match receiver.recv() {
Ok(MainThreadScriptMsg::Common(script_msg)) => Ok(script_msg),
Ok(_) => panic!("unexpected main thread event message!"),
Err(_) => Err(()),
},
Self::DedicatedWorker(receiver) => match receiver.recv() {
Ok(DedicatedWorkerScriptMsg::CommonWorker(_, WorkerScriptMsg::Common(message))) => {
Ok(message)
},
Ok(_) => panic!("unexpected worker event message!"),
Err(_) => Err(()),
},
}
}
}
impl QueuedTaskConversion for MainThreadScriptMsg {
fn task_source_name(&self) -> Option<&TaskSourceName> {
let script_msg = match self {
MainThreadScriptMsg::Common(script_msg) => script_msg,
_ => return None,
};
match script_msg {
CommonScriptMsg::Task(_category, _boxed, _pipeline_id, task_source) => {
Some(task_source)
},
_ => None,
}
}
fn pipeline_id(&self) -> Option<PipelineId> {
let script_msg = match self {
MainThreadScriptMsg::Common(script_msg) => script_msg,
_ => return None,
};
match script_msg {
CommonScriptMsg::Task(_category, _boxed, pipeline_id, _task_source) => *pipeline_id,
_ => None,
}
}
fn into_queued_task(self) -> Option<QueuedTask> {
let script_msg = match self {
MainThreadScriptMsg::Common(script_msg) => script_msg,
_ => return None,
};
let (category, boxed, pipeline_id, task_source) = match script_msg {
CommonScriptMsg::Task(category, boxed, pipeline_id, task_source) => {
(category, boxed, pipeline_id, task_source)
},
_ => return None,
};
Some((None, category, boxed, pipeline_id, task_source))
}
fn from_queued_task(queued_task: QueuedTask) -> Self {
let (_worker, category, boxed, pipeline_id, task_source) = queued_task;
let script_msg = CommonScriptMsg::Task(category, boxed, pipeline_id, task_source);
MainThreadScriptMsg::Common(script_msg)
}
fn inactive_msg() -> Self {
MainThreadScriptMsg::Inactive
}
fn wake_up_msg() -> Self {
MainThreadScriptMsg::WakeUp
}
fn is_wake_up(&self) -> bool {
matches!(self, MainThreadScriptMsg::WakeUp)
}
}
impl OpaqueSender<CommonScriptMsg> for ScriptEventLoopSender {
fn send(&self, message: CommonScriptMsg) {
self.send(message).unwrap()
}
}
#[derive(Clone, JSTraceable)]
pub(crate) struct ScriptThreadSenders {
pub(crate) self_sender: Sender<MainThreadScriptMsg>,
#[no_trace]
#[cfg(feature = "bluetooth")]
pub(crate) bluetooth_sender: IpcSender<BluetoothRequest>,
#[no_trace]
pub(crate) constellation_sender: IpcSender<ScriptThreadMessage>,
#[no_trace]
pub(crate) pipeline_to_constellation_sender: IpcSender<(PipelineId, ScriptMsg)>,
#[no_trace]
pub(crate) layout_to_constellation_ipc_sender: IpcSender<LayoutMsg>,
#[no_trace]
pub(crate) image_cache_sender: IpcSender<PendingImageResponse>,
#[no_trace]
pub(crate) time_profiler_sender: profile_time::ProfilerChan,
#[no_trace]
pub(crate) memory_profiler_sender: profile_mem::ProfilerChan,
#[no_trace]
pub(crate) devtools_server_sender: Option<IpcSender<ScriptToDevtoolsControlMsg>>,
#[no_trace]
pub(crate) devtools_client_to_script_thread_sender: IpcSender<DevtoolScriptControlMsg>,
#[no_trace]
pub(crate) content_process_shutdown_sender: Sender<()>,
}
#[derive(JSTraceable)]
pub(crate) struct ScriptThreadReceivers {
#[no_trace]
pub(crate) constellation_receiver: Receiver<ScriptThreadMessage>,
#[no_trace]
pub(crate) image_cache_receiver: Receiver<PendingImageResponse>,
#[no_trace]
pub(crate) devtools_server_receiver: Receiver<DevtoolScriptControlMsg>,
#[no_trace]
#[cfg(feature = "webgpu")]
pub(crate) webgpu_receiver: RefCell<Receiver<WebGPUMsg>>,
}
impl ScriptThreadReceivers {
pub(crate) fn recv(
&self,
task_queue: &TaskQueue<MainThreadScriptMsg>,
timer_scheduler: &TimerScheduler,
) -> MixedMessage {
select! {
recv(task_queue.select()) -> msg => {
task_queue.take_tasks(msg.unwrap());
let event = task_queue
.recv()
.expect("Spurious wake-up of the event-loop, task-queue has no tasks available");
MixedMessage::FromScript(event)
},
recv(self.constellation_receiver) -> msg => MixedMessage::FromConstellation(msg.unwrap()),
recv(self.devtools_server_receiver) -> msg => MixedMessage::FromDevtools(msg.unwrap()),
recv(self.image_cache_receiver) -> msg => MixedMessage::FromImageCache(msg.unwrap()),
recv(timer_scheduler.wait_channel()) -> _ => MixedMessage::TimerFired,
recv({
#[cfg(feature = "webgpu")]
{
self.webgpu_receiver.borrow()
}
#[cfg(not(feature = "webgpu"))]
{
&crossbeam_channel::never::<()>()
}
}) -> msg => {
#[cfg(feature = "webgpu")]
{
MixedMessage::FromWebGPUServer(msg.unwrap())
}
#[cfg(not(feature = "webgpu"))]
{
unreachable!("This should never be hit when webgpu is disabled ({msg:?})");
}
}
}
}
pub(crate) fn try_recv(
&self,
task_queue: &TaskQueue<MainThreadScriptMsg>,
) -> Option<MixedMessage> {
if let Ok(message) = self.constellation_receiver.try_recv() {
return MixedMessage::FromConstellation(message).into();
}
if let Ok(message) = task_queue.take_tasks_and_recv() {
return MixedMessage::FromScript(message).into();
}
if let Ok(message) = self.devtools_server_receiver.try_recv() {
return MixedMessage::FromDevtools(message).into();
}
if let Ok(message) = self.image_cache_receiver.try_recv() {
return MixedMessage::FromImageCache(message).into();
}
#[cfg(feature = "webgpu")]
if let Ok(message) = self.webgpu_receiver.borrow().try_recv() {
return MixedMessage::FromWebGPUServer(message).into();
}
None
}
}