Move *_traits and other shared types to shared

This is the start of the organization of types that are in their own
crates in order to break dependency cycles between other crates. The
idea here is that putting these packages into their own directory is the
first step toward cleaning them up. They have grown organically and it
is difficult to explain to new folks where to put new shared types. Many
of these crates contain more than traits or don't contain traits at all.

Notably, `script_traits` isn't touched because it is vendored from
Gecko. Eventually this will move to `third_party`.

components/shared/script/Cargo.toml

@@ -0,0 +1,47 @@
+[package]
+name = "script_traits"
+version = "0.0.1"
+authors = ["The Servo Project Developers"]
+license = "MPL-2.0"
+edition = "2018"
+publish = false
+
+[lib]
+name = "script_traits"
+path = "lib.rs"
+
+[dependencies]
+bitflags = { workspace = true }
+bluetooth_traits = { workspace = true }
+canvas_traits = { workspace = true }
+cookie = { workspace = true }
+crossbeam-channel = { workspace = true }
+devtools_traits = { workspace = true }
+embedder_traits = { workspace = true }
+euclid = { workspace = true }
+gfx_traits = { workspace = true }
+headers = { workspace = true }
+http = { workspace = true }
+hyper_serde = { workspace = true }
+ipc-channel = { workspace = true }
+keyboard-types = { workspace = true }
+libc = { workspace = true }
+log = { workspace = true }
+malloc_size_of = { path = "../../malloc_size_of" }
+malloc_size_of_derive = { workspace = true }
+media = { path = "../../media" }
+msg = { workspace = true }
+net_traits = { workspace = true }
+pixels = { path = "../../pixels" }
+profile_traits = { workspace = true }
+serde = { workspace = true }
+servo_atoms = { path = "../../atoms" }
+servo_url = { path = "../../url" }
+smallvec = { workspace = true }
+style_traits = { workspace = true }
+time = { workspace = true }
+uuid = { workspace = true }
+webdriver = { workspace = true }
+webgpu = { path = "../../webgpu" }
+webrender_api = { workspace = true }
+webxr-api = { git = "https://github.com/servo/webxr", features = ["ipc"] }

components/shared/script/compositor.rs

