Move ScriptToConstellationMsg to constellation_traits (#36364)

This is the last big change necessary to create the
`constellation_traits` crate. This moves the data structure for messages
that originate from the `ScriptThread` and are sent to the
`Contellation` to `constellation_traits`, effectively splitting
`script_traits` in half. Before, `script_traits` was responsible for
exposing the API of both the `ScriptThread` and the `Constellation` to
the rest of Servo.

- Data structures that are used by `ScriptToConstellationMsg` are moved
  to `constellation_traits`. The dependency graph looks a bit like this:
  `script_layout_interface` depends on `script_traits` depends on
  `constellation_traits` depends on `embedder_traits`.
- Data structures that are used in the embedding layer
  (`UntrustedNodeAddress`, `CompositorHitTestResult`, `TouchEventResult`
  and `AnimationState`) are moved to embedder_traits, to avoid a
  dependency cycle between `webrender_traits` and
  `constellation_traits`.
- Types dealing with MessagePorts and serialization are moved to
  `constellation_traits::message_port`.

Testing: This is covered by existing tests as it just moves types
around.
Signed-off-by: Martin Robinson <mrobinson@igalia.com>

Signed-off-by: Martin Robinson <mrobinson@igalia.com>

components/shared/constellation/Cargo.toml

@@ -11,16 +11,30 @@ rust-version.workspace = true
 name = "constellation_traits"
 path = "lib.rs"
 
+[features]
+bluetooth = []
+webgpu = ["wgpu-core"]
+
 [dependencies]
 base = { workspace = true }
 bitflags = { workspace = true }
+canvas_traits = { workspace = true }
+devtools_traits = { workspace = true }
 embedder_traits = { workspace = true }
 euclid = { workspace = true }
+http = { workspace = true }
+hyper_serde = { workspace = true }
 ipc-channel = { workspace = true }
+log = { workspace = true }
 malloc_size_of = { workspace = true }
 malloc_size_of_derive = { workspace = true }
+net_traits = { workspace = true }
+profile_traits = { workspace = true }
 serde = { workspace = true }
 servo_url = { path = "../../url" }
+strum = { workspace = true }
 strum_macros = { workspace = true }
-stylo_traits = { workspace = true }
+uuid = { workspace = true }
+webgpu_traits = { workspace = true }
 webrender_api = { workspace = true }
+wgpu-core = { workspace = true, optional = true }

components/shared/constellation/from_script_message.rs

@@ -0,0 +1,632 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+//! Messages send from the ScriptThread to the Constellation.
+
+use std::collections::{HashMap, VecDeque};
+use std::fmt;
+
+use base::Epoch;
+use base::id::{
+    BroadcastChannelRouterId, BrowsingContextId, HistoryStateId, MessagePortId,
+    MessagePortRouterId, PipelineId, ServiceWorkerId, ServiceWorkerRegistrationId, WebViewId,
+};
+use canvas_traits::canvas::{CanvasId, CanvasMsg};
+use devtools_traits::{DevtoolScriptControlMsg, ScriptToDevtoolsControlMsg, WorkerId};
+use embedder_traits::{
+    AnimationState, EmbedderMsg, MediaSessionEvent, TouchEventResult, ViewportDetails,
+};
+use euclid::default::Size2D as UntypedSize2D;
+use http::{HeaderMap, Method};
+use ipc_channel::Error as IpcError;
+use ipc_channel::ipc::{IpcReceiver, IpcSender};
+use net_traits::request::{InsecureRequestsPolicy, Referrer, RequestBody};
+use net_traits::storage_thread::StorageType;
+use net_traits::{CoreResourceMsg, ReferrerPolicy, ResourceThreads};
+use profile_traits::mem::MemoryReportResult;
+use profile_traits::{mem, time as profile_time};
+use serde::{Deserialize, Serialize};
+use servo_url::{ImmutableOrigin, ServoUrl};
+use strum_macros::IntoStaticStr;
+#[cfg(feature = "webgpu")]
+use webgpu_traits::{WebGPU, WebGPUAdapterResponse};
+use webrender_api::ImageKey;
+
+use crate::message_port::{
+    BroadcastMsg, MessagePortMsg, PortMessageTask, StructuredSerializedData,
+};
+use crate::{LogEntry, TraversalDirection, WindowSizeType};
+
+/// A Script to Constellation channel.
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct ScriptToConstellationChan {
+    /// Sender for communicating with constellation thread.
+    pub sender: IpcSender<(PipelineId, ScriptToConstellationMessage)>,
+    /// Used to identify the origin of the message.
+    pub pipeline_id: PipelineId,
+}
+
+impl ScriptToConstellationChan {
+    /// Send ScriptMsg and attach the pipeline_id to the message.
+    pub fn send(&self, msg: ScriptToConstellationMessage) -> Result<(), IpcError> {
+        self.sender.send((self.pipeline_id, msg))
+    }
+}
+
+/// The origin where a given load was initiated.
+/// Useful for origin checks, for example before evaluation a JS URL.
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub enum LoadOrigin {
+    /// A load originating in the constellation.
+    Constellation,
+    /// A load originating in webdriver.
+    WebDriver,
+    /// A load originating in script.
+    Script(ImmutableOrigin),
+}
+
+/// can be passed to `LoadUrl` to load a page with GET/POST
+/// parameters or headers
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct LoadData {
+    /// The origin where the load started.
+    pub load_origin: LoadOrigin,
+    /// The URL.
+    pub url: ServoUrl,
+    /// The creator pipeline id if this is an about:blank load.
+    pub creator_pipeline_id: Option<PipelineId>,
+    /// The method.
+    #[serde(
+        deserialize_with = "::hyper_serde::deserialize",
+        serialize_with = "::hyper_serde::serialize"
+    )]
+    pub method: Method,
+    /// The headers.
+    #[serde(
+        deserialize_with = "::hyper_serde::deserialize",
+        serialize_with = "::hyper_serde::serialize"
+    )]
+    pub headers: HeaderMap,
+    /// The data that will be used as the body of the request.
+    pub data: Option<RequestBody>,
+    /// The result of evaluating a javascript scheme url.
+    pub js_eval_result: Option<JsEvalResult>,
+    /// The referrer.
+    pub referrer: Referrer,
+    /// The referrer policy.
+    pub referrer_policy: ReferrerPolicy,
+
+    /// The source to use instead of a network response for a srcdoc document.
+    pub srcdoc: String,
+    /// The inherited context is Secure, None if not inherited
+    pub inherited_secure_context: Option<bool>,
+    /// The inherited policy for upgrading insecure requests; None if not inherited.
+    pub inherited_insecure_requests_policy: Option<InsecureRequestsPolicy>,
+    /// Whether the page's ancestors have potentially trustworthy origin
+    pub has_trustworthy_ancestor_origin: bool,
+    /// Servo internal: if crash details are present, trigger a crash error page with these details.
+    pub crash: Option<String>,
+}
+
+/// The result of evaluating a javascript scheme url.
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub enum JsEvalResult {
+    /// The js evaluation had a non-string result, 204 status code.
+    /// <https://html.spec.whatwg.org/multipage/#navigate> 12.11
+    NoContent,
+    /// The js evaluation had a string result.
+    Ok(Vec<u8>),
+}
+
+impl LoadData {
+    /// Create a new `LoadData` object.
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        load_origin: LoadOrigin,
+        url: ServoUrl,
+        creator_pipeline_id: Option<PipelineId>,
+        referrer: Referrer,
+        referrer_policy: ReferrerPolicy,
+        inherited_secure_context: Option<bool>,
+        inherited_insecure_requests_policy: Option<InsecureRequestsPolicy>,
+        has_trustworthy_ancestor_origin: bool,
+    ) -> LoadData {
+        LoadData {
+            load_origin,
+            url,
+            creator_pipeline_id,
+            method: Method::GET,
+            headers: HeaderMap::new(),
+            data: None,
+            js_eval_result: None,
+            referrer,
+            referrer_policy,
+            srcdoc: "".to_string(),
+            inherited_secure_context,
+            crash: None,
+            inherited_insecure_requests_policy,
+            has_trustworthy_ancestor_origin,
+        }
+    }
+}
+
+/// <https://html.spec.whatwg.org/multipage/#navigation-supporting-concepts:navigationhistorybehavior>
+#[derive(Debug, Default, Deserialize, PartialEq, Serialize)]
+pub enum NavigationHistoryBehavior {
+    /// The default value, which will be converted very early in the navigate algorithm into "push"
+    /// or "replace". Usually it becomes "push", but under certain circumstances it becomes
+    /// "replace" instead.
+    #[default]
+    Auto,
+    /// A regular navigation which adds a new session history entry, and will clear the forward
+    /// session history.
+    Push,
+    /// A navigation that will replace the active session history entry.
+    Replace,
+}
+
+/// Entities required to spawn service workers
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct ScopeThings {
+    /// script resource url
+    pub script_url: ServoUrl,
+    /// network load origin of the resource
+    pub worker_load_origin: WorkerScriptLoadOrigin,
+    /// base resources required to create worker global scopes
+    pub init: WorkerGlobalScopeInit,
+    /// the port to receive devtools message from
+    pub devtools_chan: Option<IpcSender<ScriptToDevtoolsControlMsg>>,
+    /// service worker id
+    pub worker_id: WorkerId,
+}
+
+/// Message that gets passed to service worker scope on postMessage
+#[derive(Debug, Deserialize, Serialize)]
+pub struct DOMMessage {
+    /// The origin of the message
+    pub origin: ImmutableOrigin,
+    /// The payload of the message
+    pub data: StructuredSerializedData,
+}
+
+/// Channels to allow service worker manager to communicate with constellation and resource thread
+#[derive(Deserialize, Serialize)]
+pub struct SWManagerSenders {
+    /// Sender of messages to the constellation.
+    pub swmanager_sender: IpcSender<SWManagerMsg>,
+    /// Sender for communicating with resource thread.
+    pub resource_sender: IpcSender<CoreResourceMsg>,
+    /// Sender of messages to the manager.
+    pub own_sender: IpcSender<ServiceWorkerMsg>,
+    /// Receiver of messages from the constellation.
+    pub receiver: IpcReceiver<ServiceWorkerMsg>,
+}
+
+/// Messages sent to Service Worker Manager thread
+#[derive(Debug, Deserialize, Serialize)]
+pub enum ServiceWorkerMsg {
+    /// Timeout message sent by active service workers
+    Timeout(ServoUrl),
+    /// Message sent by constellation to forward to a running service worker
+    ForwardDOMMessage(DOMMessage, ServoUrl),
+    /// <https://w3c.github.io/ServiceWorker/#schedule-job-algorithm>
+    ScheduleJob(Job),
+    /// Exit the service worker manager
+    Exit,
+}
+
+#[derive(Debug, Deserialize, PartialEq, Serialize)]
+/// <https://w3c.github.io/ServiceWorker/#dfn-job-type>
+pub enum JobType {
+    /// <https://w3c.github.io/ServiceWorker/#register>
+    Register,
+    /// <https://w3c.github.io/ServiceWorker/#unregister-algorithm>
+    Unregister,
+    /// <https://w3c.github.io/ServiceWorker/#update-algorithm>
+    Update,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+/// The kind of error the job promise should be rejected with.
+pub enum JobError {
+    /// <https://w3c.github.io/ServiceWorker/#reject-job-promise>
+    TypeError,
+    /// <https://w3c.github.io/ServiceWorker/#reject-job-promise>
+    SecurityError,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+#[allow(clippy::large_enum_variant)]
+/// Messages sent from Job algorithms steps running in the SW manager,
+/// in order to resolve or reject the job promise.
+pub enum JobResult {
+    /// <https://w3c.github.io/ServiceWorker/#reject-job-promise>
+    RejectPromise(JobError),
+    /// <https://w3c.github.io/ServiceWorker/#resolve-job-promise>
+    ResolvePromise(Job, JobResultValue),
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+/// Jobs are resolved with the help of various values.
+pub enum JobResultValue {
+    /// Data representing a serviceworker registration.
+    Registration {
+        /// The Id of the registration.
+        id: ServiceWorkerRegistrationId,
+        /// The installing worker, if any.
+        installing_worker: Option<ServiceWorkerId>,
+        /// The waiting worker, if any.
+        waiting_worker: Option<ServiceWorkerId>,
+        /// The active worker, if any.
+        active_worker: Option<ServiceWorkerId>,
+    },
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+/// <https://w3c.github.io/ServiceWorker/#dfn-job>
+pub struct Job {
+    /// <https://w3c.github.io/ServiceWorker/#dfn-job-type>
+    pub job_type: JobType,
+    /// <https://w3c.github.io/ServiceWorker/#dfn-job-scope-url>
+    pub scope_url: ServoUrl,
+    /// <https://w3c.github.io/ServiceWorker/#dfn-job-script-url>
+    pub script_url: ServoUrl,
+    /// <https://w3c.github.io/ServiceWorker/#dfn-job-client>
+    pub client: IpcSender<JobResult>,
+    /// <https://w3c.github.io/ServiceWorker/#job-referrer>
+    pub referrer: ServoUrl,
+    /// Various data needed to process job.
+    pub scope_things: Option<ScopeThings>,
+}
+
+impl Job {
+    /// <https://w3c.github.io/ServiceWorker/#create-job-algorithm>
+    pub fn create_job(
+        job_type: JobType,
+        scope_url: ServoUrl,
+        script_url: ServoUrl,
+        client: IpcSender<JobResult>,
+        referrer: ServoUrl,
+        scope_things: Option<ScopeThings>,
+    ) -> Job {
+        Job {
+            job_type,
+            scope_url,
+            script_url,
+            client,
+            referrer,
+            scope_things,
+        }
+    }
+}
+
+impl PartialEq for Job {
+    /// Equality criteria as described in <https://w3c.github.io/ServiceWorker/#dfn-job-equivalent>
+    fn eq(&self, other: &Self) -> bool {
+        // TODO: match on job type, take worker type and `update_via_cache_mode` into account.
+        let same_job = self.job_type == other.job_type;
+        if same_job {
+            match self.job_type {
+                JobType::Register | JobType::Update => {
+                    self.scope_url == other.scope_url && self.script_url == other.script_url
+                },
+                JobType::Unregister => self.scope_url == other.scope_url,
+            }
+        } else {
+            false
+        }
+    }
+}
+
+/// Messages outgoing from the Service Worker Manager thread to constellation
+#[derive(Debug, Deserialize, Serialize)]
+pub enum SWManagerMsg {
+    /// Placeholder to keep the enum,
+    /// as it will be needed when implementing
+    /// <https://github.com/servo/servo/issues/24660>
+    PostMessageToClient,
+}
+
+/// Used to determine if a script has any pending asynchronous activity.
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
+pub enum DocumentState {
+    /// The document has been loaded and is idle.
+    Idle,
+    /// The document is either loading or waiting on an event.
+    Pending,
+}
+
+/// This trait allows creating a `ServiceWorkerManager` without depending on the `script`
+/// crate.
+pub trait ServiceWorkerManagerFactory {
+    /// Create a `ServiceWorkerManager`.
+    fn create(sw_senders: SWManagerSenders, origin: ImmutableOrigin);
+}
+
+/// Whether the sandbox attribute is present for an iframe element
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+pub enum IFrameSandboxState {
+    /// Sandbox attribute is present
+    IFrameSandboxed,
+    /// Sandbox attribute is not present
+    IFrameUnsandboxed,
+}
+
+/// Specifies the information required to load an auxiliary browsing context.
+#[derive(Debug, Deserialize, Serialize)]
+pub struct AuxiliaryWebViewCreationRequest {
+    /// Load data containing the url to load
+    pub load_data: LoadData,
+    /// The webview that caused this request.
+    pub opener_webview_id: WebViewId,
+    /// The pipeline opener browsing context.
+    pub opener_pipeline_id: PipelineId,
+    /// Sender for the constellation’s response to our request.
+    pub response_sender: IpcSender<Option<AuxiliaryWebViewCreationResponse>>,
+}
+
+/// Constellation’s response to auxiliary browsing context creation requests.
+#[derive(Debug, Deserialize, Serialize)]
+pub struct AuxiliaryWebViewCreationResponse {
+    /// The new webview ID.
+    pub new_webview_id: WebViewId,
+    /// The new pipeline ID.
+    pub new_pipeline_id: PipelineId,
+}
+
+/// Specifies the information required to load an iframe.
+#[derive(Debug, Deserialize, Serialize)]
+pub struct IFrameLoadInfo {
+    /// Pipeline ID of the parent of this iframe
+    pub parent_pipeline_id: PipelineId,
+    /// The ID for this iframe's nested browsing context.
+    pub browsing_context_id: BrowsingContextId,
+    /// The ID for the top-level ancestor browsing context of this iframe's nested browsing context.
+    pub webview_id: WebViewId,
+    /// The new pipeline ID that the iframe has generated.
+    pub new_pipeline_id: PipelineId,
+    ///  Whether this iframe should be considered private
+    pub is_private: bool,
+    ///  Whether this iframe should be considered secure
+    pub inherited_secure_context: Option<bool>,
+    /// Whether this load should replace the current entry (reload). If true, the current
+    /// entry will be replaced instead of a new entry being added.
+    pub history_handling: NavigationHistoryBehavior,
+}
+
+/// Specifies the information required to load a URL in an iframe.
+#[derive(Debug, Deserialize, Serialize)]
+pub struct IFrameLoadInfoWithData {
+    /// The information required to load an iframe.
+    pub info: IFrameLoadInfo,
+    /// Load data containing the url to load
+    pub load_data: LoadData,
+    /// The old pipeline ID for this iframe, if a page was previously loaded.
+    pub old_pipeline_id: Option<PipelineId>,
+    /// Sandbox type of this iframe
+    pub sandbox: IFrameSandboxState,
+    /// The initial viewport size for this iframe.
+    pub viewport_details: ViewportDetails,
+}
+
+/// Resources required by workerglobalscopes
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct WorkerGlobalScopeInit {
+    /// Chan to a resource thread
+    pub resource_threads: ResourceThreads,
+    /// Chan to the memory profiler
+    pub mem_profiler_chan: mem::ProfilerChan,
+    /// Chan to the time profiler
+    pub time_profiler_chan: profile_time::ProfilerChan,
+    /// To devtools sender
+    pub to_devtools_sender: Option<IpcSender<ScriptToDevtoolsControlMsg>>,
+    /// From devtools sender
+    pub from_devtools_sender: Option<IpcSender<DevtoolScriptControlMsg>>,
+    /// Messages to send to constellation
+    pub script_to_constellation_chan: ScriptToConstellationChan,
+    /// The worker id
+    pub worker_id: WorkerId,
+    /// The pipeline id
+    pub pipeline_id: PipelineId,
+    /// The origin
+    pub origin: ImmutableOrigin,
+    /// The creation URL
+    pub creation_url: Option<ServoUrl>,
+    /// True if secure context
+    pub inherited_secure_context: Option<bool>,
+}
+
+/// Common entities representing a network load origin
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct WorkerScriptLoadOrigin {
+    /// referrer url
+    pub referrer_url: Option<ServoUrl>,
+    /// the referrer policy which is used
+    pub referrer_policy: ReferrerPolicy,
+    /// the pipeline id of the entity requesting the load
+    pub pipeline_id: PipelineId,
+}
+
+/// An iframe sizing operation.
+#[derive(Clone, Copy, Debug, Deserialize, Serialize)]
+pub struct IFrameSizeMsg {
+    /// The child browsing context for this iframe.
+    pub browsing_context_id: BrowsingContextId,
+    /// The size and scale factor of the iframe.
+    pub size: ViewportDetails,
+    /// The kind of sizing operation.
+    pub type_: WindowSizeType,
+}
+
+/// Messages from the script to the constellation.
+#[derive(Deserialize, IntoStaticStr, Serialize)]
+pub enum ScriptToConstellationMessage {
+    /// Request to complete the transfer of a set of ports to a router.
+    CompleteMessagePortTransfer(MessagePortRouterId, Vec<MessagePortId>),
+    /// The results of attempting to complete the transfer of a batch of ports.
+    MessagePortTransferResult(
+        /* The router whose transfer of ports succeeded, if any */
+        Option<MessagePortRouterId>,
+        /* The ids of ports transferred successfully */
+        Vec<MessagePortId>,
+        /* The ids, and buffers, of ports whose transfer failed */
+        HashMap<MessagePortId, VecDeque<PortMessageTask>>,
+    ),
+    /// A new message-port was created or transferred, with corresponding control-sender.
+    NewMessagePort(MessagePortRouterId, MessagePortId),
+    /// A global has started managing message-ports
+    NewMessagePortRouter(MessagePortRouterId, IpcSender<MessagePortMsg>),
+    /// A global has stopped managing message-ports
+    RemoveMessagePortRouter(MessagePortRouterId),
+    /// A task requires re-routing to an already shipped message-port.
+    RerouteMessagePort(MessagePortId, PortMessageTask),
+    /// A message-port was shipped, let the entangled port know.
+    MessagePortShipped(MessagePortId),
+    /// A message-port has been discarded by script.
+    RemoveMessagePort(MessagePortId),
+    /// Entangle two message-ports.
+    EntanglePorts(MessagePortId, MessagePortId),
+    /// A global has started managing broadcast-channels.
+    NewBroadcastChannelRouter(
+        BroadcastChannelRouterId,
+        IpcSender<BroadcastMsg>,
+        ImmutableOrigin,
+    ),
+    /// A global has stopped managing broadcast-channels.
+    RemoveBroadcastChannelRouter(BroadcastChannelRouterId, ImmutableOrigin),
+    /// A global started managing broadcast channels for a given channel-name.
+    NewBroadcastChannelNameInRouter(BroadcastChannelRouterId, String, ImmutableOrigin),
+    /// A global stopped managing broadcast channels for a given channel-name.
+    RemoveBroadcastChannelNameInRouter(BroadcastChannelRouterId, String, ImmutableOrigin),
+    /// Broadcast a message to all same-origin broadcast channels,
+    /// excluding the source of the broadcast.
+    ScheduleBroadcast(BroadcastChannelRouterId, BroadcastMsg),
+    /// Forward a message to the embedder.
+    ForwardToEmbedder(EmbedderMsg),
+    /// Broadcast a storage event to every same-origin pipeline.
+    /// The strings are key, old value and new value.
+    BroadcastStorageEvent(
+        StorageType,
+        ServoUrl,
+        Option<String>,
+        Option<String>,
+        Option<String>,
+    ),
+    /// Indicates whether this pipeline is currently running animations.
+    ChangeRunningAnimationsState(AnimationState),
+    /// Requests that a new 2D canvas thread be created. (This is done in the constellation because
+    /// 2D canvases may use the GPU and we don't want to give untrusted content access to the GPU.)
+    CreateCanvasPaintThread(
+        UntypedSize2D<u64>,
+        IpcSender<(IpcSender<CanvasMsg>, CanvasId, ImageKey)>,
+    ),
+    /// Notifies the constellation that this frame has received focus.
+    Focus,
+    /// Get the top-level browsing context info for a given browsing context.
+    GetTopForBrowsingContext(BrowsingContextId, IpcSender<Option<WebViewId>>),
+    /// Get the browsing context id of the browsing context in which pipeline is
+    /// embedded and the parent pipeline id of that browsing context.
+    GetBrowsingContextInfo(
+        PipelineId,
+        IpcSender<Option<(BrowsingContextId, Option<PipelineId>)>>,
+    ),
+    /// Get the nth child browsing context ID for a given browsing context, sorted in tree order.
+    GetChildBrowsingContextId(
+        BrowsingContextId,
+        usize,
+        IpcSender<Option<BrowsingContextId>>,
+    ),
+    /// All pending loads are complete, and the `load` event for this pipeline
+    /// has been dispatched.
+    LoadComplete,
+    /// A new load has been requested, with an option to replace the current entry once loaded
+    /// instead of adding a new entry.
+    LoadUrl(LoadData, NavigationHistoryBehavior),
+    /// Abort loading after sending a LoadUrl message.
+    AbortLoadUrl,
+    /// Post a message to the currently active window of a given browsing context.
+    PostMessage {
+        /// The target of the posted message.
+        target: BrowsingContextId,
+        /// The source of the posted message.
+        source: PipelineId,
+        /// The expected origin of the target.
+        target_origin: Option<ImmutableOrigin>,
+        /// The source origin of the message.
+        /// <https://html.spec.whatwg.org/multipage/#dom-messageevent-origin>
+        source_origin: ImmutableOrigin,
+        /// The data to be posted.
+        data: StructuredSerializedData,
+    },
+    /// Inform the constellation that a fragment was navigated to and whether or not it was a replacement navigation.
+    NavigatedToFragment(ServoUrl, NavigationHistoryBehavior),
+    /// HTMLIFrameElement Forward or Back traversal.
+    TraverseHistory(TraversalDirection),
+    /// Inform the constellation of a pushed history state.
+    PushHistoryState(HistoryStateId, ServoUrl),
+    /// Inform the constellation of a replaced history state.
+    ReplaceHistoryState(HistoryStateId, ServoUrl),
+    /// Gets the length of the joint session history from the constellation.
+    JointSessionHistoryLength(IpcSender<u32>),
+    /// Notification that this iframe should be removed.
+    /// Returns a list of pipelines which were closed.
+    RemoveIFrame(BrowsingContextId, IpcSender<Vec<PipelineId>>),
+    /// Successful response to [crate::ConstellationControlMsg::SetThrottled].
+    SetThrottledComplete(bool),
+    /// A load has been requested in an IFrame.
+    ScriptLoadedURLInIFrame(IFrameLoadInfoWithData),
+    /// A load of the initial `about:blank` has been completed in an IFrame.
+    ScriptNewIFrame(IFrameLoadInfoWithData),
+    /// Script has opened a new auxiliary browsing context.
+    CreateAuxiliaryWebView(AuxiliaryWebViewCreationRequest),
+    /// Mark a new document as active
+    ActivateDocument,
+    /// Set the document state for a pipeline (used by screenshot / reftests)
+    SetDocumentState(DocumentState),
+    /// Update the layout epoch in the constellation (used by screenshot / reftests).
+    SetLayoutEpoch(Epoch, IpcSender<bool>),
+    /// Update the pipeline Url, which can change after redirections.
+    SetFinalUrl(ServoUrl),
+    /// Script has handled a touch event, and either prevented or allowed default actions.
+    TouchEventProcessed(TouchEventResult),
+    /// A log entry, with the top-level browsing context id and thread name
+    LogEntry(Option<String>, LogEntry),
+    /// Discard the document.
+    DiscardDocument,
+    /// Discard the browsing context.
+    DiscardTopLevelBrowsingContext,
+    /// Notifies the constellation that this pipeline has exited.
+    PipelineExited,
+    /// Send messages from postMessage calls from serviceworker
+    /// to constellation for storing in service worker manager
+    ForwardDOMMessage(DOMMessage, ServoUrl),
+    /// <https://w3c.github.io/ServiceWorker/#schedule-job-algorithm>
+    ScheduleJob(Job),
+    /// Notifies the constellation about media session events
+    /// (i.e. when there is metadata for the active media session, playback state changes...).
+    MediaSessionEvent(PipelineId, MediaSessionEvent),
+    #[cfg(feature = "webgpu")]
+    /// Create a WebGPU Adapter instance
+    RequestAdapter(
+        IpcSender<WebGPUAdapterResponse>,
+        wgpu_core::instance::RequestAdapterOptions,
+        wgpu_core::id::AdapterId,
+    ),
+    #[cfg(feature = "webgpu")]
+    /// Get WebGPU channel
+    GetWebGPUChan(IpcSender<Option<WebGPU>>),
+    /// Notify the constellation of a pipeline's document's title.
+    TitleChanged(PipelineId, String),
+    /// Notify the constellation that the size of some `<iframe>`s has changed.
+    IFrameSizes(Vec<IFrameSizeMsg>),
+    /// Request results from the memory reporter.
+    ReportMemory(IpcSender<MemoryReportResult>),
+}
+
+impl fmt::Debug for ScriptToConstellationMessage {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        let variant_string: &'static str = self.into();
+        write!(formatter, "ScriptMsg::{variant_string}")
+    }
+}

components/shared/constellation/lib.rs

@@ -8,23 +8,27 @@
 //! embedding/rendering layer all the way to script, thus it should have very minimal dependencies
 //! on other parts of Servo.
 
+mod from_script_message;
+mod message_port;
+
 use std::collections::HashMap;
-use std::ffi::c_void;
 use std::fmt;
 use std::time::Duration;
 
 use base::Epoch;
 use base::cross_process_instant::CrossProcessInstant;
-use base::id::{PipelineId, ScrollTreeNodeId, WebViewId};
+use base::id::{PipelineId, WebViewId};
 use bitflags::bitflags;
 use embedder_traits::{
-    Cursor, InputEvent, MediaSessionActionType, Theme, ViewportDetails, WebDriverCommandMsg,
+    CompositorHitTestResult, Cursor, InputEvent, MediaSessionActionType, Theme, ViewportDetails,
+    WebDriverCommandMsg,
 };
 use euclid::Vector2D;
+pub use from_script_message::*;
 use ipc_channel::ipc::IpcSender;
-use malloc_size_of::malloc_size_of_is_0;
 use malloc_size_of_derive::MallocSizeOf;
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
+pub use message_port::*;
+use serde::{Deserialize, Serialize};
 use servo_url::ServoUrl;
 use strum_macros::IntoStaticStr;
 use webrender_api::ExternalScrollId;
@@ -137,28 +141,6 @@ bitflags! {
     }
 }
 
-/// The result of a hit test in the compositor.
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct CompositorHitTestResult {
-    /// The pipeline id of the resulting item.
-    pub pipeline_id: PipelineId,
-
-    /// The hit test point in the item's viewport.
-    pub point_in_viewport: euclid::default::Point2D<f32>,
-
-    /// The hit test point relative to the item itself.
-    pub point_relative_to_item: euclid::default::Point2D<f32>,
-
-    /// The node address of the hit test result.
-    pub node: UntrustedNodeAddress,
-
-    /// The cursor that should be used when hovering the item hit by the hit test.
-    pub cursor: Option<Cursor>,
-
-    /// The scroll tree node associated with this hit test item.
-    pub scroll_tree_node: ScrollTreeNodeId,
-}
-
 /// The scroll state of a stacking context.
 #[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
 pub struct ScrollState {
@@ -168,43 +150,6 @@ pub struct ScrollState {
     pub scroll_offset: Vector2D<f32, LayoutPixel>,
 }
 
-/// The address of a node. Layout sends these back. They must be validated via
-/// `from_untrusted_node_address` before they can be used, because we do not trust layout.
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-pub struct UntrustedNodeAddress(pub *const c_void);
-
-malloc_size_of_is_0!(UntrustedNodeAddress);
-
-#[allow(unsafe_code)]
-unsafe impl Send for UntrustedNodeAddress {}
-
-impl From<style_traits::dom::OpaqueNode> for UntrustedNodeAddress {
-    fn from(o: style_traits::dom::OpaqueNode) -> Self {
-        UntrustedNodeAddress(o.0 as *const c_void)
-    }
-}
-
-impl Serialize for UntrustedNodeAddress {
-    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
-        (self.0 as usize).serialize(s)
-    }
-}
-
-impl<'de> Deserialize<'de> for UntrustedNodeAddress {
-    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<UntrustedNodeAddress, D::Error> {
-        let value: usize = Deserialize::deserialize(d)?;
-        Ok(UntrustedNodeAddress::from_id(value))
-    }
-}
-
-impl UntrustedNodeAddress {
-    /// Creates an `UntrustedNodeAddress` from the given pointer address value.
-    #[inline]
-    pub fn from_id(id: usize) -> UntrustedNodeAddress {
-        UntrustedNodeAddress(id as *const c_void)
-    }
-}
-
 /// The direction of a history traversal
 #[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
 pub enum TraversalDirection {

components/shared/constellation/message_port.rs

@@ -0,0 +1,525 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+//! This module contains data structures used for message ports and serializing
+//! DOM objects to send across them as per
+//! <https://html.spec.whatwg.org/multipage/#serializable-objects>.
+//! The implementations are here instead of in `script``, because these
+//! types can be sent through the Constellation to other ScriptThreads,
+//! and Constellation cannot depend directly on `script`.
+
+use std::cell::RefCell;
+use std::collections::{HashMap, VecDeque};
+use std::path::PathBuf;
+
+use base::id::{BlobId, DomPointId, MessagePortId};
+use log::warn;
+use malloc_size_of_derive::MallocSizeOf;
+use net_traits::filemanager_thread::RelativePos;
+use serde::{Deserialize, Serialize};
+use servo_url::ImmutableOrigin;
+use strum::{EnumIter, IntoEnumIterator};
+use uuid::Uuid;
+
+#[derive(Debug, Deserialize, MallocSizeOf, Serialize)]
+enum MessagePortState {
+    /// <https://html.spec.whatwg.org/multipage/#detached>
+    Detached,
+    /// <https://html.spec.whatwg.org/multipage/#port-message-queue>
+    /// The message-queue of this port is enabled,
+    /// the boolean represents awaiting completion of a transfer.
+    Enabled(bool),
+    /// <https://html.spec.whatwg.org/multipage/#port-message-queue>
+    /// The message-queue of this port is disabled,
+    /// the boolean represents awaiting completion of a transfer.
+    Disabled(bool),
+}
+
+#[derive(Debug, Deserialize, MallocSizeOf, Serialize)]
+/// The data and logic backing the DOM managed MessagePort.
+pub struct MessagePortImpl {
+    /// The current state of the port.
+    state: MessagePortState,
+
+    /// <https://html.spec.whatwg.org/multipage/#entangle>
+    entangled_port: Option<MessagePortId>,
+
+    /// <https://html.spec.whatwg.org/multipage/#port-message-queue>
+    message_buffer: Option<VecDeque<PortMessageTask>>,
+
+    /// The UUID of this port.
+    message_port_id: MessagePortId,
+}
+
+impl MessagePortImpl {
+    /// Create a new messageport impl.
+    pub fn new(port_id: MessagePortId) -> MessagePortImpl {
+        MessagePortImpl {
+            state: MessagePortState::Disabled(false),
+            entangled_port: None,
+            message_buffer: None,
+            message_port_id: port_id,
+        }
+    }
+
+    /// Get the Id.
+    pub fn message_port_id(&self) -> &MessagePortId {
+        &self.message_port_id
+    }
+
+    /// Maybe get the Id of the entangled port.
+    pub fn entangled_port_id(&self) -> Option<MessagePortId> {
+        self.entangled_port
+    }
+
+    /// Entanged this port with another.
+    pub fn entangle(&mut self, other_id: MessagePortId) {
+        self.entangled_port = Some(other_id);
+    }
+
+    /// Is this port enabled?
+    pub fn enabled(&self) -> bool {
+        matches!(self.state, MessagePortState::Enabled(_))
+    }
+
+    /// Mark this port as having been shipped.
+    /// <https://html.spec.whatwg.org/multipage/#has-been-shipped>
+    pub fn set_has_been_shipped(&mut self) {
+        match self.state {
+            MessagePortState::Detached => {
+                panic!("Messageport set_has_been_shipped called in detached state")
+            },
+            MessagePortState::Enabled(_) => self.state = MessagePortState::Enabled(true),
+            MessagePortState::Disabled(_) => self.state = MessagePortState::Disabled(true),
+        }
+    }
+
+    /// Handle the completion of the transfer,
+    /// this is data received from the constellation.
+    pub fn complete_transfer(&mut self, mut tasks: VecDeque<PortMessageTask>) {
+        match self.state {
+            MessagePortState::Detached => return,
+            MessagePortState::Enabled(_) => self.state = MessagePortState::Enabled(false),
+            MessagePortState::Disabled(_) => self.state = MessagePortState::Disabled(false),
+        }
+
+        // Note: these are the tasks that were buffered while the transfer was ongoing,
+        // hence they need to execute first.
+        // The global will call `start` if we are enabled,
+        // which will add tasks on the event-loop to dispatch incoming messages.
+        match self.message_buffer {
+            Some(ref mut incoming_buffer) => {
+                while let Some(task) = tasks.pop_back() {
+                    incoming_buffer.push_front(task);
+                }
+            },
+            None => self.message_buffer = Some(tasks),
+        }
+    }
+
+    /// A message was received from our entangled port,
+    /// returns an optional task to be dispatched.
+    pub fn handle_incoming(&mut self, task: PortMessageTask) -> Option<PortMessageTask> {
+        let should_dispatch = match self.state {
+            MessagePortState::Detached => return None,
+            MessagePortState::Enabled(in_transfer) => !in_transfer,
+            MessagePortState::Disabled(_) => false,
+        };
+
+        if should_dispatch {
+            Some(task)
+        } else {
+            match self.message_buffer {
+                Some(ref mut buffer) => {
+                    buffer.push_back(task);
+                },
+                None => {
+                    let mut queue = VecDeque::new();
+                    queue.push_back(task);
+                    self.message_buffer = Some(queue);
+                },
+            }
+            None
+        }
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-messageport-start>
+    /// returns an optional queue of tasks that were buffered while the port was disabled.
+    pub fn start(&mut self) -> Option<VecDeque<PortMessageTask>> {
+        match self.state {
+            MessagePortState::Detached => return None,
+            MessagePortState::Enabled(_) => {},
+            MessagePortState::Disabled(in_transfer) => {
+                self.state = MessagePortState::Enabled(in_transfer);
+            },
+        }
+        if let MessagePortState::Enabled(true) = self.state {
+            return None;
+        }
+        self.message_buffer.take()
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-messageport-close>
+    pub fn close(&mut self) {
+        // Step 1
+        self.state = MessagePortState::Detached;
+    }
+}
+
+/// A data-holder for serialized data and transferred objects.
+/// <https://html.spec.whatwg.org/multipage/#structuredserializewithtransfer>
+#[derive(Debug, Default, Deserialize, MallocSizeOf, Serialize)]
+pub struct StructuredSerializedData {
+    /// Data serialized by SpiderMonkey.
+    pub serialized: Vec<u8>,
+    /// Serialized in a structured callback,
+    pub blobs: Option<HashMap<BlobId, BlobImpl>>,
+    /// Serialized point objects.
+    pub points: Option<HashMap<DomPointId, DomPoint>>,
+    /// Transferred objects.
+    pub ports: Option<HashMap<MessagePortId, MessagePortImpl>>,
+}
+
+pub(crate) trait BroadcastClone
+where
+    Self: Sized,
+{
+    /// The ID type that uniquely identify each value.
+    type Id: Eq + std::hash::Hash + Copy;
+    /// Clone this value so that it can be reused with a broadcast channel.
+    /// Only return None if cloning is impossible.
+    fn clone_for_broadcast(&self) -> Option<Self>;
+    /// The field from which to clone values.
+    fn source(data: &StructuredSerializedData) -> &Option<HashMap<Self::Id, Self>>;
+    /// The field into which to place cloned values.
+    fn destination(data: &mut StructuredSerializedData) -> &mut Option<HashMap<Self::Id, Self>>;
+}
+
+/// All the DOM interfaces that can be serialized.
+#[derive(Clone, Copy, Debug, EnumIter)]
+pub enum Serializable {
+    /// The `Blob` interface.
+    Blob,
+    /// The `DOMPoint` interface.
+    DomPoint,
+    /// The `DOMPointReadOnly` interface.
+    DomPointReadOnly,
+}
+
+impl Serializable {
+    fn clone_values(&self) -> fn(&StructuredSerializedData, &mut StructuredSerializedData) {
+        match self {
+            Serializable::Blob => StructuredSerializedData::clone_all_of_type::<BlobImpl>,
+            Serializable::DomPointReadOnly => {
+                StructuredSerializedData::clone_all_of_type::<DomPoint>
+            },
+            Serializable::DomPoint => StructuredSerializedData::clone_all_of_type::<DomPoint>,
+        }
+    }
+}
+
+/// All the DOM interfaces that can be transferred.
+#[derive(Clone, Copy, Debug, EnumIter)]
+pub enum Transferrable {
+    /// The `MessagePort` interface.
+    MessagePort,
+}
+
+impl StructuredSerializedData {
+    fn is_empty(&self, val: Transferrable) -> bool {
+        fn is_field_empty<K, V>(field: &Option<HashMap<K, V>>) -> bool {
+            field.as_ref().is_some_and(|h| h.is_empty())
+        }
+        match val {
+            Transferrable::MessagePort => is_field_empty(&self.ports),
+        }
+    }
+
+    /// Clone all values of the same type stored in this StructuredSerializedData
+    /// into another instance.
+    fn clone_all_of_type<T: BroadcastClone>(&self, cloned: &mut StructuredSerializedData) {
+        let existing = T::source(self);
+        let Some(existing) = existing else { return };
+        let mut clones = HashMap::with_capacity(existing.len());
+
+        for (original_id, obj) in existing.iter() {
+            if let Some(clone) = obj.clone_for_broadcast() {
+                clones.insert(*original_id, clone);
+            }
+        }
+
+        *T::destination(cloned) = Some(clones);
+    }
+
+    /// Clone the serialized data for use with broadcast-channels.
+    pub fn clone_for_broadcast(&self) -> StructuredSerializedData {
+        for transferrable in Transferrable::iter() {
+            if !self.is_empty(transferrable) {
+                // Not panicking only because this is called from the constellation.
+                warn!(
+                    "Attempt to broadcast structured serialized data including {:?} (should never happen).",
+                    transferrable,
+                );
+            }
+        }
+
+        let serialized = self.serialized.clone();
+
+        let mut cloned = StructuredSerializedData {
+            serialized,
+            ..Default::default()
+        };
+
+        for serializable in Serializable::iter() {
+            let clone_impl = serializable.clone_values();
+            clone_impl(self, &mut cloned);
+        }
+
+        cloned
+    }
+}
+
+/// A task on the <https://html.spec.whatwg.org/multipage/#port-message-queue>
+#[derive(Debug, Deserialize, MallocSizeOf, Serialize)]
+pub struct PortMessageTask {
+    /// The origin of this task.
+    pub origin: ImmutableOrigin,
+    /// A data-holder for serialized data and transferred objects.
+    pub data: StructuredSerializedData,
+}
+
+/// Messages for communication between the constellation and a global managing ports.
+#[derive(Debug, Deserialize, Serialize)]
+pub enum MessagePortMsg {
+    /// Complete the transfer for a batch of ports.
+    CompleteTransfer(HashMap<MessagePortId, VecDeque<PortMessageTask>>),
+    /// Complete the transfer of a single port,
+    /// whose transfer was pending because it had been requested
+    /// while a previous failed transfer was being rolled-back.
+    CompletePendingTransfer(MessagePortId, VecDeque<PortMessageTask>),
+    /// Remove a port, the entangled one doesn't exists anymore.
+    RemoveMessagePort(MessagePortId),
+    /// Handle a new port-message-task.
+    NewTask(MessagePortId, PortMessageTask),
+}
+
+/// Message for communication between the constellation and a global managing broadcast channels.
+#[derive(Debug, Deserialize, Serialize)]
+pub struct BroadcastMsg {
+    /// The origin of this message.
+    pub origin: ImmutableOrigin,
+    /// The name of the channel.
+    pub channel_name: String,
+    /// A data-holder for serialized data.
+    pub data: StructuredSerializedData,
+}
+
+impl Clone for BroadcastMsg {
+    fn clone(&self) -> BroadcastMsg {
+        BroadcastMsg {
+            data: self.data.clone_for_broadcast(),
+            origin: self.origin.clone(),
+            channel_name: self.channel_name.clone(),
+        }
+    }
+}
+
+/// File-based blob
+#[derive(Debug, Deserialize, MallocSizeOf, Serialize)]
+pub struct FileBlob {
+    #[ignore_malloc_size_of = "Uuid are hard(not really)"]
+    id: Uuid,
+    #[ignore_malloc_size_of = "PathBuf are hard"]
+    name: Option<PathBuf>,
+    cache: RefCell<Option<Vec<u8>>>,
+    size: u64,
+}
+
+impl FileBlob {
+    /// Create a new file blob.
+    pub fn new(id: Uuid, name: Option<PathBuf>, cache: Option<Vec<u8>>, size: u64) -> FileBlob {
+        FileBlob {
+            id,
+            name,
+            cache: RefCell::new(cache),
+            size,
+        }
+    }
+
+    /// Get the size of the file.
+    pub fn get_size(&self) -> u64 {
+        self.size
+    }
+
+    /// Get the cached file data, if any.
+    pub fn get_cache(&self) -> Option<Vec<u8>> {
+        self.cache.borrow().clone()
+    }
+
+    /// Cache data.
+    pub fn cache_bytes(&self, bytes: Vec<u8>) {
+        *self.cache.borrow_mut() = Some(bytes);
+    }
+
+    /// Get the file id.
+    pub fn get_id(&self) -> Uuid {
+        self.id
+    }
+}
+
+impl BroadcastClone for BlobImpl {
+    type Id = BlobId;
+
+    fn source(
+        data: &StructuredSerializedData,
+    ) -> &Option<std::collections::HashMap<Self::Id, Self>> {
+        &data.blobs
+    }
+
+    fn destination(
+        data: &mut StructuredSerializedData,
+    ) -> &mut Option<std::collections::HashMap<Self::Id, Self>> {
+        &mut data.blobs
+    }
+
+    fn clone_for_broadcast(&self) -> Option<Self> {
+        let type_string = self.type_string();
+
+        if let BlobData::Memory(bytes) = self.blob_data() {
+            let blob_clone = BlobImpl::new_from_bytes(bytes.clone(), type_string);
+
+            // Note: we insert the blob at the original id,
+            // otherwise this will not match the storage key as serialized by SM in `serialized`.
+            // The clone has it's own new Id however.
+            return Some(blob_clone);
+        } else {
+            // Not panicking only because this is called from the constellation.
+            log::warn!("Serialized blob not in memory format(should never happen).");
+        }
+        None
+    }
+}
+
+/// The data backing a DOM Blob.
+#[derive(Debug, Deserialize, MallocSizeOf, Serialize)]
+pub struct BlobImpl {
+    /// UUID of the blob.
+    blob_id: BlobId,
+    /// Content-type string
+    type_string: String,
+    /// Blob data-type.
+    blob_data: BlobData,
+    /// Sliced blobs referring to this one.
+    slices: Vec<BlobId>,
+}
+
+/// Different backends of Blob
+#[derive(Debug, Deserialize, MallocSizeOf, Serialize)]
+pub enum BlobData {
+    /// File-based blob, whose content lives in the net process
+    File(FileBlob),
+    /// Memory-based blob, whose content lives in the script process
+    Memory(Vec<u8>),
+    /// Sliced blob, including parent blob-id and
+    /// relative positions of current slicing range,
+    /// IMPORTANT: The depth of tree is only two, i.e. the parent Blob must be
+    /// either File-based or Memory-based
+    Sliced(BlobId, RelativePos),
+}
+
+impl BlobImpl {
+    /// Construct memory-backed BlobImpl
+    pub fn new_from_bytes(bytes: Vec<u8>, type_string: String) -> BlobImpl {
+        let blob_id = BlobId::new();
+        let blob_data = BlobData::Memory(bytes);
+        BlobImpl {
+            blob_id,
+            type_string,
+            blob_data,
+            slices: vec![],
+        }
+    }
+
+    /// Construct file-backed BlobImpl from File ID
+    pub fn new_from_file(file_id: Uuid, name: PathBuf, size: u64, type_string: String) -> BlobImpl {
+        let blob_id = BlobId::new();
+        let blob_data = BlobData::File(FileBlob {
+            id: file_id,
+            name: Some(name),
+            cache: RefCell::new(None),
+            size,
+        });
+        BlobImpl {
+            blob_id,
+            type_string,
+            blob_data,
+            slices: vec![],
+        }
+    }
+
+    /// Construct a BlobImpl from a slice of a parent.
+    pub fn new_sliced(rel_pos: RelativePos, parent: BlobId, type_string: String) -> BlobImpl {
+        let blob_id = BlobId::new();
+        let blob_data = BlobData::Sliced(parent, rel_pos);
+        BlobImpl {
+            blob_id,
+            type_string,
+            blob_data,
+            slices: vec![],
+        }
+    }
+
+    /// Get a clone of the blob-id
+    pub fn blob_id(&self) -> BlobId {
+        self.blob_id
+    }
+
+    /// Get a clone of the type-string
+    pub fn type_string(&self) -> String {
+        self.type_string.clone()
+    }
+
+    /// Get a mutable ref to the data
+    pub fn blob_data(&self) -> &BlobData {
+        &self.blob_data
+    }
+
+    /// Get a mutable ref to the data
+    pub fn blob_data_mut(&mut self) -> &mut BlobData {
+        &mut self.blob_data
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, MallocSizeOf, Serialize)]
+/// A serializable version of the DOMPoint/DOMPointReadOnly interface.
+pub struct DomPoint {
+    /// The x coordinate.
+    pub x: f64,
+    /// The y coordinate.
+    pub y: f64,
+    /// The z coordinate.
+    pub z: f64,
+    /// The w coordinate.
+    pub w: f64,
+}
+
+impl BroadcastClone for DomPoint {
+    type Id = DomPointId;
+
+    fn source(
+        data: &StructuredSerializedData,
+    ) -> &Option<std::collections::HashMap<Self::Id, Self>> {
+        &data.points
+    }
+
+    fn destination(
+        data: &mut StructuredSerializedData,
+    ) -> &mut Option<std::collections::HashMap<Self::Id, Self>> {
+        &mut data.points
+    }
+
+    fn clone_for_broadcast(&self) -> Option<Self> {
+        Some(self.clone())
+    }
+}