Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-23 07:13:52 +01:00
Code Issues Projects Releases Packages Wiki Activity

Eliminate duplicate Layout DOM wrappers

Browse source 
There are duplicate sets of Layout DOM wrappers: one for Layout 2013 and
one for Layout 2020. As part of cleaning up and simplifying the
wrappers, this change parameterizes them on the specific layout data
they contain. This allows them to be shared again. In addition, various
small cleanups are included.

Fixes #29691.
This commit is contained in:
Martin Robinson 2023-05-02 08:35:33 +02:00
parent ab0d462c83
commit 2d31d4301d
14 changed files with 1035 additions and 2362 deletions
Download patch file Download diff file Expand all files Collapse all files

3
Cargo.lock generated
View file

@ -5242,6 +5242,7 @@ dependencies = [
"accountable-refcell",
"app_units",
"arrayvec 0.7.1",
"atomic_refcell",
"backtrace",
"base64 0.10.1",
"bitflags",
@ -5263,6 +5264,7 @@ dependencies = [
"euclid",
"fnv",
"fxhash",
"gfx_traits",
"headers",
"html5ever",
"http",
@ -5295,6 +5297,7 @@ dependencies = [
"phf_shared 0.8.0",
"pixels",
"profile_traits",
"range",
"ref_filter_map",
"regex",
"script_layout_interface",

8
components/layout/data.rs
View file

@ -4,6 +4,7 @@
use crate::construct::ConstructionResult;
use atomic_refcell::AtomicRefCell;
use script_layout_interface::wrapper_traits::LayoutDataTrait;
use script_layout_interface::StyleData;
pub struct StyleAndLayoutData<'dom> {
@ -14,6 +15,7 @@ pub struct StyleAndLayoutData<'dom> {
}
/// Data that layout associates with a node.
#[derive(Clone)]
pub struct LayoutData {
/// The current results of flow construction for this node. This is either a
/// flow or a `ConstructionItem`. See comments in `construct.rs` for more
@ -32,9 +34,11 @@ pub struct LayoutData {
pub flags: LayoutDataFlags,
}
impl LayoutData {
impl LayoutDataTrait for LayoutData {}
impl Default for LayoutData {
/// Creates new layout data.
pub fn new() -> LayoutData {
fn default() -> LayoutData {
Self {
flow_construction_result: ConstructionResult::None,
before_flow_construction_result: ConstructionResult::None,

3
components/layout_2020/element_data.rs
View file

@ -6,6 +6,7 @@ use crate::cell::ArcRefCell;
use crate::flexbox::FlexLevelBox;
use crate::flow::inline::InlineLevelBox;
use crate::flow::BlockLevelBox;
use script_layout_interface::wrapper_traits::LayoutDataTrait;
#[derive(Default)]
pub struct LayoutDataForElement {
@ -20,3 +21,5 @@ pub(super) enum LayoutBox {
InlineLevel(ArcRefCell<InlineLevelBox>),
FlexLevel(ArcRefCell<FlexLevelBox>),
}
impl LayoutDataTrait for LayoutDataForElement {}

40
components/layout_thread/lib.rs
View file

@ -11,8 +11,6 @@
#[macro_use]
extern crate crossbeam_channel;
#[macro_use]
extern crate html5ever;
#[macro_use]
extern crate layout;
#[macro_use]
extern crate lazy_static;
@ -21,9 +19,6 @@ extern crate log;
#[macro_use]
extern crate profile_traits;
mod dom_wrapper;
use crate::dom_wrapper::{ServoLayoutDocument, ServoLayoutElement, ServoLayoutNode};
use app_units::Au;
use crossbeam_channel::{Receiver, Sender};
use embedder_traits::resources::{self, Resource};
@ -47,7 +42,6 @@ use layout::display_list::{IndexableText, ToLayout};
use layout::flow::{Flow, FlowFlags, GetBaseFlow, ImmutableFlowUtils, MutableOwnedFlowUtils};
use layout::flow_ref::FlowRef;
use layout::incremental::{RelayoutMode, SpecialRestyleDamage};
use layout::layout_debug;
use layout::parallel;
use layout::query::{
process_client_rect_query, process_content_box_request, process_content_boxes_request,
@ -62,6 +56,7 @@ use layout::traversal::{
RecalcStyleAndConstructFlows,
};
use layout::wrapper::LayoutNodeLayoutData;
use layout::{layout_debug, LayoutData};
use layout_traits::LayoutThreadFactory;
use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
use metrics::{PaintTimeMetrics, ProfilerMetadataFactory, ProgressiveWebMetric};
@ -75,6 +70,7 @@ use parking_lot::RwLock;
use profile_traits::mem::{self as profile_mem, Report, ReportKind, ReportsChan};
use profile_traits::time::{self as profile_time, profile, TimerMetadata};
use profile_traits::time::{TimerMetadataFrameType, TimerMetadataReflowType};
use script::layout_dom::{ServoLayoutDocument, ServoLayoutElement, ServoLayoutNode};
use script_layout_interface::message::{LayoutThreadInit, Msg, NodesFromPointQueryType, Reflow};
use script_layout_interface::message::{QueryMsg, ReflowComplete, ReflowGoal, ScriptReflow};
use script_layout_interface::rpc::TextIndexResponse;
@ -976,7 +972,7 @@ impl LayoutThread {
&self,
data: &Reflow,
reflow_goal: &ReflowGoal,
document: Option<&ServoLayoutDocument>,
document: Option<&ServoLayoutDocument<LayoutData>>,
layout_root: &mut dyn Flow,
layout_context: &mut LayoutContext,
rw_data: &mut LayoutThreadData,
@ -1302,11 +1298,16 @@ impl LayoutThread {
let elements_with_snapshot: Vec<_> = restyles
.iter()
.filter(|r| r.1.snapshot.is_some())
.map(|r| unsafe { ServoLayoutNode::new(&r.0).as_element().unwrap() })
.map(|r| unsafe {
ServoLayoutNode::<LayoutData>::new(&r.0)
.as_element()
.unwrap()
})
.collect();
for (el, restyle) in restyles {
let el = unsafe { ServoLayoutNode::new(&el).as_element().unwrap() };
let el: ServoLayoutElement<LayoutData> =
unsafe { ServoLayoutNode::new(&el).as_element().unwrap() };
// If we haven't styled this node yet, we don't need to track a
// restyle.
@ -1357,10 +1358,9 @@ impl LayoutThread {
let traversal = RecalcStyleAndConstructFlows::new(layout_context);
let token = {
let shared =
<RecalcStyleAndConstructFlows as DomTraversal<ServoLayoutElement>>::shared_context(
&traversal,
);
let shared = <RecalcStyleAndConstructFlows as DomTraversal<
ServoLayoutElement<LayoutData>,
>>::shared_context(&traversal);
RecalcStyleAndConstructFlows::pre_traverse(dirty_root, shared)
};
@ -1373,7 +1373,7 @@ impl LayoutThread {
|| {
// Perform CSS selector matching and flow construction.
let root = driver::traverse_dom::<
ServoLayoutElement,
ServoLayoutElement<LayoutData>,
RecalcStyleAndConstructFlows,
>(&traversal, token, thread_pool);
unsafe {
@ -1482,17 +1482,17 @@ impl LayoutThread {
process_node_scroll_area_request(node, root_flow);
},
&QueryMsg::NodeScrollIdQuery(node) => {
let node = unsafe { ServoLayoutNode::new(&node) };
let node: ServoLayoutNode<LayoutData> = unsafe { ServoLayoutNode::new(&node) };
rw_data.scroll_id_response =
Some(process_node_scroll_id_request(self.id, node));
},
&QueryMsg::ResolvedStyleQuery(node, ref pseudo, ref property) => {
let node = unsafe { ServoLayoutNode::new(&node) };
let node: ServoLayoutNode<LayoutData> = unsafe { ServoLayoutNode::new(&node) };
rw_data.resolved_style_response =
process_resolved_style_request(context, node, pseudo, property, root_flow);
},
&QueryMsg::ResolvedFontStyleQuery(node, ref property, ref value) => {
let node = unsafe { ServoLayoutNode::new(&node) };
let node: ServoLayoutNode<LayoutData> = unsafe { ServoLayoutNode::new(&node) };
let url = self.url.clone();
rw_data.resolved_font_style_response = process_resolved_font_style_request(
context,
@ -1528,7 +1528,7 @@ impl LayoutThread {
results.iter().map(|result| result.node).collect()
},
&QueryMsg::ElementInnerTextQuery(node) => {
let node = unsafe { ServoLayoutNode::new(&node) };
let node: ServoLayoutNode<LayoutData> = unsafe { ServoLayoutNode::new(&node) };
rw_data.element_inner_text_response =
process_element_inner_text_query(node, &rw_data.indexable_text);
},
@ -1633,7 +1633,7 @@ impl LayoutThread {
root_flow: &mut FlowRef,
data: &Reflow,
reflow_goal: &ReflowGoal,
document: Option<&ServoLayoutDocument>,
document: Option<&ServoLayoutDocument<LayoutData>>,
rw_data: &mut LayoutThreadData,
context: &mut LayoutContext,
) {
@ -1742,7 +1742,7 @@ impl LayoutThread {
data: &Reflow,
mut root_flow: &mut FlowRef,
reflow_goal: &ReflowGoal,
document: Option<&ServoLayoutDocument>,
document: Option<&ServoLayoutDocument<LayoutData>>,
rw_data: &mut LayoutThreadData,
layout_context: &mut LayoutContext,
) {

1537
components/layout_thread_2020/dom_wrapper.rs
View file

File diff suppressed because it is too large Load diff

40
components/layout_thread_2020/lib.rs
View file

@ -11,17 +11,12 @@
#[macro_use]
extern crate crossbeam_channel;
#[macro_use]
extern crate html5ever;
#[macro_use]
extern crate lazy_static;
#[macro_use]
extern crate log;
#[macro_use]
extern crate profile_traits;
mod dom_wrapper;
use crate::dom_wrapper::{ServoLayoutDocument, ServoLayoutElement, ServoLayoutNode};
use app_units::Au;
use crossbeam_channel::{Receiver, Sender};
use embedder_traits::resources::{self, Resource};
@ -35,6 +30,7 @@ use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
use ipc_channel::router::ROUTER;
use layout::context::LayoutContext;
use layout::display_list::{DisplayListBuilder, WebRenderImageInfo};
use layout::element_data::LayoutDataForElement;
use layout::layout_debug;
use layout::query::{
process_content_box_request, process_content_boxes_request, process_resolved_font_style_query,
@ -60,6 +56,7 @@ use parking_lot::RwLock;
use profile_traits::mem::{self as profile_mem, Report, ReportKind, ReportsChan};
use profile_traits::time::{self as profile_time, profile, TimerMetadata};
use profile_traits::time::{TimerMetadataFrameType, TimerMetadataReflowType};
use script::layout_dom::{ServoLayoutDocument, ServoLayoutElement, ServoLayoutNode};
use script_layout_interface::message::{LayoutThreadInit, Msg, NodesFromPointQueryType};
use script_layout_interface::message::{QueryMsg, ReflowComplete, ReflowGoal, ScriptReflow};
use script_layout_interface::rpc::TextIndexResponse;
@ -804,7 +801,7 @@ impl LayoutThread {
data: &mut ScriptReflowResult,
possibly_locked_rw_data: &mut RwData<'a, 'b>,
) {
let document = unsafe { ServoLayoutNode::new(&data.document) };
let document = unsafe { ServoLayoutNode::<LayoutDataForElement>::new(&data.document) };
let document = document.as_document().unwrap();
let mut rw_data = possibly_locked_rw_data.lock();
@ -959,11 +956,19 @@ impl LayoutThread {
let elements_with_snapshot: Vec<_> = restyles
.iter()
.filter(|r| r.1.snapshot.is_some())
.map(|r| unsafe { ServoLayoutNode::new(&r.0).as_element().unwrap() })
.map(|r| unsafe {
ServoLayoutNode::<LayoutDataForElement>::new(&r.0)
.as_element()
.unwrap()
})
.collect();
for (el, restyle) in restyles {
let el = unsafe { ServoLayoutNode::new(&el).as_element().unwrap() };
let el = unsafe {
ServoLayoutNode::<LayoutDataForElement>::new(&el)
.as_element()
.unwrap()
};
// If we haven't styled this node yet, we don't need to track a
// restyle.
@ -999,14 +1004,16 @@ impl LayoutThread {
);
let dirty_root = unsafe {
ServoLayoutNode::new(&data.dirty_root.unwrap())
ServoLayoutNode::<LayoutDataForElement>::new(&data.dirty_root.unwrap())
.as_element()
.unwrap()
};
let traversal = RecalcStyle::new(layout_context);
let token = {
let shared = DomTraversal::<ServoLayoutElement>::shared_context(&traversal);
let shared = DomTraversal::<ServoLayoutElement<LayoutDataForElement>>::shared_context(
&traversal,
);
RecalcStyle::pre_traverse(dirty_root, shared)
};
@ -1014,7 +1021,8 @@ impl LayoutThread {
let rayon_pool = rayon_pool.as_ref();
if token.should_traverse() {
let dirty_root = driver::traverse_dom(&traversal, token, rayon_pool).as_node();
let dirty_root: ServoLayoutNode<LayoutDataForElement> =
driver::traverse_dom(&traversal, token, rayon_pool).as_node();
let root_node = root_element.as_node();
let mut box_tree = self.box_tree.borrow_mut();
@ -1126,12 +1134,12 @@ impl LayoutThread {
process_node_scroll_area_request(node, self.fragment_tree.borrow().clone());
},
&QueryMsg::NodeScrollIdQuery(node) => {
let node = unsafe { ServoLayoutNode::new(&node) };
let node = unsafe { ServoLayoutNode::<LayoutDataForElement>::new(&node) };
rw_data.scroll_id_response =
Some(process_node_scroll_id_request(self.id, node));
},
&QueryMsg::ResolvedStyleQuery(node, ref pseudo, ref property) => {
let node = unsafe { ServoLayoutNode::new(&node) };
let node = unsafe { ServoLayoutNode::<LayoutDataForElement>::new(&node) };
let fragment_tree = self.fragment_tree.borrow().clone();
rw_data.resolved_style_response = process_resolved_style_request(
context,
@ -1142,7 +1150,7 @@ impl LayoutThread {
);
},
&QueryMsg::ResolvedFontStyleQuery(node, ref property, ref value) => {
let node = unsafe { ServoLayoutNode::new(&node) };
let node = unsafe { ServoLayoutNode::<LayoutDataForElement>::new(&node) };
rw_data.resolved_font_style_response =
process_resolved_font_style_query(node, property, value);
},
@ -1172,7 +1180,7 @@ impl LayoutThread {
results.iter().map(|result| result.node).collect()
},
&QueryMsg::ElementInnerTextQuery(node) => {
let node = unsafe { ServoLayoutNode::new(&node) };
let node = unsafe { ServoLayoutNode::<LayoutDataForElement>::new(&node) };
rw_data.element_inner_text_response = process_element_inner_text_query(node);
},
&QueryMsg::InnerWindowDimensionsQuery(_browsing_context_id) => {
@ -1232,7 +1240,7 @@ impl LayoutThread {
&self,
fragment_tree: Arc<FragmentTree>,
reflow_goal: &ReflowGoal,
document: Option<&ServoLayoutDocument>,
document: Option<&ServoLayoutDocument<LayoutDataForElement>>,
context: &mut LayoutContext,
) {
Self::cancel_animations_for_nodes_not_in_fragment_tree(

3
components/script/Cargo.toml
View file

@ -33,6 +33,7 @@ serde_json = "1.0"
accountable-refcell = { version = "0.2.0", optional = true }
app_units = "0.7"
arrayvec = "0.7"
atomic_refcell = "0.1"
backtrace = "0.3"
base64 = "0.10.1"
bitflags = "1.0"
@ -54,6 +55,7 @@ enum-iterator = "0.3"
euclid = "0.22"
fnv = "1.0"
fxhash = "0.2"
gfx_traits = { path = "../gfx_traits" }
headers = "0.3"
html5ever = "0.26"
http = "0.2"
@ -83,6 +85,7 @@ percent-encoding = "2.0"
phf = "0.8"
pixels = { path = "../pixels" }
profile_traits = { path = "../profile_traits" }
range = { path = "../range" }
ref_filter_map = "1.0.1"
regex = "1.1"
script_layout_interface = { path = "../script_layout_interface" }

114
components/script/layout_dom/document.rs Normal file
View file

@ -0,0 +1,114 @@
/* 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 crate::dom::bindings::root::LayoutDom;
use crate::dom::document::{Document, LayoutDocumentHelpers};
use crate::dom::node::{LayoutNodeHelpers, Node, NodeFlags};
use crate::layout_dom::ServoLayoutElement;
use crate::layout_dom::ServoLayoutNode;
use crate::layout_dom::ServoShadowRoot;
use script_layout_interface::wrapper_traits::LayoutDataTrait;
use selectors::matching::QuirksMode;
use std::marker::PhantomData;
use style::dom::{TDocument, TNode};
use style::media_queries::Device;
use style::shared_lock::{
SharedRwLock as StyleSharedRwLock, SharedRwLockReadGuard as StyleSharedRwLockReadGuard,
};
// A wrapper around documents that ensures ayout can only ever access safe properties.
pub struct ServoLayoutDocument<'dom, LayoutDataType: LayoutDataTrait> {
/// The wrapped private DOM Document
document: LayoutDom<'dom, Document>,
/// A PhantomData that is used to track the type of the stored layout data.
phantom: PhantomData<LayoutDataType>,
}
impl<'dom, LayoutDataType: LayoutDataTrait> Clone for ServoLayoutDocument<'dom, LayoutDataType> {
fn clone(&self) -> Self {
*self
}
}
impl<'dom, LayoutDataType: LayoutDataTrait> Copy for ServoLayoutDocument<'dom, LayoutDataType> {}
impl<'ld, LayoutDataType: LayoutDataTrait> ::style::dom::TDocument
for ServoLayoutDocument<'ld, LayoutDataType>
{
type ConcreteNode = ServoLayoutNode<'ld, LayoutDataType>;
fn as_node(&self) -> Self::ConcreteNode {
ServoLayoutNode::from_layout_js(self.document.upcast())
}
fn quirks_mode(&self) -> QuirksMode {
self.document.quirks_mode()
}
fn is_html_document(&self) -> bool {
self.document.is_html_document_for_layout()
}
fn shared_lock(&self) -> &StyleSharedRwLock {
self.document.style_shared_lock()
}
}
impl<'ld, LayoutDataType: LayoutDataTrait> ServoLayoutDocument<'ld, LayoutDataType> {
pub fn root_element(&self) -> Option<ServoLayoutElement<'ld, LayoutDataType>> {
self.as_node()
.dom_children()
.flat_map(|n| n.as_element())
.next()
}
pub fn needs_paint_from_layout(&self) {
unsafe { self.document.needs_paint_from_layout() }
}
pub fn will_paint(&self) {
unsafe { self.document.will_paint() }
}
pub fn style_shared_lock(&self) -> &StyleSharedRwLock {
self.document.style_shared_lock()
}
pub fn shadow_roots(&self) -> Vec<ServoShadowRoot<LayoutDataType>> {
unsafe {
self.document
.shadow_roots()
.iter()
.map(|sr| {
debug_assert!(sr.upcast::<Node>().get_flag(NodeFlags::IS_CONNECTED));
ServoShadowRoot::from_layout_js(*sr)
})
.collect()
}
}
pub fn flush_shadow_roots_stylesheets(
&self,
device: &Device,
quirks_mode: QuirksMode,
guard: &StyleSharedRwLockReadGuard,
) {
unsafe {
if !self.document.shadow_roots_styles_changed() {
return;
}
self.document.flush_shadow_roots_stylesheets();
for shadow_root in self.shadow_roots() {
shadow_root.flush_stylesheets(device, quirks_mode, guard);
}
}
}
pub fn from_layout_js(doc: LayoutDom<'ld, Document>) -> Self {
ServoLayoutDocument {
document: doc,
phantom: PhantomData,
}
}
}

918
components/layout_thread/dom_wrapper.rs → components/script/layout_dom/element.rs
View file

File diff suppressed because it is too large Load diff

32
components/script/layout_dom/mod.rs Normal file
View file

@ -0,0 +1,32 @@
/* 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/. */
//! A safe wrapper for DOM nodes that prevents layout from mutating the DOM, from letting DOM nodes
//! escape, and from generally doing anything that it isn't supposed to. This is accomplished via
//! a simple whitelist of allowed operations, along with some lifetime magic to prevent nodes from
//! escaping.
//!
//! As a security wrapper is only as good as its whitelist, be careful when adding operations to
//! this list. The cardinal rules are:
//!
//! 1. Layout is not allowed to mutate the DOM.
//!
//! 2. Layout is not allowed to see anything with `LayoutDom` in the name, because it could hang
//! onto these objects and cause use-after-free.
//!
//! When implementing wrapper functions, be careful that you do not touch the borrow flags, or you
//! will race and cause spurious thread failure. (Note that I do not believe these races are
//! exploitable, but they'll result in brokenness nonetheless.)
#![allow(unsafe_code)]
mod document;
mod element;
mod node;
mod shadow_root;
pub use document::*;
pub use element::*;
pub use node::*;
pub use shadow_root::*;

591
components/script/layout_dom/node.rs Normal file
View file

@ -0,0 +1,591 @@
/* 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(unsafe_code)]
use super::ServoLayoutDocument;
use super::ServoLayoutElement;
use super::ServoShadowRoot;
use super::ServoThreadSafeLayoutElement;
use crate::dom::bindings::inheritance::CharacterDataTypeId;
use crate::dom::bindings::inheritance::{NodeTypeId, TextTypeId};
use crate::dom::bindings::root::LayoutDom;
use crate::dom::characterdata::LayoutCharacterDataHelpers;
use crate::dom::element::{Element, LayoutElementHelpers};
use crate::dom::node::{LayoutNodeHelpers, Node, NodeFlags};
use crate::dom::text::Text;
use atomic_refcell::AtomicRefCell;
use gfx_traits::ByteIndex;
use msg::constellation_msg::{BrowsingContextId, PipelineId};
use net_traits::image::base::{Image, ImageMetadata};
use range::Range;
use script_layout_interface::wrapper_traits::{
DangerousThreadSafeLayoutNode, GetStyleAndOpaqueLayoutData, LayoutDataTrait, LayoutNode,
PseudoElementType, ThreadSafeLayoutNode,
};
use script_layout_interface::{
HTMLCanvasData, HTMLMediaData, LayoutNodeType, SVGSVGData, StyleAndOpaqueLayoutData, StyleData,
TrustedNodeAddress,
};
use servo_arc::Arc;
use servo_url::ServoUrl;
use std::borrow::Cow;
use std::fmt;
use std::marker::PhantomData;
use std::sync::Arc as StdArc;
use style;
use style::context::SharedStyleContext;
use style::dom::{NodeInfo, TElement, TNode, TShadowRoot};
use style::properties::ComputedValues;
use style::str::is_whitespace;
/// A wrapper around a `LayoutDom<Node>` which provides a safe interface that
/// can be used during layout. This implements the `LayoutNode` trait as well as
/// several style and selectors traits for use during layout. This version
/// should only be used on a single thread. If you need to use nodes across
/// threads use ServoThreadSafeLayoutNode.
pub struct ServoLayoutNode<'dom, LayoutDataType: LayoutDataTrait> {
/// The wrapped private DOM node.
pub(super) node: LayoutDom<'dom, Node>,
/// A PhantomData that is used to track the type of the stored layout data.
pub(super) phantom: PhantomData<LayoutDataType>,
}
//// Those are supposed to be sound, but they aren't because the entire system
//// between script and layout so far has been designed to work around their
//// absence. Switching the entire thing to the inert crate infra will help.
///
//// FIXME(mrobinson): These are required because Layout 2020 sends non-threadsafe
//// nodes to different threads. This should be adressed in a comprehensive way.
unsafe impl<LayoutDataType: LayoutDataTrait> Send for ServoLayoutNode<'_, LayoutDataType> {}
unsafe impl<LayoutDataType: LayoutDataTrait> Sync for ServoLayoutNode<'_, LayoutDataType> {}
// These impls are required because `derive` has trouble with PhantomData.
// See https://github.com/rust-lang/rust/issues/52079
impl<'dom, LayoutDataType: LayoutDataTrait> Clone for ServoLayoutNode<'dom, LayoutDataType> {
fn clone(&self) -> Self {
*self
}
}
impl<'dom, LayoutDataType: LayoutDataTrait> Copy for ServoLayoutNode<'dom, LayoutDataType> {}
impl<'a, LayoutDataType: LayoutDataTrait> PartialEq for ServoLayoutNode<'a, LayoutDataType> {
#[inline]
fn eq(&self, other: &Self) -> bool {
self.node == other.node
}
}
impl<'dom, LayoutDataType: LayoutDataTrait> fmt::Debug for ServoLayoutNode<'dom, LayoutDataType> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if let Some(el) = self.as_element() {
el.fmt(f)
} else {
if self.is_text_node() {
write!(f, "<text node> ({:#x})", self.opaque().0)
} else {
write!(f, "<non-text node> ({:#x})", self.opaque().0)
}
}
}
}
impl<'dom, LayoutDataType: LayoutDataTrait> ServoLayoutNode<'dom, LayoutDataType> {
pub(super) fn from_layout_js(n: LayoutDom<'dom, Node>) -> Self {
ServoLayoutNode {
node: n,
phantom: PhantomData,
}
}
pub unsafe fn new(address: &TrustedNodeAddress) -> Self {
ServoLayoutNode::from_layout_js(LayoutDom::from_trusted_node_address(*address))
}
pub(super) fn script_type_id(&self) -> NodeTypeId {
self.node.type_id_for_layout()
}
/// Returns the interior of this node as a `LayoutDom`.
pub fn get_jsmanaged(self) -> LayoutDom<'dom, Node> {
self.node
}
}
impl<'dom, LayoutDataType: LayoutDataTrait> style::dom::NodeInfo
for ServoLayoutNode<'dom, LayoutDataType>
{
fn is_element(&self) -> bool {
self.node.is_element_for_layout()
}
fn is_text_node(&self) -> bool {
self.script_type_id() ==
NodeTypeId::CharacterData(CharacterDataTypeId::Text(TextTypeId::Text))
}
}
impl<'dom, LayoutDataType: LayoutDataTrait> style::dom::TNode
for ServoLayoutNode<'dom, LayoutDataType>
{
type ConcreteDocument = ServoLayoutDocument<'dom, LayoutDataType>;
type ConcreteElement = ServoLayoutElement<'dom, LayoutDataType>;
type ConcreteShadowRoot = ServoShadowRoot<'dom, LayoutDataType>;
fn parent_node(&self) -> Option<Self> {
self.node
.composed_parent_node_ref()
.map(Self::from_layout_js)
}
fn first_child(&self) -> Option<Self> {
self.node.first_child_ref().map(Self::from_layout_js)
}
fn last_child(&self) -> Option<Self> {
self.node.last_child_ref().map(Self::from_layout_js)
}
fn prev_sibling(&self) -> Option<Self> {
self.node.prev_sibling_ref().map(Self::from_layout_js)
}
fn next_sibling(&self) -> Option<Self> {
self.node.next_sibling_ref().map(Self::from_layout_js)
}
fn owner_doc(&self) -> Self::ConcreteDocument {
ServoLayoutDocument::from_layout_js(self.node.owner_doc_for_layout())
}
fn traversal_parent(&self) -> Option<ServoLayoutElement<'dom, LayoutDataType>> {
let parent = self.parent_node()?;
if let Some(shadow) = parent.as_shadow_root() {
return Some(shadow.host());
};
parent.as_element()
}
fn opaque(&self) -> style::dom::OpaqueNode {
self.get_jsmanaged().opaque()
}
fn debug_id(self) -> usize {
self.opaque().0
}
fn as_element(&self) -> Option<ServoLayoutElement<'dom, LayoutDataType>> {
self.node.downcast().map(ServoLayoutElement::from_layout_js)
}
fn as_document(&self) -> Option<ServoLayoutDocument<'dom, LayoutDataType>> {
self.node
.downcast()
.map(ServoLayoutDocument::from_layout_js)
}
fn as_shadow_root(&self) -> Option<ServoShadowRoot<'dom, LayoutDataType>> {
self.node.downcast().map(ServoShadowRoot::from_layout_js)
}
fn is_in_document(&self) -> bool {
unsafe { self.node.get_flag(NodeFlags::IS_IN_DOC) }
}
}
impl<'dom, LayoutDataType: LayoutDataTrait> LayoutNode<'dom>
for ServoLayoutNode<'dom, LayoutDataType>
{
type ConcreteThreadSafeLayoutNode = ServoThreadSafeLayoutNode<'dom, LayoutDataType>;
fn to_threadsafe(&self) -> Self::ConcreteThreadSafeLayoutNode {
ServoThreadSafeLayoutNode::new(*self)
}
fn type_id(&self) -> LayoutNodeType {
self.script_type_id().into()
}
unsafe fn initialize_data(&self) {
if self.get_style_and_opaque_layout_data().is_none() {
let opaque = StyleAndOpaqueLayoutData::new(
StyleData::new(),
AtomicRefCell::new(LayoutDataType::default()),
);
self.init_style_and_opaque_layout_data(opaque);
};
}
unsafe fn init_style_and_opaque_layout_data(&self, data: Box<StyleAndOpaqueLayoutData>) {
self.get_jsmanaged().init_style_and_opaque_layout_data(data);
}
unsafe fn take_style_and_opaque_layout_data(&self) -> Box<StyleAndOpaqueLayoutData> {
self.get_jsmanaged().take_style_and_opaque_layout_data()
}
fn is_connected(&self) -> bool {
unsafe { self.node.get_flag(NodeFlags::IS_CONNECTED) }
}
}
impl<'dom, LayoutDataType: LayoutDataTrait> GetStyleAndOpaqueLayoutData<'dom>
for ServoLayoutNode<'dom, LayoutDataType>
{
fn get_style_and_opaque_layout_data(self) -> Option<&'dom StyleAndOpaqueLayoutData> {
self.get_jsmanaged().get_style_and_opaque_layout_data()
}
}
/// A wrapper around a `ServoLayoutNode` that can be used safely on different threads.
/// It's very important that this never mutate anything except this wrapped node and
/// never access any other node apart from its parent.
pub struct ServoThreadSafeLayoutNode<'dom, LayoutDataType: LayoutDataTrait> {
/// The wrapped `ServoLayoutNode`.
pub(super) node: ServoLayoutNode<'dom, LayoutDataType>,
/// The pseudo-element type, with (optionally)
/// a specified display value to override the stylesheet.
pub(super) pseudo: PseudoElementType,
}
// These impls are required because `derive` has trouble with PhantomData.
// See https://github.com/rust-lang/rust/issues/52079
impl<'dom, LayoutDataType: LayoutDataTrait> Clone
for ServoThreadSafeLayoutNode<'dom, LayoutDataType>
{
fn clone(&self) -> Self {
*self
}
}
impl<'dom, LayoutDataType: LayoutDataTrait> Copy
for ServoThreadSafeLayoutNode<'dom, LayoutDataType>
{
}
impl<'a, LayoutDataType: LayoutDataTrait> PartialEq
for ServoThreadSafeLayoutNode<'a, LayoutDataType>
{
#[inline]
fn eq(&self, other: &Self) -> bool {
self.node == other.node
}
}
impl<'lr, LayoutDataType: LayoutDataTrait> fmt::Debug
for ServoThreadSafeLayoutNode<'lr, LayoutDataType>
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.node.fmt(f)
}
}
impl<'dom, LayoutDataType: LayoutDataTrait> DangerousThreadSafeLayoutNode<'dom>
for ServoThreadSafeLayoutNode<'dom, LayoutDataType>
{
unsafe fn dangerous_first_child(&self) -> Option<Self> {
self.get_jsmanaged()
.first_child_ref()
.map(ServoLayoutNode::from_layout_js)
.map(Self::new)
}
unsafe fn dangerous_next_sibling(&self) -> Option<Self> {
self.get_jsmanaged()
.next_sibling_ref()
.map(ServoLayoutNode::from_layout_js)
.map(Self::new)
}
}
impl<'dom, LayoutDataType: LayoutDataTrait> ServoThreadSafeLayoutNode<'dom, LayoutDataType> {
/// Creates a new `ServoThreadSafeLayoutNode` from the given `ServoLayoutNode`.
pub fn new(node: ServoLayoutNode<'dom, LayoutDataType>) -> Self {
ServoThreadSafeLayoutNode {
node: node.clone(),
pseudo: PseudoElementType::Normal,
}
}
/// Returns the interior of this node as a `LayoutDom`. This is highly unsafe for layout to
/// call and as such is marked `unsafe`.
unsafe fn get_jsmanaged(&self) -> LayoutDom<'dom, Node> {
self.node.get_jsmanaged()
}
}
impl<'dom, LayoutDataType: LayoutDataTrait> style::dom::NodeInfo
for ServoThreadSafeLayoutNode<'dom, LayoutDataType>
{
fn is_element(&self) -> bool {
self.node.is_element()
}
fn is_text_node(&self) -> bool {
self.node.is_text_node()
}
}
impl<'dom, LayoutDataType: LayoutDataTrait> ThreadSafeLayoutNode<'dom>
for ServoThreadSafeLayoutNode<'dom, LayoutDataType>
{
type ConcreteNode = ServoLayoutNode<'dom, LayoutDataType>;
type ConcreteThreadSafeLayoutElement = ServoThreadSafeLayoutElement<'dom, LayoutDataType>;
type ConcreteElement = ServoLayoutElement<'dom, LayoutDataType>;
type ChildrenIterator = ThreadSafeLayoutNodeChildrenIterator<Self>;
fn opaque(&self) -> style::dom::OpaqueNode {
unsafe { self.get_jsmanaged().opaque() }
}
fn type_id(&self) -> Option<LayoutNodeType> {
if self.pseudo == PseudoElementType::Normal {
Some(self.node.type_id())
} else {
None
}
}
fn parent_style(&self) -> Arc<ComputedValues> {
let parent = self.node.parent_node().unwrap().as_element().unwrap();
let parent_data = parent.borrow_data().unwrap();
parent_data.styles.primary().clone()
}
fn debug_id(self) -> usize {
self.node.debug_id()
}
fn children(&self) -> style::dom::LayoutIterator<Self::ChildrenIterator> {
if let Some(shadow) = self.node.as_element().and_then(|e| e.shadow_root()) {
return style::dom::LayoutIterator(ThreadSafeLayoutNodeChildrenIterator::new(
shadow.as_node().to_threadsafe(),
));
}
style::dom::LayoutIterator(ThreadSafeLayoutNodeChildrenIterator::new(*self))
}
fn as_element(&self) -> Option<ServoThreadSafeLayoutElement<'dom, LayoutDataType>> {
self.node
.as_element()
.map(|el| ServoThreadSafeLayoutElement {
element: el,
pseudo: self.pseudo,
})
}
fn get_style_and_opaque_layout_data(self) -> Option<&'dom StyleAndOpaqueLayoutData> {
self.node.get_style_and_opaque_layout_data()
}
fn is_ignorable_whitespace(&self, context: &SharedStyleContext) -> bool {
unsafe {
let text: LayoutDom<Text> = match self.get_jsmanaged().downcast() {
Some(text) => text,
None => return false,
};
if !is_whitespace(text.upcast().data_for_layout()) {
return false;
}
// NB: See the rules for `white-space` here:
//
// http://www.w3.org/TR/CSS21/text.html#propdef-white-space
//
// If you implement other values for this property, you will almost certainly
// want to update this check.
!self
.style(context)
.get_inherited_text()
.white_space
.preserve_newlines()
}
}
unsafe fn unsafe_get(self) -> Self::ConcreteNode {
self.node
}
fn node_text_content(self) -> Cow<'dom, str> {
unsafe { self.get_jsmanaged().text_content() }
}
fn selection(&self) -> Option<Range<ByteIndex>> {
let this = unsafe { self.get_jsmanaged() };
this.selection().map(|range| {
Range::new(
ByteIndex(range.start as isize),
ByteIndex(range.len() as isize),
)
})
}
fn image_url(&self) -> Option<ServoUrl> {
let this = unsafe { self.get_jsmanaged() };
this.image_url()
}
fn image_density(&self) -> Option<f64> {
let this = unsafe { self.get_jsmanaged() };
this.image_density()
}
fn image_data(&self) -> Option<(Option<StdArc<Image>>, Option<ImageMetadata>)> {
let this = unsafe { self.get_jsmanaged() };
this.image_data()
}
fn canvas_data(&self) -> Option<HTMLCanvasData> {
let this = unsafe { self.get_jsmanaged() };
this.canvas_data()
}
fn media_data(&self) -> Option<HTMLMediaData> {
let this = unsafe { self.get_jsmanaged() };
this.media_data()
}
fn svg_data(&self) -> Option<SVGSVGData> {
let this = unsafe { self.get_jsmanaged() };
this.svg_data()
}
// Can return None if the iframe has no nested browsing context
fn iframe_browsing_context_id(&self) -> Option<BrowsingContextId> {
let this = unsafe { self.get_jsmanaged() };
this.iframe_browsing_context_id()
}
// Can return None if the iframe has no nested browsing context
fn iframe_pipeline_id(&self) -> Option<PipelineId> {
let this = unsafe { self.get_jsmanaged() };
this.iframe_pipeline_id()
}
fn get_colspan(&self) -> u32 {
unsafe {
self.get_jsmanaged()
.downcast::<Element>()
.unwrap()
.get_colspan()
}
}
fn get_rowspan(&self) -> u32 {
unsafe {
self.get_jsmanaged()
.downcast::<Element>()
.unwrap()
.get_rowspan()
}
}
}
pub struct ThreadSafeLayoutNodeChildrenIterator<ConcreteNode> {
current_node: Option<ConcreteNode>,
parent_node: ConcreteNode,
}
impl<'dom, ConcreteNode> ThreadSafeLayoutNodeChildrenIterator<ConcreteNode>
where
ConcreteNode: DangerousThreadSafeLayoutNode<'dom>,
{
pub fn new(parent: ConcreteNode) -> Self {
let first_child: Option<ConcreteNode> = match parent.get_pseudo_element_type() {
PseudoElementType::Normal => parent
.get_before_pseudo()
.or_else(|| parent.get_details_summary_pseudo())
.or_else(|| unsafe { parent.dangerous_first_child() }),
PseudoElementType::DetailsContent | PseudoElementType::DetailsSummary => unsafe {
parent.dangerous_first_child()
},
_ => None,
};
ThreadSafeLayoutNodeChildrenIterator {
current_node: first_child,
parent_node: parent,
}
}
}
impl<'dom, ConcreteNode> Iterator for ThreadSafeLayoutNodeChildrenIterator<ConcreteNode>
where
ConcreteNode: DangerousThreadSafeLayoutNode<'dom>,
{
type Item = ConcreteNode;
fn next(&mut self) -> Option<ConcreteNode> {
use selectors::Element;
match self.parent_node.get_pseudo_element_type() {
PseudoElementType::Before | PseudoElementType::After => None,
PseudoElementType::DetailsSummary => {
let mut current_node = self.current_node.clone();
loop {
let next_node = if let Some(ref node) = current_node {
if let Some(element) = node.as_element() {
if element.has_local_name(&local_name!("summary")) &&
element.has_namespace(&ns!(html))
{
self.current_node = None;
return Some(node.clone());
}
}
unsafe { node.dangerous_next_sibling() }
} else {
self.current_node = None;
return None;
};
current_node = next_node;
}
},
PseudoElementType::DetailsContent => {
let node = self.current_node.clone();
let node = node.and_then(|node| {
if node.is_element() &&
node.as_element()
.unwrap()
.has_local_name(&local_name!("summary")) &&
node.as_element().unwrap().has_namespace(&ns!(html))
{
unsafe { node.dangerous_next_sibling() }
} else {
Some(node)
}
});
self.current_node = node.and_then(|node| unsafe { node.dangerous_next_sibling() });
node
},
PseudoElementType::Normal => {
let node = self.current_node.clone();
if let Some(ref node) = node {
self.current_node = match node.get_pseudo_element_type() {
PseudoElementType::Before => self
.parent_node
.get_details_summary_pseudo()
.or_else(|| unsafe { self.parent_node.dangerous_first_child() })
.or_else(|| self.parent_node.get_after_pseudo()),
PseudoElementType::Normal => unsafe { node.dangerous_next_sibling() }
.or_else(|| self.parent_node.get_after_pseudo()),
PseudoElementType::DetailsSummary => {
self.parent_node.get_details_content_pseudo()
},
PseudoElementType::DetailsContent => self.parent_node.get_after_pseudo(),
PseudoElementType::After => None,
};
}
node
},
}
}
}
impl<'dom, LayoutDataType: LayoutDataTrait> GetStyleAndOpaqueLayoutData<'dom>
for ServoThreadSafeLayoutNode<'dom, LayoutDataType>
{
fn get_style_and_opaque_layout_data(self) -> Option<&'dom StyleAndOpaqueLayoutData> {
self.node.get_style_and_opaque_layout_data()
}
}

84
components/script/layout_dom/shadow_root.rs Normal file
View file

@ -0,0 +1,84 @@
/* 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 crate::dom::bindings::root::LayoutDom;
use crate::dom::shadowroot::{LayoutShadowRootHelpers, ShadowRoot};
use crate::layout_dom::ServoLayoutElement;
use crate::layout_dom::ServoLayoutNode;
use script_layout_interface::wrapper_traits::LayoutDataTrait;
use selectors::matching::QuirksMode;
use std::fmt;
use std::marker::PhantomData;
use style::dom::TShadowRoot;
use style::media_queries::Device;
use style::shared_lock::SharedRwLockReadGuard as StyleSharedRwLockReadGuard;
use style::stylist::CascadeData;
pub struct ServoShadowRoot<'dom, LayoutDataType: LayoutDataTrait> {
/// The wrapped private DOM ShadowRoot.
shadow_root: LayoutDom<'dom, ShadowRoot>,
/// A PhantomData that is used to track the type of the stored layout data.
phantom: PhantomData<LayoutDataType>,
}
impl<'dom, LayoutDataType: LayoutDataTrait> Clone for ServoShadowRoot<'dom, LayoutDataType> {
fn clone(&self) -> Self {
*self
}
}
impl<'dom, LayoutDataType: LayoutDataTrait> Copy for ServoShadowRoot<'dom, LayoutDataType> {}
impl<'a, LayoutDataType: LayoutDataTrait> PartialEq for ServoShadowRoot<'a, LayoutDataType> {
#[inline]
fn eq(&self, other: &Self) -> bool {
self.shadow_root == other.shadow_root
}
}
impl<'dom, LayoutDataType: LayoutDataTrait> fmt::Debug for ServoShadowRoot<'dom, LayoutDataType> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.as_node().fmt(f)
}
}
impl<'dom, LayoutDataType: LayoutDataTrait> ::style::dom::TShadowRoot
for ServoShadowRoot<'dom, LayoutDataType>
{
type ConcreteNode = ServoLayoutNode<'dom, LayoutDataType>;
fn as_node(&self) -> Self::ConcreteNode {
ServoLayoutNode::from_layout_js(self.shadow_root.upcast())
}
fn host(&self) -> ServoLayoutElement<'dom, LayoutDataType> {
ServoLayoutElement::from_layout_js(self.shadow_root.get_host_for_layout())
}
fn style_data<'a>(&self) -> Option<&'a CascadeData>
where
Self: 'a,
{
Some(&self.shadow_root.get_style_data_for_layout())
}
}
impl<'dom, LayoutDataType: LayoutDataTrait> ServoShadowRoot<'dom, LayoutDataType> {
pub(super) fn from_layout_js(shadow_root: LayoutDom<'dom, ShadowRoot>) -> Self {
ServoShadowRoot {
shadow_root,
phantom: PhantomData,
}
}
pub unsafe fn flush_stylesheets(
&self,
device: &Device,
quirks_mode: QuirksMode,
guard: &StyleSharedRwLockReadGuard,
) {
self.shadow_root
.flush_stylesheets::<ServoLayoutElement<LayoutDataType>>(device, quirks_mode, guard)
}
}

22
components/script/lib.rs
View file

@ -73,6 +73,8 @@ mod image_listener;
mod init;
#[warn(deprecated)]
mod layout_image;
pub mod layout_dom;
#[warn(deprecated)]
mod mem;
#[warn(deprecated)]
@ -115,23 +117,3 @@ mod window_named_properties;
pub use init::init;
pub use script_runtime::JSEngineSetup;
/// A module with everything layout can use from script.
///
/// Try to keep this small!
///
/// TODO(emilio): A few of the FooHelpers can go away, presumably...
pub mod layout_exports {
pub use crate::dom::bindings::inheritance::{
CharacterDataTypeId, DocumentFragmentTypeId, ElementTypeId,
};
pub use crate::dom::bindings::inheritance::{HTMLElementTypeId, NodeTypeId, TextTypeId};
pub use crate::dom::bindings::root::LayoutDom;
pub use crate::dom::characterdata::LayoutCharacterDataHelpers;
pub use crate::dom::document::{Document, LayoutDocumentHelpers};
pub use crate::dom::element::{Element, LayoutElementHelpers};
pub use crate::dom::node::NodeFlags;
pub use crate::dom::node::{LayoutNodeHelpers, Node};
pub use crate::dom::shadowroot::{LayoutShadowRootHelpers, ShadowRoot};
pub use crate::dom::text::Text;
}

2
components/script_layout_interface/wrapper_traits.rs
View file

@ -31,6 +31,8 @@ use style::selector_parser::{PseudoElement, PseudoElementCascadeType, SelectorIm
use style::stylist::RuleInclusion;
use webrender_api::ExternalScrollId;
pub trait LayoutDataTrait: Default + Send + Sync + 'static {}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PseudoElementType {
Normal,