@@ -0,0 +1,306 @@
+/* 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/. */
+
+//! Defines data structures which are consumed by the Compositor.
+
+use embedder_traits::Cursor;
+use serde::{Deserialize, Serialize};
+use webrender_api::units::{LayoutSize, LayoutVector2D};
+use webrender_api::{
+    Epoch, ExternalScrollId, PipelineId, ScrollLocation, ScrollSensitivity, SpatialId,
+};
+
+/// Information that Servo keeps alongside WebRender display items
+/// in order to add more context to hit test results.
+#[derive(Debug, Deserialize, Serialize)]
+pub struct HitTestInfo {
+    /// The id of the node of this hit test item.
+    pub node: u64,
+
+    /// The cursor of this node's hit test item.
+    pub cursor: Option<Cursor>,
+
+    /// The id of the [ScrollTree] associated with this hit test item.
+    pub scroll_tree_node: ScrollTreeNodeId,
+}
+
+/// An id for a ScrollTreeNode in the ScrollTree. This contains both the index
+/// to the node in the tree's array of nodes as well as the corresponding SpatialId
+/// for the SpatialNode in the WebRender display list.
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize)]
+pub struct ScrollTreeNodeId {
+    /// The index of this scroll tree node in the tree's array of nodes.
+    pub index: usize,
+
+    /// The WebRender spatial id of this scroll tree node.
+    pub spatial_id: SpatialId,
+}
+
+/// Data stored for nodes in the [ScrollTree] that actually scroll,
+/// as opposed to reference frames and sticky nodes which do not.
+#[derive(Debug, Deserialize, Serialize)]
+pub struct ScrollableNodeInfo {
+    /// The external scroll id of this node, used to track
+    /// it between successive re-layouts.
+    pub external_id: ExternalScrollId,
+
+    /// Amount that this `ScrollableNode` can scroll in both directions.
+    pub scrollable_size: LayoutSize,
+
+    /// Whether this `ScrollableNode` is sensitive to input events.
+    pub scroll_sensitivity: ScrollSensitivity,
+
+    /// The current offset of this scroll node.
+    pub offset: LayoutVector2D,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+/// A node in a tree of scroll nodes. This may either be a scrollable
+/// node which responds to scroll events or a non-scrollable one.
+pub struct ScrollTreeNode {
+    /// The index of the parent of this node in the tree. If this is
+    /// None then this is the root node.
+    pub parent: Option<ScrollTreeNodeId>,
+
+    /// Scrolling data which will not be None if this is a scrolling node.
+    pub scroll_info: Option<ScrollableNodeInfo>,
+}
+
+impl ScrollTreeNode {
+    /// Get the external id of this node.
+    pub fn external_id(&self) -> Option<ExternalScrollId> {
+        self.scroll_info.as_ref().map(|info| info.external_id)
+    }
+
+    /// Get the offset id of this node if it applies.
+    pub fn offset(&self) -> Option<LayoutVector2D> {
+        self.scroll_info.as_ref().map(|info| info.offset)
+    }
+
+    /// Set the offset for this node, returns false if this was a
+    /// non-scrolling node for which you cannot set the offset.
+    pub fn set_offset(&mut self, new_offset: LayoutVector2D) -> bool {
+        match self.scroll_info {
+            Some(ref mut info) => {
+                info.offset = new_offset;
+                true
+            },
+            _ => false,
+        }
+    }
+
+    /// Scroll this node given a WebRender ScrollLocation. Returns a tuple that can
+    /// be used to scroll an individual WebRender scroll frame if the operation
+    /// actually changed an offset.
+    pub fn scroll(
+        &mut self,
+        scroll_location: ScrollLocation,
+    ) -> Option<(ExternalScrollId, LayoutVector2D)> {
+        let mut info = match self.scroll_info {
+            Some(ref mut data) => data,
+            None => return None,
+        };
+
+        if info.scroll_sensitivity != ScrollSensitivity::ScriptAndInputEvents {
+            return None;
+        }
+
+        let delta = match scroll_location {
+            ScrollLocation::Delta(delta) => delta,
+            ScrollLocation::Start => {
+                if info.offset.y.round() >= 0.0 {
+                    // Nothing to do on this layer.
+                    return None;
+                }
+
+                info.offset.y = 0.0;
+                return Some((info.external_id, info.offset));
+            },
+            ScrollLocation::End => {
+                let end_pos = -info.scrollable_size.height;
+                if info.offset.y.round() <= end_pos {
+                    // Nothing to do on this layer.
+                    return None;
+                }
+
+                info.offset.y = end_pos;
+                return Some((info.external_id, info.offset));
+            },
+        };
+
+        let scrollable_width = info.scrollable_size.width;
+        let scrollable_height = info.scrollable_size.height;
+        let original_layer_scroll_offset = info.offset.clone();
+
+        if scrollable_width > 0. {
+            info.offset.x = (info.offset.x + delta.x).min(0.0).max(-scrollable_width);
+        }
+
+        if scrollable_height > 0. {
+            info.offset.y = (info.offset.y + delta.y).min(0.0).max(-scrollable_height);
+        }
+
+        if info.offset != original_layer_scroll_offset {
+            Some((info.external_id, info.offset))
+        } else {
+            None
+        }
+    }
+}
+
+/// A tree of spatial nodes, which mirrors the spatial nodes in the WebRender
+/// display list, except these are used to scrolling in the compositor so that
+/// new offsets can be sent to WebRender.
+#[derive(Debug, Default, Deserialize, Serialize)]
+pub struct ScrollTree {
+    /// A list of compositor-side scroll nodes that describe the tree
+    /// of WebRender spatial nodes, used by the compositor to scroll the
+    /// contents of the display list.
+    pub nodes: Vec<ScrollTreeNode>,
+}
+
+impl ScrollTree {
+    /// Add a scroll node to this ScrollTree returning the id of the new node.
+    pub fn add_scroll_tree_node(
+        &mut self,
+        parent: Option<&ScrollTreeNodeId>,
+        spatial_id: SpatialId,
+        scroll_info: Option<ScrollableNodeInfo>,
+    ) -> ScrollTreeNodeId {
+        self.nodes.push(ScrollTreeNode {
+            parent: parent.cloned(),
+            scroll_info,
+        });
+        return ScrollTreeNodeId {
+            index: self.nodes.len() - 1,
+            spatial_id,
+        };
+    }
+
+    /// Get a mutable reference to the node with the given index.
+    pub fn get_node_mut(&mut self, id: &ScrollTreeNodeId) -> &mut ScrollTreeNode {
+        &mut self.nodes[id.index]
+    }
+
+    /// Get an immutable reference to the node with the given index.
+    pub fn get_node(&mut self, id: &ScrollTreeNodeId) -> &ScrollTreeNode {
+        &self.nodes[id.index]
+    }
+
+    /// Scroll the given scroll node on this scroll tree. If the node cannot be scrolled,
+    /// because it isn't a scrollable node or it's already scrolled to the maximum scroll
+    /// extent, try to scroll an ancestor of this node. Returns the node scrolled and the
+    /// new offset if a scroll was performed, otherwise returns None.
+    pub fn scroll_node_or_ancestor(
+        &mut self,
+        scroll_node_id: &ScrollTreeNodeId,
+        scroll_location: ScrollLocation,
+    ) -> Option<(ExternalScrollId, LayoutVector2D)> {
+        let parent = {
+            let ref mut node = self.get_node_mut(scroll_node_id);
+            let result = node.scroll(scroll_location);
+            if result.is_some() {
+                return result;
+            }
+            node.parent
+        };
+
+        parent.and_then(|parent| self.scroll_node_or_ancestor(&parent, scroll_location))
+    }
+}
+
+/// A data structure which stores compositor-side information about
+/// display lists sent to the compositor.
+#[derive(Debug, Deserialize, Serialize)]
+pub struct CompositorDisplayListInfo {
+    /// The WebRender [PipelineId] of this display list.
+    pub pipeline_id: PipelineId,
+
+    /// The size of the viewport that this display list renders into.
+    pub viewport_size: LayoutSize,
+
+    /// The size of this display list's content.
+    pub content_size: LayoutSize,
+
+    /// The epoch of the display list.
+    pub epoch: Epoch,
+
+    /// An array of `HitTestInfo` which is used to store information
+    /// to assist the compositor to take various actions (set the cursor,
+    /// scroll without layout) using a WebRender hit test result.
+    pub hit_test_info: Vec<HitTestInfo>,
+
+    /// A ScrollTree used by the compositor to scroll the contents of the
+    /// display list.
+    pub scroll_tree: ScrollTree,
+
+    /// The `ScrollTreeNodeId` of the root reference frame of this info's scroll
+    /// tree.
+    pub root_reference_frame_id: ScrollTreeNodeId,
+
+    /// The `ScrollTreeNodeId` of the topmost scrolling frame of this info's scroll
+    /// tree.
+    pub root_scroll_node_id: ScrollTreeNodeId,
+}
+
+impl CompositorDisplayListInfo {
+    /// Create a new CompositorDisplayListInfo with the root reference frame
+    /// and scroll frame already added to the scroll tree.
+    pub fn new(
+        viewport_size: LayoutSize,
+        content_size: LayoutSize,
+        pipeline_id: PipelineId,
+        epoch: Epoch,
+    ) -> Self {
+        let mut scroll_tree = ScrollTree::default();
+        let root_reference_frame_id = scroll_tree.add_scroll_tree_node(
+            None,
+            SpatialId::root_reference_frame(pipeline_id),
+            None,
+        );
+        let root_scroll_node_id = scroll_tree.add_scroll_tree_node(
+            Some(&root_reference_frame_id),
+            SpatialId::root_scroll_node(pipeline_id),
+            Some(ScrollableNodeInfo {
+                external_id: ExternalScrollId(0, pipeline_id),
+                scrollable_size: content_size - viewport_size,
+                scroll_sensitivity: ScrollSensitivity::ScriptAndInputEvents,
+                offset: LayoutVector2D::zero(),
+            }),
+        );
+
+        CompositorDisplayListInfo {
+            pipeline_id,
+            viewport_size,
+            content_size,
+            epoch,
+            hit_test_info: Default::default(),
+            scroll_tree,
+            root_reference_frame_id,
+            root_scroll_node_id,
+        }
+    }
+
+    /// Add or re-use a duplicate HitTestInfo entry in this `CompositorHitTestInfo`
+    /// and return the index.
+    pub fn add_hit_test_info(
+        &mut self,
+        node: u64,
+        cursor: Option<Cursor>,
+        scroll_tree_node: ScrollTreeNodeId,
+    ) -> usize {
+        if let Some(last) = self.hit_test_info.last() {
+            if node == last.node && cursor == last.cursor {
+                return self.hit_test_info.len() - 1;
+            }
+        }
+
+        self.hit_test_info.push(HitTestInfo {
+            node,
+            cursor,
+            scroll_tree_node,
+        });
+        self.hit_test_info.len() - 1
+    }
+}

components/shared/script/script_msg.rs

@@ -0,0 +1,493 @@
+/* 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/. */
+
+use std::collections::{HashMap, VecDeque};
+use std::fmt;
+
+use canvas_traits::canvas::{CanvasId, CanvasMsg};
+use devtools_traits::{ScriptToDevtoolsControlMsg, WorkerId};
+use embedder_traits::{EmbedderMsg, MediaSessionEvent};
+use euclid::default::Size2D as UntypedSize2D;
+use euclid::Size2D;
+use gfx_traits::Epoch;
+use ipc_channel::ipc::{IpcReceiver, IpcSender};
+use msg::constellation_msg::{
+    BroadcastChannelRouterId, BrowsingContextId, HistoryStateId, MessagePortId,
+    MessagePortRouterId, PipelineId, ServiceWorkerId, ServiceWorkerRegistrationId,
+    TopLevelBrowsingContextId, TraversalDirection,
+};
+use net_traits::request::RequestBuilder;
+use net_traits::storage_thread::StorageType;
+use net_traits::CoreResourceMsg;
+use serde::{Deserialize, Serialize};
+use servo_url::{ImmutableOrigin, ServoUrl};
+use smallvec::SmallVec;
+use style_traits::CSSPixel;
+use webgpu::{wgpu, WebGPU, WebGPUResponseResult};
+use webrender_api::units::{DeviceIntPoint, DeviceIntSize};
+
+use crate::{
+    AnimationState, AuxiliaryBrowsingContextLoadInfo, BroadcastMsg, DocumentState,
+    IFrameLoadInfoWithData, LayoutControlMsg, LoadData, MessagePortMsg, PortMessageTask,
+    StructuredSerializedData, WindowSizeType, WorkerGlobalScopeInit, WorkerScriptLoadOrigin,
+};
+
+/// 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 of the iframe.
+    pub size: Size2D<f32, CSSPixel>,
+    /// The kind of sizing operation.
+    pub type_: WindowSizeType,
+}
+
+/// Messages from the layout to the constellation.
+#[derive(Deserialize, Serialize)]
+pub enum LayoutMsg {
+    /// Inform the constellation of the size of the iframe's viewport.
+    IFrameSizes(Vec<IFrameSizeMsg>),
+    /// Requests that the constellation inform the compositor that it needs to record
+    /// the time when the frame with the given ID (epoch) is painted.
+    PendingPaintMetric(PipelineId, Epoch),
+}
+
+impl fmt::Debug for LayoutMsg {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        use self::LayoutMsg::*;
+        let variant = match *self {
+            IFrameSizes(..) => "IFrameSizes",
+            PendingPaintMetric(..) => "PendingPaintMetric",
+        };
+        write!(formatter, "LayoutMsg::{}", variant)
+    }
+}
+
+/// Whether a DOM event was prevented by web content
+#[derive(Debug, Deserialize, Serialize)]
+pub enum EventResult {
+    /// Allowed by web content
+    DefaultAllowed,
+    /// Prevented by web content
+    DefaultPrevented,
+}
+
+/// A log entry reported to the constellation
+/// We don't report all log entries, just serious ones.
+/// We need a separate type for this because `LogLevel` isn't serializable.
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub enum LogEntry {
+    /// Panic, with a reason and backtrace
+    Panic(String, String),
+    /// Error, with a reason
+    Error(String),
+    /// warning, with a reason
+    Warn(String),
+}
+
+/// https://html.spec.whatwg.org/multipage/#replacement-enabled
+#[derive(Debug, Deserialize, Serialize)]
+pub enum HistoryEntryReplacement {
+    /// Traverse the history with replacement enabled.
+    Enabled,
+    /// Traverse the history with replacement disabled.
+    Disabled,
+}
+
+/// Messages from the script to the constellation.
+#[derive(Deserialize, Serialize)]
+pub enum ScriptMsg {
+    /// 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),
+    /// Requests are sent to constellation and fetches are checked manually
+    /// for cross-origin loads
+    InitiateNavigateRequest(RequestBuilder, /* cancellation_chan */ IpcReceiver<()>),
+    /// 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)>,
+    ),
+    /// 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<TopLevelBrowsingContextId>>,
+    ),
+    /// 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, HistoryEntryReplacement),
+    /// 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, HistoryEntryReplacement),
+    /// 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>>),
+    /// Notifies constellation that an iframe's visibility has been changed.
+    VisibilityChangeComplete(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, IpcSender<LayoutControlMsg>),
+    /// Script has opened a new auxiliary browsing context.
+    ScriptNewAuxiliary(
+        AuxiliaryBrowsingContextLoadInfo,
+        IpcSender<LayoutControlMsg>,
+    ),
+    /// Mark a new document as active
+    ActivateDocument,
+    /// Set the document state for a pipeline (used by screenshot / reftests)
+    SetDocumentState(DocumentState),
+    /// 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(EventResult),
+    /// 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),
+    /// Get Window Informations size and position
+    GetClientWindow(IpcSender<(DeviceIntSize, DeviceIntPoint)>),
+    /// Get the screen size (pixel)
+    GetScreenSize(IpcSender<DeviceIntSize>),
+    /// Get the available screen size (pixel)
+    GetScreenAvailSize(IpcSender<DeviceIntSize>),
+    /// Notifies the constellation about media session events
+    /// (i.e. when there is metadata for the active media session, playback state changes...).
+    MediaSessionEvent(PipelineId, MediaSessionEvent),
+    /// Create a WebGPU Adapter instance
+    RequestAdapter(
+        IpcSender<WebGPUResponseResult>,
+        wgpu::instance::RequestAdapterOptions,
+        SmallVec<[wgpu::id::AdapterId; 4]>,
+    ),
+    /// Get WebGPU channel
+    GetWebGPUChan(IpcSender<WebGPU>),
+    /// Notify the constellation of a pipeline's document's title.
+    TitleChanged(PipelineId, String),
+}
+
+impl fmt::Debug for ScriptMsg {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        use self::ScriptMsg::*;
+        let variant = match *self {
+            CompleteMessagePortTransfer(..) => "CompleteMessagePortTransfer",
+            MessagePortTransferResult(..) => "MessagePortTransferResult",
+            NewMessagePortRouter(..) => "NewMessagePortRouter",
+            RemoveMessagePortRouter(..) => "RemoveMessagePortRouter",
+            NewMessagePort(..) => "NewMessagePort",
+            RerouteMessagePort(..) => "RerouteMessagePort",
+            RemoveMessagePort(..) => "RemoveMessagePort",
+            MessagePortShipped(..) => "MessagePortShipped",
+            EntanglePorts(..) => "EntanglePorts",
+            NewBroadcastChannelRouter(..) => "NewBroadcastChannelRouter",
+            RemoveBroadcastChannelRouter(..) => "RemoveBroadcastChannelRouter",
+            RemoveBroadcastChannelNameInRouter(..) => "RemoveBroadcastChannelNameInRouter",
+            NewBroadcastChannelNameInRouter(..) => "NewBroadcastChannelNameInRouter",
+            ScheduleBroadcast(..) => "ScheduleBroadcast",
+            ForwardToEmbedder(..) => "ForwardToEmbedder",
+            InitiateNavigateRequest(..) => "InitiateNavigateRequest",
+            BroadcastStorageEvent(..) => "BroadcastStorageEvent",
+            ChangeRunningAnimationsState(..) => "ChangeRunningAnimationsState",
+            CreateCanvasPaintThread(..) => "CreateCanvasPaintThread",
+            Focus => "Focus",
+            GetBrowsingContextInfo(..) => "GetBrowsingContextInfo",
+            GetTopForBrowsingContext(..) => "GetParentBrowsingContext",
+            GetChildBrowsingContextId(..) => "GetChildBrowsingContextId",
+            LoadComplete => "LoadComplete",
+            LoadUrl(..) => "LoadUrl",
+            AbortLoadUrl => "AbortLoadUrl",
+            PostMessage { .. } => "PostMessage",
+            NavigatedToFragment(..) => "NavigatedToFragment",
+            TraverseHistory(..) => "TraverseHistory",
+            PushHistoryState(..) => "PushHistoryState",
+            ReplaceHistoryState(..) => "ReplaceHistoryState",
+            JointSessionHistoryLength(..) => "JointSessionHistoryLength",
+            RemoveIFrame(..) => "RemoveIFrame",
+            VisibilityChangeComplete(..) => "VisibilityChangeComplete",
+            ScriptLoadedURLInIFrame(..) => "ScriptLoadedURLInIFrame",
+            ScriptNewIFrame(..) => "ScriptNewIFrame",
+            ScriptNewAuxiliary(..) => "ScriptNewAuxiliary",
+            ActivateDocument => "ActivateDocument",
+            SetDocumentState(..) => "SetDocumentState",
+            SetFinalUrl(..) => "SetFinalUrl",
+            TouchEventProcessed(..) => "TouchEventProcessed",
+            LogEntry(..) => "LogEntry",
+            DiscardDocument => "DiscardDocument",
+            DiscardTopLevelBrowsingContext => "DiscardTopLevelBrowsingContext",
+            PipelineExited => "PipelineExited",
+            ForwardDOMMessage(..) => "ForwardDOMMessage",
+            ScheduleJob(..) => "ScheduleJob",
+            GetClientWindow(..) => "GetClientWindow",
+            GetScreenSize(..) => "GetScreenSize",
+            GetScreenAvailSize(..) => "GetScreenAvailSize",
+            MediaSessionEvent(..) => "MediaSessionEvent",
+            RequestAdapter(..) => "RequestAdapter",
+            GetWebGPUChan(..) => "GetWebGPUChan",
+            TitleChanged(..) => "TitleChanged",
+        };
+        write!(formatter, "ScriptMsg::{}", variant)
+    }
+}
+
+/// 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)]
+/// 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,
+}

components/shared/script/serializable.rs

@@ -0,0 +1,151 @@
+/* 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 implementations in script that are serializable,
+//! as per https://html.spec.whatwg.org/multipage/#serializable-objects.
+//! The implementations are here instead of in script
+//! so that the other modules involved in the serialization don't have
+//! to depend on script.
+
+use std::cell::RefCell;
+use std::path::PathBuf;
+
+use malloc_size_of_derive::MallocSizeOf;
+use msg::constellation_msg::BlobId;
+use net_traits::filemanager_thread::RelativePos;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+/// 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.clone()
+    }
+
+    /// 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.clone()
+    }
+}
+
+/// 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: 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.clone()
+    }
+
+    /// 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
+    }
+}

components/shared/script/tests/compositor.rs

@@ -0,0 +1,179 @@
+/* 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/. */
+
+use euclid::Size2D;
+use script_traits::compositor::{ScrollTree, ScrollTreeNodeId, ScrollableNodeInfo};
+use webrender_api::units::LayoutVector2D;
+use webrender_api::{ExternalScrollId, PipelineId, ScrollLocation, ScrollSensitivity, SpatialId};
+
+fn add_mock_scroll_node(tree: &mut ScrollTree) -> ScrollTreeNodeId {
+    let pipeline_id = PipelineId(0, 0);
+    let num_nodes = tree.nodes.len();
+    let parent = if num_nodes > 0 {
+        Some(ScrollTreeNodeId {
+            index: num_nodes - 1,
+            spatial_id: SpatialId::new(num_nodes - 1, pipeline_id),
+        })
+    } else {
+        None
+    };
+
+    tree.add_scroll_tree_node(
+        parent.as_ref(),
+        SpatialId::new(num_nodes, pipeline_id),
+        Some(ScrollableNodeInfo {
+            external_id: ExternalScrollId(num_nodes as u64, pipeline_id),
+            scrollable_size: Size2D::new(100.0, 100.0),
+            scroll_sensitivity: ScrollSensitivity::ScriptAndInputEvents,
+            offset: LayoutVector2D::zero(),
+        }),
+    )
+}
+
+#[test]
+fn test_scroll_tree_simple_scroll() {
+    let mut scroll_tree = ScrollTree::default();
+    let pipeline_id = PipelineId(0, 0);
+    let id = add_mock_scroll_node(&mut scroll_tree);
+
+    let (scrolled_id, offset) = scroll_tree
+        .scroll_node_or_ancestor(
+            &id,
+            ScrollLocation::Delta(LayoutVector2D::new(-20.0, -40.0)),
+        )
+        .unwrap();
+    let expected_offset = LayoutVector2D::new(-20.0, -40.0);
+    assert_eq!(scrolled_id, ExternalScrollId(0, pipeline_id));
+    assert_eq!(offset, expected_offset);
+    assert_eq!(scroll_tree.get_node(&id).offset(), Some(expected_offset));
+
+    let (scrolled_id, offset) = scroll_tree
+        .scroll_node_or_ancestor(&id, ScrollLocation::Delta(LayoutVector2D::new(20.0, 40.0)))
+        .unwrap();
+    let expected_offset = LayoutVector2D::new(0.0, 0.0);
+    assert_eq!(scrolled_id, ExternalScrollId(0, pipeline_id));
+    assert_eq!(offset, expected_offset);
+    assert_eq!(scroll_tree.get_node(&id).offset(), Some(expected_offset));
+
+    // Scroll offsets must be negative.
+    let result = scroll_tree
+        .scroll_node_or_ancestor(&id, ScrollLocation::Delta(LayoutVector2D::new(20.0, 40.0)));
+    assert!(result.is_none());
+    assert_eq!(
+        scroll_tree.get_node(&id).offset(),
+        Some(LayoutVector2D::new(0.0, 0.0))
+    );
+}
+
+#[test]
+fn test_scroll_tree_simple_scroll_chaining() {
+    let mut scroll_tree = ScrollTree::default();
+
+    let pipeline_id = PipelineId(0, 0);
+    let parent_id = add_mock_scroll_node(&mut scroll_tree);
+    let unscrollable_child_id =
+        scroll_tree.add_scroll_tree_node(Some(&parent_id), SpatialId::new(1, pipeline_id), None);
+
+    let (scrolled_id, offset) = scroll_tree
+        .scroll_node_or_ancestor(
+            &unscrollable_child_id,
+            ScrollLocation::Delta(LayoutVector2D::new(-20.0, -40.0)),
+        )
+        .unwrap();
+    let expected_offset = LayoutVector2D::new(-20.0, -40.0);
+    assert_eq!(scrolled_id, ExternalScrollId(0, pipeline_id));
+    assert_eq!(offset, expected_offset);
+    assert_eq!(
+        scroll_tree.get_node(&parent_id).offset(),
+        Some(expected_offset)
+    );
+
+    let (scrolled_id, offset) = scroll_tree
+        .scroll_node_or_ancestor(
+            &unscrollable_child_id,
+            ScrollLocation::Delta(LayoutVector2D::new(-10.0, -15.0)),
+        )
+        .unwrap();
+    let expected_offset = LayoutVector2D::new(-30.0, -55.0);
+    assert_eq!(scrolled_id, ExternalScrollId(0, pipeline_id));
+    assert_eq!(offset, expected_offset);
+    assert_eq!(
+        scroll_tree.get_node(&parent_id).offset(),
+        Some(expected_offset)
+    );
+    assert_eq!(scroll_tree.get_node(&unscrollable_child_id).offset(), None);
+}
+
+#[test]
+fn test_scroll_tree_chain_when_at_extent() {
+    let mut scroll_tree = ScrollTree::default();
+
+    let pipeline_id = PipelineId(0, 0);
+    let parent_id = add_mock_scroll_node(&mut scroll_tree);
+    let child_id = add_mock_scroll_node(&mut scroll_tree);
+
+    let (scrolled_id, offset) = scroll_tree
+        .scroll_node_or_ancestor(&child_id, ScrollLocation::End)
+        .unwrap();
+
+    let expected_offset = LayoutVector2D::new(0.0, -100.0);
+    assert_eq!(scrolled_id, ExternalScrollId(1, pipeline_id));
+    assert_eq!(offset, expected_offset);
+    assert_eq!(
+        scroll_tree.get_node(&child_id).offset(),
+        Some(expected_offset)
+    );
+
+    // The parent will have scrolled because the child is already at the extent
+    // of its scroll area in the y axis.
+    let (scrolled_id, offset) = scroll_tree
+        .scroll_node_or_ancestor(
+            &child_id,
+            ScrollLocation::Delta(LayoutVector2D::new(0.0, -10.0)),
+        )
+        .unwrap();
+    let expected_offset = LayoutVector2D::new(0.0, -10.0);
+    assert_eq!(scrolled_id, ExternalScrollId(0, pipeline_id));
+    assert_eq!(offset, expected_offset);
+    assert_eq!(
+        scroll_tree.get_node(&parent_id).offset(),
+        Some(expected_offset)
+    );
+}
+
+#[test]
+fn test_scroll_tree_chain_through_overflow_hidden() {
+    let mut scroll_tree = ScrollTree::default();
+
+    // Create a tree with a scrollable leaf, but make its `scroll_sensitivity`
+    // reflect `overflow: hidden` ie not responsive to non-script scroll events.
+    let pipeline_id = PipelineId(0, 0);
+    let parent_id = add_mock_scroll_node(&mut scroll_tree);
+    let overflow_hidden_id = add_mock_scroll_node(&mut scroll_tree);
+    scroll_tree
+        .get_node_mut(&overflow_hidden_id)
+        .scroll_info
+        .as_mut()
+        .map(|mut info| {
+            info.scroll_sensitivity = ScrollSensitivity::Script;
+        });
+
+    let (scrolled_id, offset) = scroll_tree
+        .scroll_node_or_ancestor(
+            &overflow_hidden_id,
+            ScrollLocation::Delta(LayoutVector2D::new(-20.0, -40.0)),
+        )
+        .unwrap();
+    let expected_offset = LayoutVector2D::new(-20.0, -40.0);
+    assert_eq!(scrolled_id, ExternalScrollId(0, pipeline_id));
+    assert_eq!(offset, expected_offset);
+    assert_eq!(
+        scroll_tree.get_node(&parent_id).offset(),
+        Some(expected_offset)
+    );
+    assert_eq!(
+        scroll_tree.get_node(&overflow_hidden_id).offset(),
+        Some(LayoutVector2D::new(0.0, 0.0))
+    );
+}

components/shared/script/transferable.rs

@@ -0,0 +1,164 @@
+/* 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 implementations in script that are transferable.
+//! The implementations are here instead of in script
+//! so that the other modules involved in the transfer don't have
+//! to depend on script.
+
+use std::collections::VecDeque;
+
+use malloc_size_of_derive::MallocSizeOf;
+use msg::constellation_msg::MessagePortId;
+use serde::{Deserialize, Serialize};
+
+use crate::PortMessageTask;
+
+#[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.clone()
+    }
+
+    /// 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 {
+        match self.state {
+            MessagePortState::Enabled(_) => true,
+            _ => false,
+        }
+    }
+
+    /// 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;
+    }
+}

components/shared/script/webdriver_msg.rs

@@ -0,0 +1,138 @@
+/* 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/. */
+
+#![allow(missing_docs)]
+
+use std::collections::HashMap;
+
+use cookie::Cookie;
+use euclid::default::Rect;
+use hyper_serde::Serde;
+use ipc_channel::ipc::IpcSender;
+use msg::constellation_msg::BrowsingContextId;
+use serde::{Deserialize, Serialize};
+use servo_url::ServoUrl;
+use webdriver::common::{WebElement, WebFrame, WebWindow};
+use webdriver::error::ErrorStatus;
+
+#[derive(Debug, Deserialize, Serialize)]
+pub enum WebDriverScriptCommand {
+    AddCookie(
+        #[serde(
+            deserialize_with = "::hyper_serde::deserialize",
+            serialize_with = "::hyper_serde::serialize"
+        )]
+        Cookie<'static>,
+        IpcSender<Result<(), WebDriverCookieError>>,
+    ),
+    DeleteCookies(IpcSender<Result<(), ErrorStatus>>),
+    ExecuteScript(String, IpcSender<WebDriverJSResult>),
+    ExecuteAsyncScript(String, IpcSender<WebDriverJSResult>),
+    FindElementCSS(String, IpcSender<Result<Option<String>, ErrorStatus>>),
+    FindElementLinkText(String, bool, IpcSender<Result<Option<String>, ErrorStatus>>),
+    FindElementTagName(String, IpcSender<Result<Option<String>, ErrorStatus>>),
+    FindElementsCSS(String, IpcSender<Result<Vec<String>, ErrorStatus>>),
+    FindElementsLinkText(String, bool, IpcSender<Result<Vec<String>, ErrorStatus>>),
+    FindElementsTagName(String, IpcSender<Result<Vec<String>, ErrorStatus>>),
+    FindElementElementCSS(
+        String,
+        String,
+        IpcSender<Result<Option<String>, ErrorStatus>>,
+    ),
+    FindElementElementLinkText(
+        String,
+        String,
+        bool,
+        IpcSender<Result<Option<String>, ErrorStatus>>,
+    ),
+    FindElementElementTagName(
+        String,
+        String,
+        IpcSender<Result<Option<String>, ErrorStatus>>,
+    ),
+    FindElementElementsCSS(String, String, IpcSender<Result<Vec<String>, ErrorStatus>>),
+    FindElementElementsLinkText(
+        String,
+        String,
+        bool,
+        IpcSender<Result<Vec<String>, ErrorStatus>>,
+    ),
+    FindElementElementsTagName(String, String, IpcSender<Result<Vec<String>, ErrorStatus>>),
+    FocusElement(String, IpcSender<Result<(), ErrorStatus>>),
+    ElementClick(String, IpcSender<Result<Option<String>, ErrorStatus>>),
+    GetActiveElement(IpcSender<Option<String>>),
+    GetCookie(String, IpcSender<Vec<Serde<Cookie<'static>>>>),
+    GetCookies(IpcSender<Vec<Serde<Cookie<'static>>>>),
+    GetElementAttribute(
+        String,
+        String,
+        IpcSender<Result<Option<String>, ErrorStatus>>,
+    ),
+    GetElementProperty(
+        String,
+        String,
+        IpcSender<Result<WebDriverJSValue, ErrorStatus>>,
+    ),
+    GetElementCSS(String, String, IpcSender<Result<String, ErrorStatus>>),
+    GetElementRect(String, IpcSender<Result<Rect<f64>, ErrorStatus>>),
+    GetElementTagName(String, IpcSender<Result<String, ErrorStatus>>),
+    GetElementText(String, IpcSender<Result<String, ErrorStatus>>),
+    GetElementInViewCenterPoint(String, IpcSender<Result<Option<(i64, i64)>, ErrorStatus>>),
+    GetBoundingClientRect(String, IpcSender<Result<Rect<f32>, ErrorStatus>>),
+    GetBrowsingContextId(
+        WebDriverFrameId,
+        IpcSender<Result<BrowsingContextId, ErrorStatus>>,
+    ),
+    GetUrl(IpcSender<ServoUrl>),
+    GetPageSource(IpcSender<Result<String, ErrorStatus>>),
+    IsEnabled(String, IpcSender<Result<bool, ErrorStatus>>),
+    IsSelected(String, IpcSender<Result<bool, ErrorStatus>>),
+    GetTitle(IpcSender<String>),
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub enum WebDriverCookieError {
+    InvalidDomain,
+    UnableToSetCookie,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub enum WebDriverJSValue {
+    Undefined,
+    Null,
+    Boolean(bool),
+    Number(f64),
+    String(String),
+    Element(WebElement),
+    Frame(WebFrame),
+    Window(WebWindow),
+    ArrayLike(Vec<WebDriverJSValue>),
+    Object(HashMap<String, WebDriverJSValue>),
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub enum WebDriverJSError {
+    /// Occurs when handler received an event message for a layout channel that is not
+    /// associated with the current script thread
+    BrowsingContextNotFound,
+    JSError,
+    StaleElementReference,
+    Timeout,
+    UnknownType,
+}
+
+pub type WebDriverJSResult = Result<WebDriverJSValue, WebDriverJSError>;
+
+#[derive(Debug, Deserialize, Serialize)]
+pub enum WebDriverFrameId {
+    Short(u16),
+    Element(String),
+    Parent,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub enum LoadStatus {
+    LoadComplete,
+    LoadTimeout,
+}